281 Commits
Author SHA1 Message Date
Brues 3e50a0b34f Turn on countdownForCooldowns when migrating the old cooldown settings
pfUI drew its own cooldown numbers before; the native countdown shows
them only with the countdownForCooldowns cvar on, and only the first-run
setup set it. Upgraded installs showed no numbers at all, so the
cooldown settings migration turns the cvar on as it removes
appearance.cd.
2026-11-01 00:23:39 -05:00
Brues 3faeafdfc5 Migrate the old cooldown settings into C.cooldown
The shared appearance.cd values (font, size, threshold, tenths, colors)
move to the cooldown table. "Enable Durations On Foreign Frames" and
"Hide Foreign Cooldown Animations" become the Other Addons numbers and
sweep; the spellbook and character slots take that sweep, and the
foreign numbers when "Enable Durations On Blizzard Frames" was off.

Each module's old options move to its kind: the bars, bags and totems
reverse, the buffs sweep and reverse, and the nameplate debuff text,
sweep and reverse, with "Enable Debuff Timers" off turning off both
numbers and sweep. Unit frames had one set per frame and now share one:
the target frame's timer options and the raid frames' "Show Time Left"
stand for the rest. The per-frame keys, appearance.cd and bars.cd_size
are removed.

The migration is keyed on the old keys rather than the version, so it
also runs on dev installs, and runs once.
2026-10-31 23:52:28 -05:00
Brues b2cffcb3c2 Load each module and skin through securecallfunction so one error no longer stops the rest from loading 2026-10-31 21:17:42 -05:00
Brues 5476a28982 Skin menu dividers: CreateMenuDivider draws a 1px border-colored line; use it in the radar menu 2026-10-31 21:04:11 -05:00
Brues e38d028677 Retire libtipscan: libpredict reads HoT set bonuses from the item set data, the professions skin shows the crafted item's tooltip frame in the detail pane 2026-10-31 20:19:25 -05:00
Brues 987c244591 Load only the client's locale strings; abbreviate numbers through ClassicAPI's numeric formatter; build the module environment once instead of on every load 2026-10-31 20:01:05 -05:00
Brues 14a26b8301 Replace saved-handler wrappers with HookScript; use intrinsic pre/postcall bindings for barbershop and SetHighlight 2026-10-31 19:47:41 -05:00
Brues b2e89b461c Hook OnClick/OnEnter/OnLeave instead of wrapping saved handlers; drop dead TBC bank-slot OnUpdate 2026-10-31 19:40:51 -05:00
Brues 907d282a68 Centralize cooldown setup and settings
Every pfUI cooldown is now made by CreateCooldown(parent, kind) in the
new api/cooldown.lua, which replaces the cooldown module. A kind names
what the cooldown times: actionbar, bags, blizzard (spellbook and
character), unitframe, indicator, nameplate, buff, tooltip, totem or
lossofcontrol. The pfCooldownType, pfCooldownStyleText,
pfCooldownStyleAnimation and pfCooldownSize fields are gone. The new
file owns everything the cooldowns share:
- the numbers' font and size
- the formatter
- each kind's numbers, sweep and sweep direction
- the GCD threshold for spell kinds
- the CooldownFrame_SetTimer hook for other addons' Cooldown frames
UpdateCooldowns applies changed settings to every cooldown at once.
GetAuraTimer moves here from the unit frames.

All settings live in one C.cooldown table, on one page: Settings ->
Cooldown. It has the shared font, size, threshold, tenths and colors,
then "Show Numbers On", "Show Sweep On" and "Reverse Sweep On" lists
with a checkbox per kind. The per-module options are removed:
- each unit frame's timer text, animation and reverse, and the
  indicators' "Show Time Left"
- the nameplate debuff timer options
- the Blizzard and foreign font sizes and toggles
- Action Bars' cooldown text size
- the reverse options of bars, bags, buffs and totems
The old appearance.cd settings are not migrated.

The player buff frame and the tooltip aura icons now show the native
countdown too, which replaces their own text and OnUpdate ticking. The
buff frame keeps its inside or below-the-icon placement. Weapon
enchants report only their time left, so they start through
SetCooldownTimeLeft: numbers, no sweep. A slim poll remains for their
charges and renewals, since no event reports those. Buff indicators
now take the aura's real duration, which gives them a correct sweep.
The spellbook and character slots now hide GCD numbers like the other
spell cooldowns.
2026-10-31 19:17:14 -05:00
Brues 149c8cb3c3 Bump CAPI min to 11813 2026-10-31 19:00:19 -05:00
Brues 93ab07a662 Show cooldown text through ClassicAPI's native countdown
The cooldown module no longer builds its own text frame with a 10 Hz
OnUpdate per cooldown. The CooldownFrame_SetTimer hook now configures
each Cooldown frame's own countdown instead: SetHideCountdownNumbers
for the per-frame text toggles and omnicc's noCooldownCount,
SetMinimumCountdownDuration for the GCD threshold, and
GetCountdownFontString for the pfUI font and size. The engine ticks
the numbers, gated by the countdownForCooldowns cvar. The cvar gets a
checkbox in the Cooldown settings, and pfUI.SetupCVars turns it on.

The text comes from one shared C_StringUtil numeric rule formatter,
given to each frame with SetCountdownFormatter. Its breakpoints keep
pfUI's format: the number in its unit's cooldown color, a unit (m/h/d)
once the unit below passes 99, and tenths in the low color when
milliseconds are on. Values now round up. GetColoredTimeString formats
through the same formatter, so the buff, buffwatch and tooltip timers
match. A config:changed callback rebuilds the breakpoints, and every
frame picks them up on its next update.

The paper-doll slots swap their indicator Models for Cooldown frames,
as the spellbook and bags already do. They and the spellbook take the
BLIZZARD tag when they are created, replacing the per-update hooks in
the skin module. Models get no numbers. Hide Foreign Cooldown
Animations clears the draw flags instead of setting alpha to 0, so the
numbers stay visible. The buff module's sweep hides its numbers
because buff.timer carries the text.
2026-10-31 18:45:17 -05:00
Brues 84da90c7d4 Run the raid and questitem delay timers on C_Timer
Both modules waited out their delays in an OnUpdate script. Each now
keeps one C_Timer.NewTimer handle and cancels it whenever a new request
comes in, so the update runs 0.5 s after the last one.

Raid: the roster pass becomes pfUI.uf.raid:UpdateRoster, and
pfUI.uf.raid:QueueUpdate schedules it. Roster events queue it with a
0.5 s delay; a config change or a tank toggle queues it for the next
frame. The frame no longer shows and hides itself to run the pass, and
the extra 1 s throttle is gone because the debounce already merges
bursts.

Questitem: without the OnUpdate script the scanner frame only handled
events, so it moves onto pfUI.events with one callback per event, and
pfUI.questitem becomes a plain table. The showquest check now lives in
QueueSeed.
2026-10-31 17:25:44 -05:00
Brues d2cefe69cf Add a DBM-style range radar for party and raid members
/radar toggles it and /radar <yards> sets the range; the right-click
menu and the mouse wheel step through 5-40 yd. The map turns with
GetPlayerFacing so ahead is up, and ClassicAPI.UnitPosition places
class-colored dots (the mirrored name, since SuperWoW takes the global
with x, y, z order).

The range ring is two stacked TempPortraitAlphaMask discs: a ring-color
disc under a slightly smaller background-color one. It turns red when a
member is inside the range, and a list under the radar shows the five
nearest with their raid markers inline. Raid markers come from the
markN tokens, so marked mobs show too and a marked member shows the
marker instead of a dot.

Units behind terrain (UnitInLineOfSight, traced 4x a second) are
dimmed. Units on another floor, over 5 yd up or down and steeper than
45 degrees so hills don't count, get an arrow above or below them.
Hovering a blip shows its name, distance and both states; clicking a
blip or a list row targets it.
2026-10-31 17:17:35 -05:00
Brues 9da2d459dd Fix dressup Undress button text: UNDRESS global doesn't exist in 1.12.1 2026-10-31 16:43:29 -05:00
Brues 2b7febf617 Replace pfUI's clamp/isempty/modf with ClassicAPI's Clamp/TableIsEmpty
The world map's shift/ctrl wheel alpha and scale use Clamp, and the
fresh-install profile check uses TableIsEmpty (pfUI_init and pfUI_config
are always tables by then). modf only wrapped math.modf and had no callers.
2026-10-31 15:47:52 -05:00
Brues 3b64bfa98b Show the target LoS indicator through ClassicAPI's UnitInLineOfSight
The indicator moves from the unitxp module to the target frame, so it no
longer needs UnitXP_SP3. Its checkbox and the shared font size move to a
Target Indicators header; unitxp_font_size becomes indicator_font_size.
The unused pfUI.api.UnitInLineOfSight wrapper, which shadowed the
ClassicAPI global inside the pfUI environment, is removed.
2026-10-31 15:41:15 -05:00
Brues 217b00e9a4 Use ClassicAPI.strsplit for pfUI's strsplit 2026-10-31 15:33:13 -05:00
Brues 2d5cf94ae1 Fold librange into pfUI.api.UnitInRange 2026-10-31 15:23:13 -05:00
Brues 7ba0fedd2b Make the inspect window movable by dropping EnableMovable's addon wait 2026-10-31 15:21:18 -05:00
Brues b6a41e70ec Switch action bar pages and shift-drag on MODIFIER_STATE_CHANGED 2026-10-31 15:16:28 -05:00
Brues e43ddd31fd Read nameplate units directly instead of scanning by name 2026-10-31 15:08:39 -05:00
Brues f81ea09d1c Choose 3D, 2D or round/square class icon portraits 2026-10-31 14:43:43 -05:00
Brues 78d4e0a56e Run the Turtle WoW setup with RunNextFrame and hook the map once
The one-shot OnUpdate frame becomes RunNextFrame. Its call into the map loader ran with the delay frame as this, so the loader's hooked flag sat on a different frame than on PLAYER_ENTERING_WORLD and the map hooks went on twice: shift and ctrl mouse wheel changed alpha and scale by two steps. The flag is now a local of the module.
2026-10-31 14:28:01 -05:00
Brues caf7112651 Scan chat bubbles once per frame with DirtiableMixin
Each chat message queued its own scan for the next frame, so a busy frame scanned the same bubbles several times. MarkDirty runs one scan for all of that frame's messages.
2026-10-31 14:28:01 -05:00
Brues e5a78c8d54 Animate unit frame bars with ClassicAPI's SmoothStatusBarMixin
Health and power bars take SmoothStatusBarMixin instead of pfUI's own OnUpdate animation, so the animation no longer runs faster at higher frame rates. The speed dropdown becomes an on/off checkbox, since the mixin's rate is fixed. A new range keeps the bar's filled share, so it doesn't jump before the animation moves on.
2026-10-31 14:20:20 -05:00
Brues 43f90751d6 Clear AFK when a holiday scene is clicked 2026-10-31 13:45:35 -05:00
Brues f90279e003 Drive the haste and spell power text from events
Replace the 0.25s ticker with UNIT_SPELL_HASTE for haste and
PLAYER_DAMAGE_DONE_MODS for spell power, which fires on the
MOD_DAMAGE_DONE fields GetSpellBonusDamage reads.
2026-10-31 13:27:48 -05:00
Brues 17fe9f0dd9 Drive the mounted trigger from PLAYER_MOUNT_DISPLAY_CHANGED
IsMounted reads the mount display field, which this event watches. The trigger listened to UNIT_AURA_DELTA, which can fire before that field updates and only worked because the switch waits half a second. UNIT_AURA_DELTA still drives the stealth and dining triggers.
2026-10-31 13:20:03 -05:00
Brues 54e66fea11 Drive range, offline, aggro and combat state from events
Every unit frame re-checked its range fade, offline state, combat and
aggro glow and indicator icons on a 0.2-0.5s tick, and infight polled
aggro every 0.3s. Each now comes from an event.

Aggro: the 270-token scan and its cache are gone. UNIT_TARGET fires for
every unit in view (SuperWoW registers them all), so a table of which
hostile unit attacks which friendly one, by GUID, follows every attacker,
including ones no token reaches. A unit that comes into view mid-fight
is noted when a token first reaches it (target, focus, mouseover, a
nameplate, a member's target). A read drops attackers that left view,
where nothing fires, and a loading screen resets the table. Changes go
out as "aggro:changed" with the old and the new victim, so only the
frames showing those redraw; infight listens too.

Combat square and glow follow UNIT_FLAGS. Range fade follows ClassicAPI's
UNIT_IN_RANGE_UPDATE, registered only by frames that fade, by GUID for a
chained unit; with the 40y check off, frames fade by sight through
UNIT_DISTANCE_CHECK_UPDATE, which also swaps a portrait's question mark
for the model. A UnitXP threshold has no event and keeps its poll.
UNIT_CONNECTION refreshes a member who goes offline or comes back; the
PARTY_MEMBER_ENABLE/DISABLE branches were never registered.

A full refresh now draws the indicator icons and combat state, so a new
unit brings its own. UNIT_FACTION redraws the PvP icon and reaction
colour; its "pvp" refresh step drew nothing. Unlock mode and /pftest
re-apply the fade on entry and exit.

What stays on the tick: the pet frames and the UnitXP range check.
2026-10-31 13:10:46 -05:00
Brues d21d13bdfa Skin ClassicAPI options edit boxes instead of treating them as dropdowns 2026-10-31 12:40:07 -05:00
Brues 480889cb05 Drive power from UNIT_POWER_UPDATE and UNIT_MAXPOWER
1.12's UNIT_MANA, UNIT_RAGE and the rest fire for every power a unit
has, not only the one it shows, so a druid in cat or bear form redrew
every frame showing them, health colours and texts included, on each
mana tick. ClassicAPI's generic power events name the power in arg2.

Unit frames register them on their own token and redraw only for the
power their bar shows, or for mana under a druid mana bar. They fire
for tokens only, so the GUID-followed target-of-X frames keep the
per-type events; those now share one list with UNIT_AURA, so a frame
swaps auras and power on the same check.

energytick counts gains on the power it tracks alone, so a cat druid's
mana regen is no longer read as energy. It forgets the power while
hidden, so a bear's mana ticks are not measured against rage, and
re-baselines on a shift, so leaving cat form is not a fake mana gain.

The equipment manager's dining trigger wakes on mana changes only.
2026-10-31 11:55:54 -05:00
Brues b6f58b0e04 Drive auras from UNIT_AURA_DELTA
UNIT_AURA says nothing about what changed and stays silent when a buff
is refreshed or its duration packet lands, so a recast HoT kept its old
timer until something else rebuilt the row. UNIT_AURA_DELTA reports
added, updated and removed aura instances, refreshes included.

Unit frames register it on their own token. An add, a removal or a full
update rebuilds the auras as before; an update-only delta re-reads the
slot behind each shown icon for its stacks and timer and redraws the
buff indicators, without a relayout or a dispel scan. Frames that
follow a GUID (the target-of-X chain) stay on UNIT_AURA, since the
delta only fires for tokens. A finished aura layout announces itself
as "unitframe:auras".

buffwatch drops its 0.4s rescan: bars rebuild on the delta, on login
and on a target change, and a timer wakes the frame when the next aura
crosses the bar threshold. Bars re-anchor when the player or target
frame lays out its aura rows, and a whitelist or blacklist click
applies at once.

Nameplates, the loss of control alert and the equipment manager's
mount/stealth/dining check listen to the delta as well.
2026-10-31 11:32:47 -05:00
Brues 8b5a27f9be Expire cached aggro on UNIT_TARGET
UnitHasAggro caches a positive answer for 1s and a negative one for
0.3s, so the aggro glow lagged a taunt or a mob turning on a healer by
up to that long. A retarget now expires the entries it can affect: every
unit that had aggro and the retargeting unit's new target. The rest stay
cached, so the scan runs no more often. Mobs without a token of their
own fire it with their GUID, and "<guid>target" composes.
2026-10-31 06:36:42 -05:00
Brues cc5c562516 Rebuild the unit tooltip when its unit retargets
pfUI's unit lines -- target, guild, colours, speed, unit id, the buff
row -- were added once from OnShow, so the target line went stale while
hovering, and any SetUnit on a shown tooltip wiped them. They now go on
from OnTooltipSetUnit, every time a unit is set.

While a unit tooltip is up it listens for UNIT_TARGET on the unit's
GUID and re-sets the unit a frame later, through the token the tooltip
was built from: "mouseover" stops naming the unit once the cursor
leaves, so a fading tooltip is left to fade. Item and spell ids stay on
OnShow.
2026-10-31 06:36:42 -05:00
Brues a9542bd467 Follow target-of-target frames with UNIT_TARGET
A frame whose unit is another unit's target (targettarget,
targettargettarget, pettarget, focustarget, partyNtarget) has no token
that unit events name, so it polled: bars every 0.2s, a full aura and
portrait rescan every second, and a GUID compare to notice swaps.

Such a frame now registers its unit events by the unit's GUID, which
every unit event also fires with, and UNIT_TARGET by the GUID of every
link of its chain. A link retargeting re-points the frame at once and
queues one full refresh; the ticks are gone. The 0.2s visibility timer
stays for them, since nothing reports a unit going out of sight.

Nameplates register UNIT_TARGET on their own token, so a mob turning to
someone else recolours its combat state immediately instead of after
the colour cache and data tick run out.

Drop pfScanActive and the namebuf delay: both guarded against the old
target-swapping range scan, which no longer exists. focus.lua's
instantRefresh was never read.
2026-10-31 06:27:21 -05:00
Brues 45bc65b3c0 bump CAPI min to 1.18.10 2026-10-31 06:10:04 -05:00
Brues 113ff257cf CHAT_MSG_BN_WHISPER and RAID_INSTANCE_WELCOME are not valid events 2026-10-31 03:12:33 -05:00
Brues 07e315cd86 Toggle the item comparison live with shift
The comparison read IsShiftKeyDown() only when the tooltip was set, so
pressing or releasing shift while hovering did nothing until the next
hover. Each hooked tooltip now remembers the item it shows, dropped on
OnTooltipCleared and OnHide, and MODIFIER_STATE_CHANGED shows or hides
its comparison right away, as on retail.

Merchant and auction comparisons show regardless of shift and never
store a link, so shift leaves them up.
2026-10-31 03:05:56 -05:00
Brues b3298571dd End the nameplate right-click on GLOBAL_MOUSE_UP
The right-click emulation polled IsMouselooking() every frame while the
button was held, to catch the release. GLOBAL_MOUSE_UP reports the
release directly, so the frame and its OnUpdate go away.

PLAYER_STOPPED_LOOKING can't stand in for it: ClassicAPI fires the
LOOKING pair only for left-button free-look, and only once the camera
has moved, so a click without a drag fires neither event.
2026-10-31 02:57:03 -05:00
Brues f5c08822f8 Keep empty fields and literal delimiters in strsplit
pfUI.api.strsplit (also the bare strsplit in module code) built a
"([^%s]+)" pattern from the delimiter. That dropped empty fields
("a,,b" gave "a", "b") despite the comment, and a delimiter that is a
pattern character (% ] ^ -) broke the pattern. It now scans for an
escaped character class and keeps every field, like WoW's strsplit.

The custom buff indicator list skips the empty entries this now yields
for "" and the list editor's leading "#", so an empty list no longer
scans auras.
2026-10-31 02:49:46 -05:00
Brues 6f5c225ec3 Drive unit frame visibility from events
Every unit frame re-checked its visibility five times a second. Now
group, target and pet events re-check it in OnEvent, which also runs
while a frame is hidden, and the focus module already re-checks focus
and focustarget on PLAYER_FOCUS_CHANGED.

Only the frames with a tick keep the 0.2 second poll. They show another
unit's target or a pet that can go out of sight, and no event reports
either. The focus target frame now gets the same tick as targettarget,
because no event reports the focus changing its target.

Unlock mode and /pftest have no event, so they re-check every frame
when they change. RegisterUnitWatch does not fit here. It polls on the
same 0.2 second timer, and it only shows a unit that exists, without
the pet range, raid grid and group hiding rules.
2026-10-31 02:04:20 -05:00
Brues a8d805626d Replace QueueFunction and RunOOC with RunNextFrame
RunOOC never waited for combat to end; it ran its function on the next
frame. QueueFunction ran one function every 0.2 seconds. Each caller now
defers with ClassicAPI's RunNextFrame.

The loot roll announcement sends its name lists and the roll directly.
The 0.2 second spacing did not help with the server's chat flood limit
(10 messages less than a second apart), and an announcement is at most
four messages.
2026-10-31 01:57:10 -05:00
Brues df13e30e08 Add a Valentine's Day AFK scene
Hearts drawn from a turned square and two tinted minimap-mask discs float up the screen and sway, a rosy glow lines the edges, and the goblin Cupid hovers by the side.
2026-10-31 01:50:12 -05:00
Brues 235422689b Add Hallow's End and Christmas AFK scenes
The fireworks screen becomes a shared AFK scene: a fading night, the greeting, and a click or coming back to close it. Hallow's End gets a flickering candlelight edge and a row of undead, seven of fifteen creature displays at random, that rise one after another. Christmas gets endless snowfall and a drift that piles up for as long as the player is AFK. Fireworks now spawn across the scene's own size instead of the UI-scaled screen size.
2026-10-31 01:50:12 -05:00
Brues f79494a53a Play the New Year fireworks as animation groups
Explosions are pooled textures that grow and fade with a Scale and Alpha group instead of resizing frames every frame, and the night fades in with an Alpha group instead of stepping alpha per frame.
2026-10-31 00:53:57 -05:00
Brues 7db85b6c07 Play button press animations as animation groups
Each style is now a list of keyframes that a button builds into chained
Scale and Alpha animations the first time it plays. The animations are
timed by the engine instead of stepping by 30/GetFramerate() each frame,
scale the drawing instead of the frame, and run no Lua while they play.
The damped bounce styles ease between the extremes of their old curves.
2026-10-31 00:45:09 -05:00
Brues 61282115a3 Pulse the screen edge glow smoothly and drive it from events
The glow stepped its color ten times a second and re-checked combat,
health and death on every step. An animation group now shifts the color
along an IN_OUT curve and pauses while the glow is hidden. Combat,
health and death update from their events. Aggro has no event, so a
ticker polls it every .3s, matching UnitHasAggro's cache, and only while
that glow is enabled.
2026-10-31 00:36:43 -05:00
Brues b64ae7dd53 Replace HookAddonOrVariable with an EventUtil-based HookAddon
The polling lurker frame is gone. HookAddon gates on
C_AddOns.DoesAddOnExist, waits for PLAYER_LOGIN with
EventUtil.ContinueOnPlayerLogin, then runs on
EventUtil.ContinueOnAddOnLoaded. Addons loaded at startup still hook
only after every pfUI module and skin exists and after the addon's
own VARIABLES_LOADED setup. Load-on-demand addons still hook on their
ADDON_LOADED.

The "or variable" form is gone. Callers that passed a global now pass
the addon that defines it: TheoryCraft, SuperMacro, DPSMate and
Turtle_GroupUI. DPSMate names its windows from its settings, so its
hook now checks for DPSMate_DPSMate itself, as the variable lookup
used to. eqcompare's Guda check uses HookAddon too.
2026-10-31 00:28:30 -05:00
Brues b9c260b8e1 Confirm clipboard copies with fading screen text instead of chat 2026-10-30 23:50:42 -05:00
Brues ff5deac0ec Copy links with CopyToClipboard instead of a popup
Clicking a chat URL and the GUI's Donate/GitHub/Website buttons now put the address straight on the clipboard and say so in chat. The url link goes through ClassicAPI's LinkUtil handler registry, so SetItemRef is no longer replaced. Exporting a profile also copies the string.
2026-10-30 23:45:08 -05:00
Brues cff4be9416 Mousewheel Scroll Speed doesn't require a reload to change 2026-10-30 23:40:50 -05:00
Brues 6a670ab668 Tint swing timer bars while the target is out of range
C_SwingTimer checks the range for each shown bar, and
PLAYER_SWING_RANGE_UPDATE turns a bar the new Out Of Range Color (grey by
default, since the main-hand bar and the hunter dead zone are red) while
its swing can't reach the current target. The melee check is the
server's 2D reach; the ranged one covers the hunter's minimum range too.
No check (no target, nothing to attack, no weapon) keeps the normal
color.
2026-10-30 23:31:29 -05:00
Brues c5894f7f15 Scroll chat with ScrollByAmount
The mouse wheel on the chat frames and on the AFK camera's chat moves by
ScrollByAmount instead of looping ScrollUp / ScrollDown. Shift-wheel up
scrolls by the full range, so the oldest line stops on top as it does
with the wheel; ScrollToTop would leave it alone on the bottom line.
2026-10-30 23:26:36 -05:00
Brues 5224d02572 Drive the loss of control alert by events alone
The 0.1s rescan only caught timers that change without a loss of control
event: a refreshed debuff fires UNIT_AURA, and a second kick on a locked
school fires SPELL_UPDATE_COOLDOWN, after ClassicAPI has read the lockout
from the packet. The alert listens to both while it shows. pfUI's
cooldown text prints the time left on the icon, so the alert's own
countdown and LOSS_OF_CONTROL_SECONDS go.
2026-10-30 23:23:17 -05:00
Brues f56720dccc Add a loss of control alert
A movable alert in the middle of the screen for the strongest active
effect from C_LossOfControl: icon, cooldown sweep, the effect's name and
the seconds left. A school lockout reads "<School> Locked". It opens on
LOSS_OF_CONTROL_ADDED / _UPDATE and rescans every 0.1s while shown,
because a refreshed debuff or a second kick changes the timer without an
event.

The labels are Classic Era's LOSS_OF_CONTROL_DISPLAY_* GlobalStrings,
added to each locale file. The README lists the alert and the dressing
room controls.
2026-10-30 23:16:20 -05:00
Brues 70cc994a97 Zoom, pan and per-slot undress in the dressing room
EnableClickRotate becomes EnableModelControls, the controls of 4.3.4's
ModelWithControlsTemplate: left-drag turns the model without ClassicAPI's
step animation, the mouse wheel moves the camera toward the face with
SetPortraitZoom, and right-drag pans with 4.3.4's per-race pan speed and
bounds. Showing the frame resets zoom and pan. Every model frame pfUI
skins gets them.

The dressing room gains an Undress button and a column of slot buttons
on each side, in the paperdoll's order; clicking one calls UndressSlot.
2026-10-30 23:11:09 -05:00
Brues 2c7ca8afdd Read the dock anchor only once a frame is docked
SetupMenu reads each radio's selection when the dropdown is set up at module load, before any frame is docked, so IsDockAnchor indexed a nil dock parent.
2026-10-30 22:25:27 -05:00
Brues 1b71ee617f Wait on ContinueOnItemLoad for inbox, panel and loot history items
The inbox package border now waits for the item to load, since another
player's item may not be cached. The panel and loot history drop their
cached branch: ContinueOnItemLoad runs at once for a cached item. The
swing timer reads the off-hand inventory type from the slot instead of
parsing the item link.
2026-10-30 21:44:37 -05:00
Brues bfe1864aa1 Pick the unlock dock's anchor from a pfUIDropdownTemplate
Each radio reads its selection from the frame's saved position, and
UpdateDockValues regenerates the menu instead of setting a UIDropDownMenu
selection by hand. A frame without a saved position shows N/A, like its
coordinates, instead of the anchor of the frame selected before it.
2026-10-30 20:21:46 -05:00
Brues 11b1a2b077 Show the master loot menu with ClassicAPI's menu system
The menu opens under the clicked loot button, owned by it. A change to
the candidates or the rolls rebuilds it while it is shown. Request Rolls,
Reroll Ties, Clear Rolls and the roll list sit in the root menu, which
can be rebuilt in place where a submenu can't, so rolls appear as they
come in. With advanced loot off, the raid gets the class lists instead of
Blizzard's menu, whose roster the unregistered LootFrame never filled.
The confirm dialog names the candidate instead of the clicked row's text.
pfUI no longer initializes GroupLootDropDown or overrides
GroupLootDropDown_GiveLoot.
2026-10-30 20:13:52 -05:00
Brues 4616c2bc5f Toggle visibility with SetShown instead of Show/Hide branches
Each if/else that only showed one object in one branch and hid it in the other is now ClassicAPI's SetShown, which shows on any truthy value. 21 sites across 10 modules.
2026-10-30 19:49:43 -05:00
Brues f7680ded0b Fill textures with SetColorTexture instead of color-form SetTexture
ClassicAPI's SetColorTexture is the same engine call as SetTexture(r, g, b [, a]) under the name that says what it does. 83 calls across 25 files, renamed only.
2026-10-30 19:48:48 -05:00
Brues 6469a557ff Reuse one question dialog, backfill chat history, dim arrow icons on events
CreateQuestionDialog builds its frame once and sizes it right away from
the text's unbounded width. A frame per call broke the one-dialog guard
after the first dialog, since 1.12 binds a frame name only once. An
onclose that opens the next question runs on the next frame.

Chat history goes in with BackFillMessage, above the lines the frame
already has. SkinArrowButton dims its icon from OnEnable/OnDisable
instead of an OnUpdate per button.
2026-10-30 19:48:02 -05:00
Brues 4988384884 Light config rows on mouse motion and list search results in a ScrollBox
Config rows and search results took their hover from an OnUpdate that
polled the cursor every frame. Rows now take OnEnter/OnLeave, and their
widgets propagate mouse motion so the row stays lit over them. Search
results fill a pfUIScrollBoxListTemplate from a DataProvider instead of
a hand-pooled button list, and match the search text literally.
2026-10-30 19:39:22 -05:00
Brues af9edb215d Show pfUI's dropdowns and menus with ClassicAPI's menu system
pfUIDropdownTemplate (a DropdownButton) replaces CreateDropDownButton in
the config GUI, addon profiles, the trigger editor and the icon picker
filter. The equipment set gear menu and the tracking menu open
MenuUtil context menus. pfUIMenuStyleMixin draws pfUI's backdrop behind
them, and the skin module makes it the default style and draws the
checkboxes and radios as pfUI boxes.
2026-10-30 19:33:40 -05:00
Brues f37ea00226 Give pfUI its own EventRegistry and move event-only frames onto it
pfUI.events was a bare CallbackRegistry for pfUI's custom events. Build it
from ClassicAPI's EventRegistry instead, so the same object also takes game
events through RegisterFrameEventAndCallback, sharing one frame for all of
them.

Move the frames that existed only to listen for a few events onto it:
libspell, focus, pixelperfect, innervatecall, loothistory, unusable,
equipmentmanager (bank + window refresh), the actionbar grid, updatenotify,
turtle-wow's steady shot, nampower's spell queue, superwow's group tracking
and unitxp's notifications, plus newitem and mapreveal, which used the
global EventRegistry. Handlers take their payload as arguments instead of
the event/arg globals, and the per-frame PLAYER_LOGOUT teardown goes away,
since the registry unregisters its frame on logout.
2026-10-30 12:37:56 -05:00
Brues b0f9b7b993 Use ClassicAPI's nop for empty functions 2026-10-30 12:20:37 -05:00
Brues 436c6d6dd4 Apply per-line chat settings without a reload 2026-10-30 12:20:23 -05:00
Brues efe6ec6080 Give spellbook buttons a native Cooldown and fix the bag slot one
Spell buttons kept the template's indicator Model for their sweep. The
Spellbook skin now creates a native Cooldown for each one.

Taking the "<button>Cooldown" name was meant to point the FrameXML
lookups at the new frame, but 1.12 binds a frame's name only while that
global is unset. The bag slot Cooldowns from a721f788 were never used:
ContainerFrame_UpdateCooldown still drove the Model, so bags lost their
timer text, ignored Reverse Cooldown Animation and were hidden by Hide
Foreign Cooldown Animations. Both places now rebind the global by hand.
2026-10-30 12:09:19 -05:00
Brues a96a3dbd87 Show the About page's values inside the panel
The values anchored to the content's TOPRIGHT, which now spans the whole
panel since the panels moved to pfUIScrollFrameTemplate, so they sat 375px
past its right edge and the scroll frame clipped them. Anchor them to the
content's TOPLEFT, where the labels' offsets already measure from.
2026-10-30 11:45:08 -05:00
Brues a721f788a9 Let each cooldown frame apply its own sweep settings
The sweep options reached the frames only through the cooldown module's
CooldownFrame_SetTimer hook, which set alpha 0 for a hidden animation and
SetReverse(true) for a reversed one. With that module disabled, Show Timer
Animation and Reverse did nothing, and reverse never turned back off
without a reload. The player buff sweeps had no other path at all.

Each owner now configures its own frame. Player buffs drive their
Cooldown with SetCooldown and Clear, and only while Show Timer Animation
is on. Unit frame auras, raid aura indicators and nameplate debuffs hide
the sweep with SetDrawSwipe and SetDrawBling. Every frame with a reverse
option calls SetReverse. The hook keeps the timer text and Hide Foreign
Cooldown Animations.

Nameplate debuffs hid the sweep with alpha, which the plate's SetAlpha
copied down on every target change (ClassicAPI keeps 1.12's alpha under
default plates), so hidden sweeps came back. Their settings now come from
UpdateDebuffConfig alone.

Bag slots get a native Cooldown like bank slots, in place of the
template's indicator Model, so Reverse Cooldown Animation covers bags and
Hide Foreign Cooldown Animations no longer hides them.

The buff, unit frame, nameplate and totem options apply without a reload.

Fixes #72.
2026-10-30 10:46:00 -05:00
Brues f33a9068f2 Translate the Self quick button
Classic Era dropped QUICKBUTTON_NAME_SELF and its tooltip, so every locale
showed 4.3.4's English text. Each locale now has its own, worded after its
My actions strings.
2026-10-30 03:13:38 -05:00
Brues 187e057923 Add the Combat Log settings window and 4.3.4's default filters
"Settings" in the Combat Log tab's menu opens Blizzard's Combat Log page,
rebuilt in Lua with pfUI widgets: the filter list with copy, add and
delete, and the Message Sources, Message Types, Colors, Formatting and
Settings tabs. Combat Log Defaults restores the default filters. Closing
the window refills the log only when the active filter changed.

The log now records while ChatFrame2 is hidden, so switching tabs no
longer loses history.

The default filters are 4.3.4's: Self, Everything, What happened to me?
and Kills. Classic Era's My actions left out auras.
2026-10-30 03:02:42 -05:00
Brues 3899004957 bump CAPI min to 1.18.05 2026-10-30 02:19:25 -05:00
Brues ee73cde828 Replace the combat log with Classic Era's Blizzard_CombatLog
ChatFrame2 now shows the 4.x combat log, ported from Classic Era's
Blizzard_CombatLog as the combatlog module. ClassicAPI's COMBAT_LOG_EVENT,
CombatLogAddFilter and kept entries drive it, and changing filter refills
the frame with BackFillMessage. Quick buttons sit above the log, and its
unit, spell, raid icon and action links open Blizzard's filter menus.
Filters save account-wide in pfUI_combatlog.

The 1.12 CHAT_MSG_COMBAT_* and CHAT_MSG_SPELL_* events no longer reach
ChatFrame2. Its message groups stay saved, so disabling the module brings
the text log back.

env/combatlog_<locale>.lua hold the Classic Era GlobalStrings the log reads
that 1.12 lacks.
2026-10-30 02:19:08 -05:00
Brues 76efd5b490 Pass every AddMessage argument through the chat hook
The hook forwarded the text and seventeen named arguments. It takes them
as ... now, which ClassicAPI rewrites to unpack(arg) with arg.n, so every
argument reaches the frame's AddMessage, nils included. GetMessageInfo
returns all of them, and a hook that drops some loses them for every
frame after it.
2026-10-30 01:25:36 -05:00
Brues 393b37b8c3 Add an option to show timestamps in chat copy
"Show Timestamps In Chat Copy" (chat text settings, on by default) is read
each time chat copy opens. With it off, chat copy takes each line through
pfUI.chat.StripTimestamp, which removes the exact timestamp AddMessage
prepends: the configured color and brackets, so other bracketed text
stays.

Whispers are now recolored before the timestamp goes on, not after. The
recolor turned the stamp's closing "|r " into "|r" plus the whisper color,
so whisper lines did not match. The shown text and the saved history come
out the same.
2026-10-30 01:25:36 -05:00
Brues 7928db33bf Show the equipment manager's lists in ClassicAPI ScrollBoxes
The set list, the unused-items grid and the trigger list each drew a
fixed number of slots and moved them with a mouse-wheel offset. All three
are pfUIScrollBoxListTemplate lists now, with a scroll bar.

The set list's rows are the sets and then the "New Set" entry, set up by
one initializer. Refresh rebuilds them only when the sets change and
otherwise reinitializes the shown rows, so a row keeps its frame between
the two clicks of the native OnDoubleClick that now equips a set, in
place of the hand-timed double click. PickupEquipmentSet is called
without a presence check.

The row's gear passes mouse motion on to the row, so moving onto it no
longer leaves the row and the MouseIsOverHitRect workaround is gone. The
gear rests at half alpha and lights up on hover with an additive copy of
itself, instead of the blue square highlight.

The unused items are a grid view that keeps its scroll position on
refresh. The trigger list scrolls to a new trigger with ScrollToEnd.
2026-10-30 01:07:22 -05:00
Brues 5d8314b2d4 Scroll the config panels with ClassicAPI's scroll bar
pfUIScrollFrameTemplate (api/ui-widgets.xml) is a ScrollFrame with
pfUIScrollBarTemplate inside its right edge and a Content scroll child,
driven by ScrollUtil.InitScrollFrameWithScrollBar. The panels keep a
ScrollFrame because the engine measures its range from the shown frames
inside the content, which the hand-placed config rows rely on. The bar
follows OnScrollRangeChanged instead of an OnUpdate poll per panel.

A panel measures its range once its rows are built, and the search
results measure theirs with UpdateScrollChildRect instead of hiding,
re-attaching and scrolling a frame later. Clearing the search measures
again too.

CreateScrollFrame and CreateScrollChild have no users left, and nothing
called CreateTabFrame or CreateTabChild; all four are gone. pfQuest's
compat layer brings its own copies of the scroll helpers.
2026-10-30 00:51:16 -05:00
Brues 3987cfb8a0 Show loot history and the icon picker in ClassicAPI ScrollBoxes
pfUIScrollBoxListTemplate (api/ui-widgets.xml) is a WowScrollBoxList with
pfUIScrollBarTemplate beside it, 5px inside the frame, so a list's
backdrop goes on the frame itself. The addon list moves onto it and drops
the sibling backdrop frame.

Loot history builds a flat list of item rows and, under an expanded item,
player rows; the view sizes and indents them. The item frame array, the
player pool, the hand-placed rows and the scroll child re-attach are gone,
and the scroll position holds across roll updates.

The icon picker's FauxScrollFrame and 80 fixed buttons become a grid view
over the provider's icon indices. Picking an icon reinitializes the shown
buttons instead of redrawing the grid, and closing the popup drops the
grid's entries along with the provider.
2026-10-30 00:47:07 -05:00
Brues 796f20eadf Show chat copy and the share box in ClassicAPI's scrolling edit box
pfUIScrollingEditBoxTemplate (api/ui-widgets.xml) is ScrollingEditBoxTemplate
with pfUIScrollBarTemplate beside the text. Its mixin's SetFont gives the
box a font object of its own, since the edit box sets its font by object on
every SetText and pfUI fonts are paths. ui-widgets.lua now loads before the
XML, which needs the mixin.

The share box no longer recomputes its scroll child on every text change.

Chat copy reads each chat frame's messages with ClassicAPI's
GetMessageInfo when it opens, so the AddMessage hook, its 100-line copy of
the history and the skip of combat frames are gone. It shows every line
the frame keeps, lines from before login included. It puts the caret at
the end to scroll to the newest line instead of three OnUpdate passes, and
Escape now leaves copy mode on every chat frame.
2026-10-30 00:38:54 -05:00
Brues 26c55bddb0 Drive the rez icon from ClassicAPI's incoming resurrections
ClassicAPI's UnitHasIncomingResurrection sees every resurrection cast in
view from SMSG_SPELL_START and ends it with the cast, and
INCOMING_RESURRECT_CHANGED signals each change. libpredict's own
tracking goes: the ress tables and 60s timers, parsing Resurrection and
RES/RESNO messages, clearing on UNIT_HEALTH, and the rez branches of the
cast handlers, along with UNIT_SPELLCAST_STOP and the foreign cast
targets only rez used. libpredict still announces the player's own
resurrections to HealComm and CTRA for clients without ClassicAPI.

The native state ends with the cast, so a rez that landed would vanish
before the target accepts it. libpredict records the SPELL_RESURRECT
combat log event per GUID and keeps the offer until the target is alive
again or the 60s accept popup runs out, unlike Grid2, which cannot tell
a landed rez from a cancelled one. UnitHasResurrection answers both.

The unit frames show the icon in RefreshIndicators, refreshed by
INCOMING_RESURRECT_CHANGED on the frame's own unit and by libpredict for
offers, instead of polling libpredict every 0.1s.
2026-10-29 23:49:28 -05:00
Brues 8c22fdb850 Show the addon list in a ClassicAPI ScrollBox
The list built one row per addon in a ScrollFrame, hid the rows out of
view by hand and drove pfUI's own slider. A WowScrollBoxList keeps rows
only for the addons in view and recycles them while scrolling.

pfUIScrollBarTemplate (api/ui-widgets.xml) is a ScrollBarMixin bar with
the old slider's look: a thin track and a flat teal thumb that hides when
nothing scrolls. Its steppers exist for the mixin but stay hidden.

Rows read the addon's enabled state, so profiles enable and disable
addons directly instead of clicking every row's checkbox. A checkbox
now shows whether an addon is enabled; it showed whether it was loaded.
2026-10-29 23:04:47 -05:00
Brues 2d275c53fa Clear AFK on wake only while it is still set
/afk toggles. The overlay sent it on every click and key press, so when
the client or the server had already cleared AFK it set it again. Check
ClassicAPI's IsChatAFK first. It follows the client's /afk state at
once, where UnitIsAFK waits for the server's flag update.
2026-10-29 22:40:30 -05:00
Brues ba752056ad Stop the AFK camera when AFK clears while it spins
62e0d4eb stopped the camera only while the start delay was shown, but the
delay hides itself once the camera starts. AFK cleared during the spin
left the overlay up, and the next key press sent /afk and set AFK again.
Stop when the camera spins instead, which also keeps stop() and its
SetView(4) from running when AFK clears before the camera started.
2026-10-29 22:40:26 -05:00
Brues 1ccf87c61a Drop CreateGoldString's fallback for clients without coin icons
ClassicAPI always provides GetCoinTextureString, so the presence check
and the hand-built "g/s/c" string after it never ran.
2026-10-29 22:39:01 -05:00
Brues dc89f01dda Refresh the FPS & Lag panel tooltip while it is shown
The tooltip was built once on enter, so its memory, network and addon
figures stayed at the values from that moment. The widget's one-second
ticker now rebuilds it while the panel still owns GameTooltip. The
tooltip takes its owner as self, not this, so the ticker can call it.
2026-10-29 22:24:36 -05:00
Brues a917a70b1c Add an expand/collapse-all button to the Reputation tab
ClassicAPI 1.18's ExpandAllFactionHeaders and CollapseAllFactionHeaders
set every header in one call. The button sits on the "Faction" label's
row, in the headers' +/- column, and shows "+" while any header is
collapsed.
2026-10-29 22:24:36 -05:00
Brues 03ea3d5aa5 Clear cancelled resurrections announced over HealComm and CTRA
ParseChatMessage tested the raw message for "RessStop", which no
HealComm message is, so ParseComm's Resurrection/stop/ result was never
acted on. CTRA's RESNO was matched against the whole message, but it
carries the target's name, and the CTRA parser only recognised RES. A
cancelled rez from another player left the icon on the target's frame
until they were revived. RessStop still keeps a rez whose cast landed
and whose accept window is open.
2026-10-29 18:58:15 -05:00
Brues 2b4d33d46a Keep libpredict tracking casts when HealComm is loaded
With HealComm-1.0 present (HealComm, LunaUnitFrames, NotGrid), the
compat hook unregistered every event on libpredict.sender to stop pfUI
broadcasting a duplicate of the player's casts. Since cast detection
moved onto that frame's UNIT_SPELLCAST_* handlers, that also blinded
libpredict to every cast, so the player's own resurrections never put
the rez icon on the target's frame: ParseChatMessage drops the player's
own Resurrection echo, expecting the cast events to have tracked it.

The compat hook now only mutes the outgoing HealComm and CTRA messages.
The HealComm.SendAddonMessage hook that parsed the player's own messages
while solo goes too, since libpredict tracks its own casts directly.
2026-10-29 18:56:51 -05:00
Brues 94dcfb3dad Compute bar layout options instead of tabulating pfGridmath
pfGridmath listed every exact cols x rows grid per bar size; the only
live use was seeding the layout dropdown, which a divisor loop now does.

Everything else that read it was unreachable: every layout option is a
"cols x rows" string, so ResolveBarLayout's BarLayoutFormfactor lookup
never matched, and the actionbar module resets a stored layout that
isn't one before BarLayoutSize/BarButtonAnchor run, so their fallbacks
never fired. BarLayoutFormfactor and env/tables.lua go with it.
2026-10-29 14:16:43 -05:00
Brues 0890905eb6 Drop named-unit frames and the pfValidUnits global
CreateUnitFrame and CreateCastbar could take a character name instead of
a unit token, but every caller passes a token, so that mode and the
empty-label guards around it were dead. The OnClick TargetByName branch
could never run anyway: label was always a string, and "" is truthy.

With that gone, the aggro scan was the only reader of pfValidUnits, so
its unit list now lives in unitframes.lua and is built once at load.

/focusname resolves the name with UnitTokenFromName (exact first, then
prefix) instead of swapping the target and muting UIErrorsFrame.
2026-10-29 14:00:54 -05:00
Brues 6c76a88467 Draw unit frame bars with the native StatusBar
The custom bar sized its textures in Lua from GetWidth(), so it had to
track how ClassicAPI reports the UI scale (#71), and it stretched the bar
texture instead of cropping it. The engine's StatusBar does that layout
itself.

The background of the missing part is a second StatusBar that fills
from the other end (ClassicAPI's SetReverseFill), one frame level below
the fill, so the incoming-heal texture still draws between the two.
SetFrameLevel moves both, and the health and power bars now sit two
levels above their backdrops. SetStatusBarBackgroundTexture becomes
SetStatusBarBackgroundColor, as it only ever took a color.
2026-10-29 11:06:02 -05:00
Brues 35c32f365e Remove scaledsize fix 2026-10-29 10:38:28 -05:00
Brues 6dcb5162be bags: use ClassicAPI's native item search
C_Container.SetItemSearch drives the search box; slots dim from isFiltered on INVENTORY_SEARCH_UPDATE and on each slot update. Matches name, subclass, equip slot and equipment set names. Drops the tooltip-scanning full-text option.
2026-10-29 10:35:28 -05:00
Brues 8afafe71cf Drop RunMacroText fallback and dead actionbar spellslot branches
ClassicAPI 1.18 provides RunMacroText natively; bump CAPI min to 1.18.0. spellslot/booktype/scanmacro were only ever cleared, never set.
2026-10-29 10:35:28 -05:00
Brues 99ed538ee7 bump CAPI min to 1.17.10 2026-10-29 10:35:28 -05:00
Brues f382039f21 panel: show per-addon memory in FPS & Lag tooltip
Use UpdateAddOnMemoryUsage/GetAddOnMemoryUsage like Blizzard's MainMenuBar performance tooltip: total addon memory plus the top 3 consumers, formatted with the TOTAL_MEM/ADDON_MEM global strings. Guarded so the tooltip falls back gracefully on clients without these APIs.
2026-10-29 10:35:28 -05:00
Brues 8307dd757e Bump ClassicAPI minimum 1.17.4 2026-10-29 10:35:28 -05:00
Brues 5ab5337bbc Keep status bars true to their value on ClassicAPI 1.18.0
ClassicAPI 1.18.0 divides the UI scale out of an anchored frame's
GetWidth/GetHeight, as 4.3.4 does. The status bar still divided it out
itself, so under a UI scale below 1 the bar emptied early (at 29% health
on a 0.71 scale). Only divide on older ClassicAPI.

Fixes #71
2026-10-29 10:33:55 -05:00
Brues d15b1cd320 Only declare RunMacroText if it doesn't exist 2026-10-28 12:21:34 -05:00
0cabf2ec29 Add equipment manager auto-switching and "Unused" items panel (#70)
* Add equipment manager auto-switching and "Unused" items panel

Equipment manager (modules/equipmentmanager.lua):
- Add automatic set switching: ordered triggers (mounted, swimming,
  eating/drinking, shapeshift form/stance, zone, instance type, time
  of day, resting, stealthed, targeting a boss) equip a set; topmost
  matching trigger wins, with a 0.5s debounce
- Never swap gear in combat, while dead or casting; optionally restore
  the previous gear via a hidden "pfUI Auto-Restore" set
- Add an "Unused" side panel listing equippable items in bags, bank
  and paperdoll that no set uses, with an ignore list (tools and quest
  disguises pre-ignored), bank snapshot and bag highlighting
- Persist triggers, ignore list and bank snapshot in new per-character
  SavedVariable pfUI_eqmgr (all three .toc files)
- Add Character > Equipment Manager options (autoswitch, announce,
  minimum item quality, include bank) in gui.lua and config.lua
- Hide ignored-slot overlays when the manager frame is closed

Add frFR translations for the new equipment manager strings.

* equipmentmanager: lean on ClassicAPI for unused scan and autoswitch

- Unused panel: list items via GetInventoryItemsForSlot instead of
  hand-packing locations and walking the bags.
- Bank snapshot: record set membership while the bank is open.
  GetItemLocations reports bank items as missing once it closes, so set
  items in the bank were listed as unused.
- Autoswitch: check CanUseEquipmentSets and the UseEquipmentSet result
  before marking a trigger applied, and retry when the swap is blocked.
- Drive the engine from events (aura, form, zone, resting, target,
  regen) instead of a 4 Hz ticker; poll only swimming, time and eating.
- Detect eating/drinking by the localized names of the Food (433) and
  Drink (430) auras instead of hardcoded locale strings and icon paths.
- Drop presence guards on APIs that always exist; use strsplittable and
  strtrim for trigger values.

* equipmentmanager: wake the dining trigger on player health/mana events

Drop dining from the poll: listen to UNIT_HEALTH/UNIT_MANA for the player
while a dining trigger is enabled, so taking the set off once full is
event-driven. Register UNIT_AURA for the player only.

* equipmentmanager: split trigger values with strsplit

strsplittable needs ClassicAPI 1.17.11; strsplit has been there since
1.7.3, so this keeps the minimum where it is.

* equipmentmanager: let the trigger hint wrap

---------

Co-authored-by: Duciel <336374+Duciel@users.noreply.github.com>
Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com>
2026-10-27 11:02:44 -05:00
Brues fe376b8e51 Keep buff timer text above the cooldown sweep 2026-10-25 20:32:49 -05:00
Brues e326cea05e Add radial sweeps to buff/debuff icon display 2026-10-25 20:26:45 -05:00
Brues d9e74b3bc5 Add per-frame reverse toggle for cooldown sweeps 2026-10-25 20:24:12 -05:00
Brues 0e428de74c Fix inactive nameplate alpha capped at 99%
CacheConfig clamped notargalpha to 0.99, so a 100% setting never reached full opacity. Clamp to 1.0 instead and detect the target plate by GUID comparison only, removing the alpha-based fallback that required the headroom.
2026-10-25 20:00:50 -05:00
Brues df21f1f26c stable: capture per-iteration button in Enable/Disable closures
Lua 5.0 shares the generic-for loop variable across iterations, so the
closures all saw the final (nil) value.
2026-10-25 12:12:05 -05:00
Brues bd7bf3f39f Size aura cooldown text to its laid-out icon
Unit frame aura icons only get their size from the layout pass, but
RefreshUnit started their timers before it ran. A cooldown text created
on a never-laid-out icon saw a height of 0 and fell back to a 16pt font,
so some buff and debuff timers overflowed their icons. (Closes #64)

- RefreshUnit stores each aura's timer and starts them after
  LayoutAuras, once every icon has its final size.
- With dynamic size on, the cooldown text re-sizes its font whenever
  its frame's height changed since the last SetTimer, so icons that
  switch between the normal and own aura size keep a matching font.
2026-10-25 11:48:24 -05:00
Brues 987c337709 Revert "Remove CLINK parsing"
This reverts commit c03b74c3d1.
2026-10-25 11:39:39 -05:00
Brues cdaf9336a3 nameplates: skip destroyed plates on PLAYER_LOGOUT
Leaving the world destroys the units before PLAYER_LOGOUT fires, so some
plates in the registry are already dead: their overlay buttons dropped
their events and lost their methods, and UnregisterAllEvents errored as a
nil method. Only silence the plates that are still alive.
2026-10-25 11:33:51 -05:00
Brues e4f0849816 Pass the draw layer as CreateTexture's second argument
CreateTexture("OVERLAY") names the texture "OVERLAY" and leaves it on
the default ARTWORK layer. Pass nil for the name so the layer applies.
2026-10-25 11:21:01 -05:00
Brues c03b74c3d1 Remove CLINK parsing 2026-10-24 23:23:16 -05:00
Brues e583ac1e83 Drive mapreveal from MAP_EXPLORATION_UPDATED and C_MapExplorationInfo 2026-10-24 21:33:12 -05:00
Brues 964c316cdc Replace Nampower combat events with ClassicAPI events
Read casts from UNIT_SPELLCAST_* and heal amounts from
COMBAT_LOG_EVENT_UNFILTERED in libpredict, swingtimer and the prowl
page switch. Drop libdebuff's AURA_CAST/DEBUFF_* bookkeeping and hook
tables, which nothing read: its aura readers already use C_UnitAuras.
Drop the unitframe BUFF_ADDED_OTHER start-time tracker, since
C_UnitAuras stamps an expiration for auras seen being applied.
2026-10-23 21:27:28 -05:00
Brues b73ed88346 Split chat faction and race icons into separate options 2026-10-23 19:33:08 -05:00
Brues b374a0914a Color equipment flyout borders by item quality 2026-10-23 17:27:37 -05:00
Brues aaddeb120a Drive innervate callout from the combat log
Read Innervate casts from COMBAT_LOG_EVENT_UNFILTERED instead of
Nampower's AURA_CAST events, taking the target name from the event.
Schedule the ready callout once Innervate's own cooldown appears on
SPELL_UPDATE_COOLDOWN; at cast time GetSpellCooldown reports only the GCD.
2026-10-23 17:03:23 -05:00
Brues 1ad78d43e9 nil 2026-10-23 16:21:05 -05:00
Brues dde4a5aa2d Merge chat class color and player level passes into one loop 2026-10-23 12:51:04 -05:00
Brues e7e1382693 Port unitframe and actionbar performance fixes from Duciel/pfUI@45f8ca6
Unitframes: only set the unit attribute when it changes, poll group frame indicators every 3s since events already cover them, and limit full refreshes on eventless frames to unit changes or once a second.

Actionbar: handle UNIT_INVENTORY_CHANGED with a light count/cooldown/usable pass instead of a full update of every button, and skip hidden buttons in the cached passes, catching them up once they become visible.
2026-10-23 12:39:07 -05:00
Brues 6aaf4f2047 Read chat sender and channel from GetCurrentChatEvent
Pull the CHAT_MSG payload once per line instead of decoding it from the
rendered text. The sender match uses arg2 rather than the name resolved
from the GUID, and channel shortening only runs on CHAT_MSG_CHANNEL with
a single anchored replacement in place of the backtracking pattern.
2026-10-23 03:12:42 -05:00
Brues 233d0dafc0 one more bump 2026-10-23 03:09:07 -05:00
Brues 95e832835e Color chat senders by GUID and drop the who-search option
The engine name-queries a chat sender before the CHAT_MSG event fires,
so GetPlayerInfoByGUID(GetCurrentChatGUID()) resolves every player
sender, including strangers in world channels. Other names in the text
still fall back to C_PlayerCache.GetPlayerInfoByName and libunitscan.

This makes the silent /who lookup for unknown classes obsolete; remove
it along with its FriendsFrame_OnEvent wrapper, config default, GUI
entry and translations.
2026-10-23 02:40:08 -05:00
Brues cae7c2d68a Guard unusable bag refresh against the bank frame not existing yet 2026-10-23 02:39:42 -05:00
Brues 8abde7beba Classify nameplate units with UnitSelectionType instead of bar color 2026-10-23 02:06:43 -05:00
Brues fbb0c4c254 Refresh unusable bag tint when item requirements change 2026-10-23 02:00:27 -05:00
Brues 42e950639f Rotate bar textures on vertical XP, rep and nameplate health bars
Vertical StatusBars stretched the bar texture's shading along the wrong axis. ClassicAPI's SetRotatesTexture turns it with the bar.
2026-10-22 23:56:51 -05:00
Brues e70c8025c2 Draw the ranged swing timer as a native center-fill StatusBar
The ranged bar faked its fills with three textures resized and re-texcoorded every frame. A StatusBar with ClassicAPI's SetFillStyle covers all of it: CENTER for hunters (reload drains to the middle, the deadzone grows back out in the warn color), STANDARD otherwise.
2026-10-22 23:43:44 -05:00
Brues 8f1322d71c Skin ClassicAPI's Interface Options frame and its option controls
SkinCollapseButton's icon no longer takes the mouse, so clicks reach the button under it.
2026-10-22 23:34:08 -05:00
Brues 935b854073 Remove dead buffdetect setting 2026-10-22 23:25:59 -05:00
Brues df16988d3f Flow unit frame auras: debuffs first on enemies, own size, spacing
Unit frame aura icons are placed by a layout pass after each aura
refresh instead of a fixed grid set at setup. Rows are as tall as
their largest icon, and the debuff block no longer uses the debuff
size to step past buff rows. (Closes #25)

- When buffs and debuffs share a corner, debuffs come first on
  neutral and hostile units.
- New Own Buff Size / Own Debuff Size (-1 = normal size) enlarge the
  player's auras, which C_UnitAuras already lists first.
- New Buff/Debuff X-Spacing and Y-Spacing set the gaps between icons
  and rows; the default of 1 keeps the old look.
- The selfdebuff tooltip remap is gone from unit frames and buffwatch:
  own auras lead the list, so the HARMFUL|PLAYER index is the HARMFUL
  index.
2026-10-22 23:24:15 -05:00
Brues 627ab8b437 Use ClassicAPI's native Cooldown frame for cooldown sweeps
ClassicAPI 1.17.1 draws the Cooldown sweep natively, as 4.3.4's
CGCooldown, so pfUI's cooldowns no longer need the indicator Model.

- Action buttons, bank slots, totems, unit frame auras and icons, and
  nameplate debuffs are Cooldown frames with CooldownFrameTemplate.
- The plain-Frame fallbacks for disabled animations are gone; the hook
  already hides the sweep with alpha 0.
- The 36px scale-and-inset realign only runs on stock indicator Models.
2026-10-22 22:47:18 -05:00
Brues c36184081a Bump min ClassicAPI to 1.17.1 2026-10-22 22:19:35 -05:00
Brues d881d73246 Use region:IsMouseOver instead of the MouseIsOver global 2026-10-22 21:37:50 -05:00
Brues b9f473c049 Test hover against the hit rect, not the bare frame rect
CreateBackdrop widens a frame's hit rect by the border, so mouse focus
and OnEnter/OnLeave cover a band that plain MouseIsOver reports as
outside. Add MouseIsOverHitRect, which passes the frame's hit rect
insets as MouseIsOver offsets, and use it at the unpadded call sites.
The XP bar's hover text follows the same OnEnter/OnLeave flag as its
fade.
2026-10-22 21:36:27 -05:00
Brues 9cb21b982b Use ClassicAPI animation groups for fades and pulses
Replace hand-rolled OnUpdate alpha loops with engine animation groups:
unit frame aggro/combat glow, tracking icon pulse, new-mail blink,
castbar fade-out, autohide, XP/rep bar fade, info box timeout and the
unlock-mode scale label. Timing no longer depends on framerate, and the
always-running glow driver and tracking OnUpdate are gone.

The XP bar tracks hover through OnEnter/OnLeave instead of MouseIsOver,
so a fade can't restart under the cursor.
2026-10-22 21:28:34 -05:00
Brues 65ad47e842 Bump min ClassicAPI to 1.17 2026-10-22 21:10:39 -05:00
Brues 50aba54289 castbar, nameplates: update the shield on mid-cast interruptible changes 2026-10-22 21:09:17 -05:00
Brues d58060b188 hoverbind: Escape clears every key bound to the button 2026-10-22 21:00:01 -05:00
Brues 340bd9be9e pagemaster: page modifiers via override bindings; hoverbind: warn on conflicts
The old pagemaster wipe block checked a setting that was migrated away and
never ran, so saved MOD-key bindings beat the paged action. Override every
key bound to ACTIONBUTTON1-12 for each enabled page modifier instead; the
saved binding set stays untouched.

Hoverbind now reports when a bind takes a key from another action, and when
an override masks the new bind.
2026-10-22 20:59:30 -05:00
Thorsten42andBrues 287a4ed46c Fix panel alignment: center-panel overlap and Quest Log/Friends/Spellbook heights (#63)
* Only move the center panel when it overlaps the left panel

The panel aligner cached the left panel's rightmost child once and then
re-anchored the center panel to that edge on every change. Children that
were hidden later (such as Spellbook skill-line tabs) kept pushing the
center panel right, and panels that already cleared the left panel were
pulled back to the left.

Recalculate the rightmost visible child while both panels are shown and
only shift the center panel when its backdrop really overlaps.

* Align Quest Log, Friends and Spellbook panel heights

Most skinned panels draw their backdrop 430px tall, 10px below the frame
top (insets 10/-10 and -30/72). Three panels did not match:

- Quest Log: frame was 440px and anchored at y -104, so it stood 10px
  taller than a panel opened beside it. It is now 430px at y -114, with
  the list/detail panes and visible rows (22) reduced to fit.
- Friends: bottom inset was 74 instead of 72.
- Spellbook: top-left inset was 12/-12 instead of 10/-10.

The Quest Log is a doublewide UI panel. Opening another panel next to
it made UpdateUIPanelPositions re-anchor it to the default (0, -104),
causing a visible jump. Its UIPanelWindows entry now carries the same
x/y offsets as the OnShow anchor.

* Let the panel manager place UI panels

Remove the OnUpdate panel aligner. UpdateUIPanelPositions already lays
out left/center/right panels, and with the overlap-only rule the
aligner no longer changed the spacing in normal cases.

The Quest Log's UIPanelWindows offsets put it at 10, -114 on every
layout pass, so the QuestLog_OnShow re-anchor is redundant.

---------

Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com>
2026-10-22 20:48:41 -05:00
Seraphic8x2244 341ba95561 Fix addon button panel startup visibility (#61)
* fix(addonbuttons): rescan before startup visibility check

* Fix missing percentage symbols in unitframe labels
2026-10-22 20:40:00 -05:00
Brues 1600ec333b game_menu: skin every menu button dynamically
Scan GameMenuFrame's children on load and on each show instead of a
hardcoded list, so buttons added by other addons (ClassicAPI AddOn
Options, MoveAnything, MCP, SuperMacro, HardcoreDeath, Turtle shop) get
skinned without per-addon calls.
2026-10-22 18:41:47 -05:00
Brues 471c5713c5 use GetPhysicalScreenSize to get Screen Resolution 2026-10-19 20:20:03 -05:00
Brues 5d38322b2e stable: skin every stabled pet slot the client creates 2026-10-19 01:33:09 -05:00
Brues 40dd9dd6db equipmentmanager: drag a set onto the action bars via PickupEquipmentSet 2026-09-27 00:13:27 -05:00
Brues c1eba4d295 Bump CAPI min to 1.15.10 2026-09-25 10:58:07 -05:00
Brues cbc531531c swingtimer: drive the timers from ClassicAPI's PLAYER_SWING
Replaces the Lua reconstruction of the swing clock (AUTO_ATTACK_SELF with
an extra-attack guess, parry-haste maths, Slam freeze, DBC-based reset
checks on every SPELL_GO including triggered spells). PLAYER_SWING tracks
the server's clock from packets, so triggered casts, extra attacks, parry
haste, weapon swaps and the ranged wind-up all match the server.

Refs #58
2026-09-25 10:56:01 -05:00
Brues b57fc52f9a libbagsort: group gear by equip slot
Gear was split into four quality tiers and ordered by class, subclass
and name inside each, so a helm could sit between two pairs of boots.
Gear is now one category, ordered by class, then equip slot, then
subclass, then best quality first, then name.

The slot ranks come from a table keyed by the equipLoc token, not the
token's alphabetical order (which puts chest before head) or its INVTYPE
number (which parts robe from chest). The order matches ClassicAPI's
C_Container.SortBags and comes from Baganator.
2026-09-25 10:24:09 -05:00
Brues 8268af915a energytick: let the five-second rule display as a separate bar or the old shade
The shading bar sat on top of the power bar's own fill and shrank from the
right as the window drained, which reads as part of the mana bar rather than
a countdown over it -- the same problem nameplate castbars solve by living
below the health bar instead of on it.

Show Five Second Rule Style now picks between that: a real StatusBar below
the power bar, backdrop and all, or the original translucent overlay for
anyone who prefers it. The style is read once at module load like the other
structural toggles here, not swapped live -- a /reload picks up a change.
Height and color are only meaningful for the separate-bar style, so the
GUI's Five Second Rule Height and the new appearance.castbar.fsrcolor picker
apply to it alone; the overlay is unchanged from before.

The sweep spark's own dim/solid signal (fsrEnd/fsrGain) is untouched by any
of this -- it keeps dimming through an unconfirmed window regardless of
which display, or none, is shown.

Energy/Mana Ticks -- including both five-second-rule settings -- moves from
Unit Frames > General to Unit Frames > Player, right after Powerbar: they
are C.unitframes.player-only, so General was never the right tab, and
Powerbar is the setting group they actually belong to.
2026-09-22 21:19:12 -05:00
Brues 1108746949 castbar: mark a cast that none of your interrupts can stop
ClassicAPI carries notInterruptible on C_Spell.UnitCastingInfo (arg 8) and
UnitChannelInfo (arg 7); both call sites already stepped over it positionally.
The target, focus and nameplate bars now paint it.

There is no shield art to hang on the icon -- this client ships three
CastingBar textures (Border, Flash, Spark), and Blizzard's shield arrived in
3.x -- so the state is carried by color instead: the bar and the icon's
border both take a new appearance.castbar.shieldcolor, which keeps it legible
on a bar configured without an icon. One api helper paints both so the two
modules cannot drift apart on it.

Dusty rose (.8,.45,.45) rather than a steel grey. Grey is the retail
convention, but pfUI's casting color is already a near-grey pale blue, so the
two separated on brightness alone and washed out against the bar texture. The
rose sits above failcolor in luminance and well below it in saturation, and
the two are further told apart by motion: a failed cast flashes the bar full
and fades, a shielded one fills normally and tints the icon border, which
failcolor never touches.

Not on the player's own bar. The flag is measured against the reader's own
interrupts and silences, so on your own cast it answers a question nobody
asked.

Stamped once at cast start, with the rest of the cast data, rather than
re-polled. ClassicAPI evaluates lazily from the caster's live auras but does
not yet fire the 3.3.5 UNIT_SPELLCAST_INTERRUPTIBLE / _NOT_INTERRUPTIBLE
change events, and polling per frame would undo the event-driven rework these
bars just got -- so a caster who bubbles mid-cast keeps the bar it started
with until the next one.

Two limits worth knowing when it stays dark. The value is relative to your own
kit -- with no interrupt and no silence known it is never reported, whatever
the cast -- and a creature's built-in interrupt immunity lives in
creature_template, which 1.12's SMSG_SPELL_START does not carry, so a boss
with that immunity reads interruptible while your kick still fails on it.
2026-09-13 15:19:42 -05:00
Brues 38b4100353 server agnostic <3 2026-09-12 04:36:27 -05:00
Brues f497c71523 Filter unit events to their units, rework energytick, drop macrotweak
Eight commits off classicapi_next.

ClassicAPI's RegisterUnitEvent registers for an event but only delivers it
when arg1 is one of the given units, so a handler for one unit stops waking
for every other one in the world. The 26 registrations whose unit set is
fixed at registration time now name it. The rule throughout is register the
superset and keep the handler's own check -- the filter narrows what arrives,
it does not decide what to act on. Guards that look unreachable stay put: the
filter applies only when arg1 is a string, so an event that fires with a
number or no argument is delivered as if plainly registered.

Frames whose unit changes at runtime own their subscriptions instead of
sorting events out per event. unitframes points them at the unitstr
UpdateVisibility already computes -- replacing a string concat, and on a miss
a second concat plus a UnitGUID call, for every frame on every unit event in
the world -- and a frame that is not in use drops its unit events entirely.
nameplates registers per plate against the plate's own token, which is also
the only workable shape: slots have no cap, so any nameplate1..N list would
have been a guess that fails in exactly the crowded scenes where plates
matter. marktracking names mark1 through mark8. A registration keeps its
kind, so none of these can be plain-registered first.

Both teardown paths PLAYER_LOGOUT guards -- the crash 132 -- now cover the
per-frame subscriptions: plates tear down rather than dispatching through
logout, and a unit frame takes itself off the visibility scan so it cannot
re-register what it just dropped.

marktracking also drops its once-a-second full rebuild, which ran for the
whole session whether or not a marker existed anywhere. The ticker is created
and cancelled with group membership. It is deliberately not keyed on a mark
being visible -- a marker on an out-of-range unit shows no row, and that is
the case the poll exists to catch.

nameplates gates the per-plate update against the floor across all four
throttle categories before classifying it, instead of running a GetAlpha, a
castbar IsShown, a cast lookup and up to two libthrottle:Get resolutions on
plates throttled to 10fps that were going to return anyway. Nothing that
would have updated can be turned away by a floor. The four throttles resolve
in CacheConfig, where config changes already land.

energytick sweeps the clock the server actually runs. There is one regen
timer for every power, re-armed every 2s by Player::RegenerateAll and never
touched by casting; the five-second rule changes what a tick pays, not when
it lands. The sweep is a free-running phase lock on that clock, so
Illumination refunds, potions and a Mana Spring totem on its own phase no
longer snap the spark mid-cycle, and an 80ms band keeps a correct tick from
hitching it at the wrap. The FSR window shades rather than predicting a share
of spirit the client cannot compute -- the Casting Regen item ladder is equip
auras absent from the buff list. The energy period is summed from
SPELL_AURA_MOD_ENERGY_REGEN_TIME across the spellbook and buffs, so Blade
Rush is found without GetTalentInfo(2, 16), an ordinal that does not fail
when the tree changes but reads another talent's rank.

macrotweak is gone -- ClassicAPI 1.15 covers it -- with its config entry, its
GUI block, its translations in all eight locales, and actionbar's
ButtonMacroScan, the #showtooltip scanner that fed it.
2026-09-11 00:10:51 -05:00
Brues 8e109a585a eqcompare: place the compare after the tooltip settles when Guda is loaded
Guda anchors its item tooltips with ANCHOR_NONE and its own SetPoint, and
the tooltip module then relocates every ANCHOR_NONE tooltip to its
configured spot. eqcompare picked left or right from GetLeft/GetRight
inside the Set* call -- against the position the tooltip was about to
leave -- so for an item in the left half of the screen the shopping
tooltips anchored to the right edge and rode the relocation off-screen
(vatichild/guda#41). Guda's own inventory block also widens the tooltip
after our hook has run.

With Guda present, resolve the link in the hook but hand the placement to
RunNextFrame, skipping it if the tooltip has hidden since. Guda lists
pfUI as a dependency, so it loads after us: gate on DoesAddOnExist and
flip the flag from ContinueOnAddOnLoaded. Without Guda the hook is
unchanged.
2026-09-09 13:23:53 -05:00
Brues 83f89be14a unitframes: compare indicator auras without case folding
The indicator scan lowercased the aura's name and icon on every aura of every
unit, and SetupBuffIndicators lowercased the other side to match. Both sides
come out of the same DBC records byte for byte, so the comparison already held
without any of it: the aura's name and icon are Spell.dbc's localized name and
SpellIcon.dbc's path (aura/Data.cpp fills one struct and emits it as either the
AuraData table or the positional UnitAura tuple), and the indicator record
reads those same two fields through C_Spell.GetSpellName / GetSpellTexture.

So this was two string allocations per aura per scan to reach a result it
already had -- and on Lua 5.0 that is an allocate-and-hash each time, since the
VM interns even when the string exists. RefreshUnit runs this for every unit
frame, which in a raid is 40 frames against up to 32 auras each.

Checked every rank of all 65 indicator spells in Spell.dbc: name and icon are
byte-identical across a spell's whole ladder, no case or spelling drift, so
nothing depended on the fold.

It also drops a crash path. aura/Data.cpp yields nil for the icon when a
spell's SpellIconID is 0, and icon:lower() would have errored on that; name was
guarded on the line above but icon never was. A raw compare is just false.

The equality is now load-bearing, so AddIndicator's comment says to feed it
spell ids and never a hand-written name or icon path -- a literal
"interface\icons\foo" in that table would silently match nothing.
2026-09-08 16:35:31 -05:00
Brues e59158764c unitframes: identify buff indicators by spell id, not icon path
Spell.dbc reuses icons freely across unrelated spells, so matching an aura on
its icon alone lit the indicator for the wrong buff. Blessing of Sanctuary
fired on Lightning Shield and Shadowguard, Blessing of Kings on Mage Armor and
Commanding Shout, and Totemic Power on the Blessed Sunfruit food buff -- the
last of which the code already carried a comment about. Fixes #55.

Each entry is now a spell id, resolved once into the aura's name plus its icon,
and a match needs both. Name alone is no better than icon alone: creature and
item auras reuse player spell names, so a mob's "Renew" or a trinket's
"Rejuvenation" would light a HoT indicator. Every rank of a spell carries the
same name and icon, so one id covers the whole rank ladder without listing it.

HOT_INDICATORS folds away with this. It existed to name-check exactly the three
HoTs whose icons were known to collide; that check is now what every entry
does, and the table's only remaining job -- naming a HoT's libpredict key -- is
an argument on the Renew, Regrowth and Rejuvenation entries.

Deriving the name from an id also picks up this client's renames for free. The
paladin blessings are "Hand of Freedom", "Hand of Protection" and "Greater
Blessing of Sacrifice" here, which hardcoded English names would have missed.

All 65 ids were checked against the client's Spell.dbc, SpellIcon.dbc and
SkillLineAbility.dbc: each resolves to the intended aura, with its full rank
ladder sitting on the icon the old list matched.

That check also turned up five entries matching no spell at all on this
client. ability_hunter_misdirection, spell_holy_prayerofmendingtga and
inv_misc_herb_felblossom are TBC leftovers and are gone.
spell_nature_giftofthewild was never right -- Gift of the Wild uses Mark of the
Wild's icon -- and is now covered by id 21849. ability_warrior_rallyingcry
hosts no Commanding Shout either, so that entry now points at the real spell
(45580) and works for the first time.

Unrelated to the above, this file's string.fn(s, ...) calls become s:fn(...).
2026-09-08 16:28:51 -05:00
Brues 863d99647d Draw the loot history and map overlays from real pools
Both modules had already grown a pool by hand. loothistory kept usedPlayers /
freePlayers tables with a recycle loop and a table.remove acquire; mapreveal
kept pfOverlays keyed by index, a pfOverlayMax high-water mark, and a
hide-the-tail loop. Replace both with ClassicAPI's Pools.lua backport, which
is what modules/tooltip.lua already uses for its buff icons.

The map explore icons change shape rather than just plumbing. Everything
constant -- size, scripts, mouse, frame level, the magnifying glass texture --
moves into the pool's creator instead of being re-set on every overlay on
every map update, and the acquire moves inside the visibility test. The old
loop built and configured an icon for every overlay in the zone and then hid
most of them again; with "mapexploration" off it built the whole set and hid
all of them. Now nothing is acquired for an icon that will not be shown.

The tile textures lose their pfRevealN names, since pools create anonymous
regions. They were already unique, so nothing was being clobbered -- this
only costs their labels in /fstack.
2026-09-07 18:41:54 -05:00
Brues 06b3ae8d22 cooldown: stop shadowing the global time()
`local time = time()` bound the timestamp over the top of the time function
inside that branch, so any later call in the same scope would have indexed a
number. Nothing did, but the name is a trap. Call it currentTime.
2026-09-07 18:39:28 -05:00
Brues 879d7afe83 cooldown: throttle before the work, not after
The 0.1s gate sat below the hidden-cooldown check, so every frame, for every
ticking cooldown, the update built "<parent>Cooldown" twice and did two _G
lookups with it. Lua 5.0 interns on every concat -- it allocates and hashes
even when the string already exists -- so this was allocating garbage at the
frame rate times the number of live cooldowns. A profiler run had it at 24s
of accumulated CPU.

Move the gate to the top so a non-tick frame costs one GetTime() and a
compare. The name lookup goes away entirely: pfCreateCoolDown already has the
cooldown frame, so it stashes the reference instead. That is also more
correct than deriving it from the parent's name, which silently skipped the
check for any cooldown not named "<parent>Cooldown".

The text frame and its fontstring were both created with a fixed name, so
every one of the hundreds in a UI clobbered _G.pfCooldownFrame and left it
pointing at whichever was made last. Name them after the cooldown they render
for, falling back to a counter for anonymous ones.

One behavior change: the hidden-cooldown check is now throttled too, so text
can linger up to 100ms after its cooldown frame hides. It only refreshes at
0.1s anyway, and expiry still runs through the remaining < 0 branch.
2026-09-07 18:14:33 -05:00
Brues 4eab494a01 Name the installed ClassicAPI version in the outdated popup
"cannot run on this ClassicAPI" named no version, so the player had nothing
to compare against the requirement, and it overstated the failure: pfUI does
load on an old DLL, it just throws wherever it reaches for an API that isn't
there. Put the installed version in the headline and soften it to "will not
work correctly"; the detail line then only has to state the requirement.
2026-09-07 17:55:56 -05:00
Brues bb8ce8fd63 apparently some addons can't figure out -1 for themselves 2026-09-05 07:19:58 -05:00
brues-code 75c4657ab9 ClassicAPI flavor TOCs, and drop the multi-client scaffolding (#53)
* nameplates: source totem icons from UnitCreatedBySpell

Read the totem's icon from the totem-drop spell (UnitCreatedBySpell +
GetSpellTexture) instead of the self-aura at index 1 plus a
UNIT_SPELLCAST_SUCCEEDED capture for active totems. The drop spell is a
broadcast descriptor field present for every summoned unit in range, so
it resolves immediately for passive and active totems alike and gives the
totem's own icon rather than the attack-spell proxy. Drops the
UNIT_SPELLCAST_SUCCEEDED registration and handler.

Re-read the spell each render and key the cached texture on the spell id
so an in-place totem swap (same unit, new drop spell -- no plate re-add)
refreshes the icon without needing the plate to leave and re-enter view.

* CAPI min bumped to 1.13.1

* Gracefully disable pfUI when ClassicAPI is missing

Add API_Check.lua as the first TOC entry. When the ClassicAPI DLL is
absent or below the minimum version it sets pfUI_disabled and stands up
an inert stub so the rest of the addon no-ops instead of flooding load
errors: modules and skins register their bodies into no-ops, and the
setfenv'd api/lib files run inside an environment where CreateFrame and
any missing global resolve to a null object -- so no real frames or live
handlers are created and missing API calls just return null. pfUI.lua
bails early on pfUI_disabled.

* auras: scan through GetAuraSlots instead of by-index loops

Every aura scan loop (unit frame buffs/debuffs, dispel indicators, buff and
custom indicators, player buff frame, buffwatch bars, tooltip buff row) now
enumerates a unit's auras once with C_UnitAuras.GetAuraSlots and reads each
aura by slot id via the positional C_UnitAuras.UnitAuraBySlot. The by-index
getters re-walk the aura array from slot 0 on every call, so a per-button
loop over them was quadratic in the aura count; one enumeration plus a
by-slot read per aura is linear.

pfUI.api.ScanAuraSlots(unit, filter, buf, max) wraps GetAuraSlots' fill-a-
table form (table as the 5th argument) so no vararg Lua frame is involved:
Lua 5.0 allocates an `arg` table for every vararg call, which showed up as
nameplate OnUpdate/OnEvent memory growth in the first cut of this change.

Single by-index reads in tooltip and click handlers are unchanged (one call
each, and SetUnitAura takes the same index).

Requires the ClassicAPI build that adds GetAuraSlots' fill form; on an older
DLL the 5th argument is ignored and ScanAuraSlots would read the first slot
id as the count.

* Show Faction/Race icons in chat

* Load pfUI through ClassicAPI's flavor TOCs

ClassicAPI redirects the read of pfUI\pfUI.toc to a flavored file whenever
the DLL is installed, so which TOC the client opens already answers whether
ClassicAPI is there. Split the manifest three ways and let that do the work:

  pfUI.toc             fallback, reached only when ClassicAPI is missing;
                       loads API_Check.lua and nothing else
  pfUI_ClassicAPI.toc  full addon, every non-Turtle client
  pfUI_Turtle.toc      full addon plus init\turtle.xml, on Turtle

The fallback TOC declares no SavedVariables. It used to, while API_Check.lua
reset pfUI_profiles to an empty table on the disabled path -- which truncated
the player's profiles on logout.

With the missing-DLL case handled by TOC selection, API_Check.lua drops the
null object stub that kept the other ~140 files quiet, along with
pfUI_disabled and the now unreachable early return in pfUI.lua. It keeps the
version gate, which still matters: the flavor redirect landed in ClassicAPI
v1.11.0, below the v1.13.1 pfUI needs, so an old DLL still gets served a
flavor TOC. pfUI.lua also loses a verbatim duplicate of the whole check.

Turtle-only files move to init\turtle.xml: modules\turtle-wow.lua (its
TURTLE_WOW_VERSION guard is now redundant) and the lft, turtle_shop,
barbershop, transmog and ebc skins. turtle-wow registers last instead of
75th of 84; the only ordering it relies on is pfUI.chat, registered 8th.

pfSellData moves to env\selldata.lua, listed only in pfUI_ClassicAPI.toc,
since turtle-wow.lua replaces the table wholesale on Turtle. env\tables.lua
keeps an empty declaration so sellvalue.lua has something to index when the
turtle-wow module is disabled.

The release workflow pinned PFUI_CLASSIC_API_LATEST in pfUI.lua, which has
not held that constant since it moved to API_Check.lua, so the pin was
silently doing nothing. It also switches to brues-code/packager@vCAPI, which
recognizes the _ClassicAPI and _Turtle suffixes and applies the TOC build
type filters to them.

* Split the vendor price tables into their own manifests

Turtle's pfSellData moves out of modules\turtle-wow.lua into
env\selldata_turtle.lua, matching env\selldata.lua for the stock list, and
each is pulled in by the manifest for its client: init\stock.xml from
pfUI_ClassicAPI.toc, init\turtle.xml from pfUI_Turtle.toc. Either way it
loads after init\env.xml and replaces the empty pfSellData declared there.

Turtle's prices used to be assigned inside the turtle-wow module body, which
put them on pfUI.env and skipped them entirely when that module was
disabled. At file scope they land on _G and apply either way.

* Drop the vanilla compat layer

compat\vanilla.lua named the handful of things that differed between clients
back when pfUI targeted several. Only one client remains, so every constant
had exactly one value. Inline each at its use site and delete the file,
init\compat.xml, and both TOC entries.

  COOLDOWN_FRAME_TYPE                    -> "Model"
  LOOT_BUTTON_FRAME_TYPE                 -> "LootButton"
  MINIMAP_TRACKING_FRAME                 -> _G.MiniMapTrackingFrame
  FRIENDS_NAME_LOCATION                  -> "ButtonTextNameLocation"
  EVENTS_MINIMAP_ZONE_UPDATE             -> the event list, in panel.lua
  MICRO_BUTTONS                          -> a local in panel.lua
  NAMEPLATE_OBJECTORDER                  -> a local in nameplates.lua
  ACTIONBAR_SECURE_TEMPLATE_BAR/_BUTTON  -> nil, so the argument goes away

NAMEPLATE_FRAMETYPE and PLAYER_BUFF_START_ID had no readers left.

RunMacroText moves to pfUI.lua. compat\vanilla.lua was setfenv'd into the
pfUI environment, so the function only ever existed on pfUI.env; at file
scope it lands on _G as a real export instead. Nothing in pfUI calls it, and
ClassicAPI neither defines nor looks for a RunMacroText global -- it does
the same throwaway edit box natively in src/macro/Execute.cpp and only
defers to a global RunMacro.

* bump CAPI min to 11303

* auras: uncap the self-debuff tooltip lookup

With selfdebuff on, the displayed debuff list is PLAYER-filtered while
GameTooltip:SetUnitAura indexes the unfiltered HARMFUL list, so both
handlers map one to the other by matching name + sourceGUID. That mapping
scanned slots 1..16 only.

The unfiltered harmful list is not capped at 16. Once a unit's 16 debuff
slots are full the server parks further debuffs in buff slots, and
C_UnitAuras classifies by the aura's polarity flag rather than its slot
range, so it reports those as harmful too -- verified live at 18 harmful on
a 20-aura target. Past the sixteenth the lookup found nothing and fell
through to the raw filtered index, opening the wrong tooltip or none.

Both now enumerate however many harmful auras the unit actually has, via
ScanAuraSlots, which also drops the per-index rescan the by-index accessor
was doing. Each handler gets its own slot buffer: OnEnter can fire while a
refresh is showing/hiding frames under the cursor, so sharing the refresh
buffer could clobber a scan mid-walk.

The nameplate module still collects at most 16 debuffs per plate. That one
is a display cap matching its 16 configured icon frames, not an aura-count
assumption, so it is left alone.

* bump CAPI min to 11304
2026-09-04 19:57:57 -05:00
Brues 5815b9e81e chat: let pfUI's chat colors own their alpha and apply live
Two problems with routing the native transparency slider into the pfUI panel.

RefreshBackgroundAlpha overwrote the alpha of C.chat.global.background on every
refresh, so anyone with custom colors enabled saw their configured opacity
revert on reload, tab switch and dock change. That value carries its own alpha,
is set by the shipped profiles and is shared with the meter skins, so the slider
must not own it. Skip the alpha mirror entirely when custom colors are on; the
slider still drives the panel on the default theme, which is what issue #48 was
actually about.

The colors were also only applied at module load, so the pickers needed a
/reload to show anything. Extract that into ApplyPanelColors and expose it as
pfUI.chat:UpdateConfig, which the gui resolves as U["chat"], so the three chat
color settings take effect on the spot. CreateBackdrop is re-run first to
restore the appearance theme, which is what lets toggling custom colors back
off return the panel to the global theme without a reload.
2026-09-02 11:40:20 -05:00
Brues 60f953178f nameplates: validate unitstr before filling the per-unit cache
cache.player and cache.minion were filled from unitstr before the two guards
that validate it, so a stale identifier poisoned the cache -- and because the
fill is gated on `== nil`, the wrong answer was never recomputed. Players read
back as cache.player == false until the plate was hidden and shown again, which
only appeared to fix it because pool reuse tripped the name/guid wipe.

Two paths produce a stale unitstr: OnUpdate dispatches a targetUpdate to
OnDataChanged before it refreshes plate.istarget, and frameState.mouseoverGuid
is only updated on gaining mouseover, never on losing it.

Hoist the PLAYER_TARGET_CHANGED distrust and the UnitName mismatch check above
the cache fill so an unverified unitstr leaves the cache nil for the next tick
instead of locking in a wrong answer.
2026-09-02 10:56:46 -05:00
Brues 1dc10964a2 luarc: use nested config form so diagnostics settings apply 2026-09-02 10:31:03 -05:00
Brues 0fc08e77c0 Create .pkgmeta 2026-09-02 10:26:28 -05:00
Brues 7f3795b45b Add .luarc.json for Lua 5.1 language server diagnostics 2026-09-02 10:23:48 -05:00
Brues 8eee766652 chat: apply Blizzard per-window transparency to docked backdrops
The native chat background transparency slider drives FCF_SetWindowAlpha,
which only touches the ChatFrame*Background textures pfUI hides on docked
frames, so the visible pfUI backdrop never responded to it.

Mirror the selected window's stored alpha (GetChatWindowInfo) onto the pfUI
backdrop and refresh it from RefreshChat, FCF_SetWindowAlpha and
FCF_SelectDockFrame so the native slider drives it live and persists across
/reload. Default the SetupPositions window alpha to 0.8 to keep the historical
look, and migrate existing installs whose windows still carry the old hard-0
alpha so their chat background is not suddenly transparent.

Fixes #48
2026-09-02 01:05:47 -05:00
Brues 2b5288a688 nameplates: don't run GetUnitInfo for minions 2026-08-31 16:43:38 -05:00
Brues daba4e202e Default saved variables with 'or {}' instead of overwriting
Seed the SavedVariables globals only when absent (X = X or {}) rather
than unconditionally assigning {}. Behaviorally identical under the
current load order -- a returning character's data is restored over these
between file load and ADDON_LOADED -- but expresses intent as a default
and won't clobber data if that timing ever changed.
2026-08-31 12:04:00 -05:00
Brues 98c7751416 Utilize CAPI Tracking functions
commit 8ea5c81789
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Aug 24 23:40:01 2026 -0500

    bump CAPI min to 1.12.4

commit 39a46563a1
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Aug 24 23:35:49 2026 -0500

    tracking: use native ClassicAPI tracking API

    Replace the hardcoded knownTrackingSpells class table and the
    icon-substring spellbook scan with ClassicAPI's native tracking
    functions:

    - RefreshSpells now enumerates GetNumTrackingTypes() / GetTrackingInfo(),
      which the DLL derives from the spellbook by tracking-aura effect. This
      drops the per-class spell/icon table and picks up server-custom
      trackers (e.g. Turtle's Find Trees) automatically.
    - Selecting a tracker in the menu uses SetTracking(index) instead of
      CastSpell(slot, BOOKTYPE_SPELL).
    - Keep the Druid Cat Form gate on Track Humanoids (5225) and the
      existing invalidSpells filter. Falls back to no entries if the tracking
      API is absent.

    Active icon (GetTrackingTexture), cancel (CancelTrackingBuff), and the
    hover tooltip (GameTooltip:SetTrackingSpell) were already native and are
    unchanged.

Fixes #42
2026-08-30 17:19:17 -05:00
Brues 8796fab6d8 libpredict: predict incoming heals for built-in click casting (#44)
Built-in click casting drives the cast through secure frame attributes,
bypassing the CastSpell/CastSpellByName/UseAction hooks that populate
spell_queue -- so the heal-prediction lookup in the SPELL_START_SELF
handler missed and no incoming heal showed.

Populate spell_queue from the cast's own rank-specific spellId (via
C_Spell.GetSpellName/GetSpellSubtext) right before the cache lookup, so
prediction works regardless of how the cast was initiated. Deriving the
rank from the actual spellId also fixes stale-rank lookups when a prior
keybind cast left a different rank of the same spell queued.
2026-08-24 21:37:41 -05:00
brues-code 7ca0e40d8b CAPI needs 1.12.1 for UnitAura changes 2026-08-24 12:05:18 -05:00
brues-code 2f93b246a1 Accidentally bumped ClassicAPI to the wrong version 2026-08-24 11:48:54 -05:00
Brues c647698f8f bump CAPI min 2026-08-24 11:07:38 -05:00
Brues 48026008b6 buffwatch: use official dispel-type colours for debuff bars
The debuff-bar auto colour read the vanilla DebuffTypeColor global,
diverging from unitframes/buff which use C_UnitAuras.GetAuraDispelTypeColor
(the BC GlobalColor.dbc palette ClassicAPI ships). Switch buffwatch to the
same accessor so all aura displays share one palette; nil/unknown types
fall back to DEBUFF_TYPE_NONE instead of the old ad-hoc (1, .2, .2).
2026-08-24 11:07:38 -05:00
Brues c1d96bae58 buff/buffwatch: positional aura reads in hot refresh loops
buff.lua RefreshBuffButton runs 50x per PLAYER_AURAS_CHANGED and
buffwatch.lua GetBuffData runs 32x per RefreshBuffBarFrame; both now use
the zero-allocation positional C_UnitAuras.UnitAura instead of the
table-allocating GetAuraDataByIndex.

buffwatch also threads the aura's dispelType out of GetBuffData onto the
frame.buffs row, so the debuff-bar colour reads it from the row instead
of re-fetching the aura with GetDebuffDataByIndex on every name change.

Cold single-lookups (hover/click tooltips) keep the readable table API.
2026-08-24 11:07:38 -05:00
Brues 1d44c5ec6f unitframes: scan debuff slots once for dispel indicators
The dispellable-indicator block re-scanned all 16 harmful slots for
every dispellable type (O(types x 16) UnitDebuff calls per refresh).
Scan the 16 slots once into a reusable set, then have the per-type loop
check the set. Zero-allocation (the set is cleared and reused within the
single RefreshUnit call).
2026-08-24 11:07:38 -05:00
Brues 8f88dfd852 Use positional C_UnitAuras accessors in hot aura scans
Swap the per-frame aura-refresh loops from table-allocating
GetAuraDataByIndex/GetBuffDataByIndex/GetDebuffDataByIndex/GetUnitAuras
to the zero-allocation positional C_UnitAuras.UnitAura/UnitBuff/UnitDebuff.

unitframes: buff/debuff icon loops, the dispellable-indicator 16-slot
scan, the two GetUnitAuras indicator passes, and the custom-debuff scan.
nameplates: the per-plate debuff scan now writes positional results
straight into the reusable display buffer, dropping the per-aura tables
and the result array.

Filters change from HARMFUL|PLAYER/HARMFUL to PLAYER/nil since UnitBuff/
UnitDebuff lock the range and still honor the PLAYER predicate. Cold
single-lookups (hover/click, tooltip, totem icon, libdebuff) keep the
readable table API.
2026-08-24 11:07:37 -05:00
Brues a57214aeb0 Bump ClassicAPI minimum version 2026-08-24 11:07:37 -05:00
Brues 9bde843e33 utlize inline icons and CreateGoldString in repair module 2026-08-24 11:07:37 -05:00
Brues ad13e6ace3 Utilize SetFormattedText
This change updates several text setters to use `SetFormattedText` instead of passing `string.format(...)` into `SetText`. It also switches a few regex captures from `string.find` to `string.match` for cleaner capture handling, and replaces explicit width/height setters with `SetSize` in the first-run dialog for consistency.
2026-08-24 11:07:37 -05:00
Brues 82c74c2db5 Skip declaring pfSellData on turtle client
This giant table is just going to be immediately replaced so there's no point in declaring it.
2026-08-21 14:59:19 -05:00
roby-brok a3cfd711fe nameplates: read friendly name colours from the class table
The class-colour write sourced r, g, b from the health bar rather than
from PFUI_CLASS_COLORS[class], which the condition tested for but never
read. So "class colours on friendly names" only produced a class colour
when friendclassc - a bar option - happened to be on as well; otherwise
the name took the generic friendly colour. In every case it also
inherited the tapped-grey and barcombatstate overrides meant for the bar,
neither of which belongs on the name.

The name now reads the class table directly.

The discarded "and PFUI_CLASS_COLORS[class]" term was dead weight: the
table carries an __index metamethod returning a grey ColorMixin for any
missing key, so it was always truthy and merely allocated a throwaway
table per evaluation. "and class" is the real guard. One behaviour change
falls out - a friendly player of an unrecognised class now takes that
grey fallback rather than the bar colour, which is what the option means.

(cherry picked from commit f880dc3528db2ba0d0936b00a4dff8deec48e6d2)
(cherry picked from commit 111d70004d4fb172f168aa48a4cb6177a7f0d393)
2026-08-21 13:31:07 -05:00
roby-brok a7ad1f073f nameplates: give the name colour a single owner
cache.namecolor was written by two writers holding unrelated quantities:
the computed health-bar colour in OnDataChanged, which class-colours
friendly player names when friendclassnamec is on, and Blizzard's own
name FontString in the OnUpdate sync. Sharing one key let either suppress
the other, so the option silently lost - names came out white with
namefightcolor off, or the plain reaction colour with it on.

It also forced a full data pass every throttled tick, because the sync
writer sets update = true whenever it writes and the two kept flipping
the key. That defeats the half-second tick gate entirely.

Compounded by nameplate.cache surviving pool reuse: OnShow re-runs the
data pass but never clears the table, which is built once at plate
creation, so a recycled plate could inherit the previous unit's name
colour.

Ownership is now explicit through cache.ownname, each writer keeps its
own key, and both are invalidated when ownership flips.

(cherry picked from commit 0a4b3a7d6ae523cf70584adbb694a8740024b7cd)
(cherry picked from commit 0df9bb9fa907349182fb03217cab6aa1777aa7d9)
2026-08-21 13:31:07 -05:00
roby-brok fe5b3b135b nameplates: use true difficulty colours for level text
The level string was brightened by +0.3 on all three channels before
display, in the levelFromDB path and again in the OnUpdate colour sync.
A flat offset desaturates toward white and costs the high tiers most,
because their green/blue channels start near zero: verydifficult
1.00/0.50/0.25 becomes 1.00/0.80/0.55 and reads as yellow, impossible
1.00/0.10/0.10 becomes 1.00/0.40/0.40 and reads as orange. Orange and
yellow ended up 0.2 apart on a single channel, so a mob 3-4 levels above
the player showed yellow and a skull-range mob showed orange.

Both offsets dropped. Ownership of the colour is now explicit through
cache.levelfromdb so the two writers no longer race: the sync block
stands down on ?? plates, and the DB path clears cache.levelcolor so the
sync re-asserts cleanly once the level resolves. That also fixes a stale
cache - nameplate.cache is built once at plate creation and survives pool
reuse, so a recycled plate could keep the previous unit's colour.

Deleting the sync block instead would be wrong: it is the only thing that
colours the level on non-?? plates, and plate.level is created with no
colour at all.

Reported by Iden via Discord.

(cherry picked from commit eaa9beac51953d2a959c67d5ff5bc50273a919c3)
(cherry picked from commit 3fdb3b23136b260d111509e24e6d7b0d0b9b1b33)
2026-08-21 13:31:07 -05:00
Brues 9c29f0c7d4 Add handlesHookScript capability flag
Introduce pfUI.handlesHookScript boolean in pfUI.lua to signal that this fork's actionbar buttons correctly support the modern HookScript widget method. This prevents ClassicAPI's AddOnCompat shim from shadowing HookScript during actionbar load. The flag documents behavior (not identity): forks that maintain HookScript-correct actionbar code should keep the flag; forks that do not should clear it to opt into the safe compatibility fallback.
2026-08-21 13:26:09 -05:00
Brues 685ecb4a3e Removed !!!ClassicAPI from toc dependencies
Addon is now baked into the DLL and !!!ClassicAPI will always load before pfUI so this only served to confuse users
2026-08-18 10:35:31 -05:00
Brues 8cdaf1fc00 Prefer GetCoinTextureString in CreateGoldString
If the global GetCoinTextureString exists, use it to format money (wrapped in white color codes) for CreateGoldString. Keeps the existing numeric fallback formatting for environments without GetCoinTextureString.
2026-08-18 04:38:09 -05:00
Brues bb39c9d94e Add localized race info to pfUI environment
Initialize pfUI.env.L["race"] by iterating C_CreatureInfo.GetRaceInfo and C_CreatureInfo.GetFactionInfo. Builds a table keyed by clientFileString containing raceName, raceID and faction (groupTag).
2026-08-18 04:34:34 -05:00
Brues 18059ffbb7 Class-color aura caster name in tooltips 2026-08-18 04:29:33 -05:00
Brues d75e280238 Show party pets in raidpet frames under raidforgroup
When "Use Raid Frames To Display Group Members" is on and in a party,
raid pet frames tried to show raidpet1..40 (nonexistent in a party)
instead of the player pet and partypet1..4.

Remap raidpet grid slots to pet / partypet<N> in UpdateVisibility,
keyed on a stable pfRaidPet<N> slot, mirroring the raid player frames.
LayoutPets now mirror-places the party pet slots, and the raid updater
runs LayoutPets when in a party (not just a raid).

Also exclude raid pet frames (label "partypet", cache_raidpet set) from
the hide_in_raid group-hiding clause so they are not hidden.
2026-08-13 18:03:56 -05:00
Brues 9eb34b8f0a Revert "40-y rangecheck on by default"
This reverts commit af6893c10c.
2026-08-13 17:43:13 -05:00
Brues f8dde49f09 Add IsPlayerGuid API wrapper
Expose the built-in IsPlayerGuid helper through pfUI.api so callers can check whether a GUID or unit token matches the local player. This keeps the pfUI API surface consistent with the underlying WoW API while making the check available through the addon namespace.
2026-08-13 17:32:47 -05:00
Brues 74fbbb6154 Use PFUI_CLASS_COLORS in loothistory 2026-08-12 14:33:05 -05:00
Brues af6893c10c 40-y rangecheck on by default 2026-08-12 14:25:37 -05:00
Brues be6b2ea036 Support binding a click to a named macro
Accept "macro:<name>" in a click-cast action to run a saved macro by
name via the secure `macro` attribute (leading space after the colon is
trimmed). ClassicAPI dispatches it through RunMacro, so a conditional
addon still evaluates the macro body.
2026-08-12 00:33:49 -05:00
roby-brok afdb6c3862 unitframes: stop UnitHasAggro rescanning and reallocating on every call
Two costs on the hot path. It concatenated '<u>target' and '<u>targettarget'
per call per unit, though pfValidUnits never changes after load -- now built
once into a static triple list. And only positive results were cached, so the
common case (nothing has aggro) rescanned the entire unit table on every call;
negative results now cache for 0.3s, short enough that aggro still appears
promptly.
2026-08-11 02:06:28 -05:00
Brues b230a45b92 Show spell and unit IDs on tooltips
Add "Show Spell IDs" and "Show Unit IDs" options alongside the existing
item-ID line. Spell IDs come from GameTooltip:GetSpell() on spell
tooltips and from the aura's spellId on unit-aura tooltips; unit IDs
come from C_CreatureInfo.GetCreatureID on the mouseover unit's GUID
(skipped for players and guarded when the GUID carries no entry).
2026-08-11 00:38:28 -05:00
Brues ef1fa47539 Dock GreedMeter into the chat panel
Register GreedMeter's primary window on the meter dock's damage slot,
mirroring the ShaguDPS integration. GreedMeter builds its windows lazily
and supports several, so frames are resolved at call time.

A second GreedMeter window docks into the panel's other half: pfUI's
dock decides fill-vs-split by whether the threat slot is filled, so hook
GreedMeter's window add/remove to reconcile that slot and re-run the
resize. Only the first two windows fit the panel; any beyond that float.
2026-08-10 23:52:52 -05:00
Brues ab0ad7dcf9 Group tooltip settings into sections 2026-08-10 15:07:01 -05:00
Brues c82813df5b Use GetRGB() for NORMAL_FONT_COLOR 2026-08-10 15:05:48 -05:00
Brues 6e1f8095a2 Allow whitespace-only macro names
strtrim collapsed a name like " " to "" and the empty guard then
rejected the save, but a whitespace-only name is valid in vanilla and a
common way to make a name-less macro. Save the raw text and only reject
a truly empty box.
2026-08-10 09:53:34 -05:00
Brues 9cabdf2974 Revert the pixel-perfect scale change
GetPerfectPixel switched to UIParent:GetEffectiveScale(), which reports
the true unclamped scale (e.g. 1.42 on the larger pixelperfect presets,
since the module calls UIParent:SetScale past the uiScale cvar's 1.0
cap). At that scale 768/screenheight/scale drops below half a pixel and
the border edgeSize rounds to zero, so button borders disappeared.

The uiScale cvar's <=1.0 cap was load-bearing, not a bug: it keeps the
1px borders from vanishing. Restore the cvar-based measurement and move
pixelperfect back to its original load position.
2026-08-10 01:27:27 -05:00
Brues b6931359b0 Use the real UKNOWNBEING global in libpredict guards
The 1.12 client defines Blizzard's own misspelling, UKNOWNBEING
("Unknown Being"); UNKNOWNBEING does not exist and resolves to nil, so
both guards never matched. Point them at the real global.
2026-08-10 01:13:47 -05:00
roby-brok e017dbf515 Fix guards, cache keys and comparisons that never match (#40)
* chat: detect whispers before the timestamp is prepended

Whisper detection tests for the whisper colour code at position 1, but the
timestamp is prepended first, so with timestamps enabled the code is no longer
at position 1 and every whisper failed the test -- losing both the recolour and
the correct chat-history entry.

(cherry picked from commit 4b69d597631c422d9360a94ff129323288a28cc2)

* macrotweak + libpredict: inverted install guard, misspelled globals

macrotweak: _AddHistoryLine is the backup slot this block creates, so it is nil
until line 18 runs. Guarding on its truthiness meant the chat-history filter
never installed at all -- macro calls kept landing in chat input history.

libpredict: UKNOWNBEING / UNKOWNBEING are misspelled, so both resolve to nil and
the guards never matched the real UNKNOWNBEING. Neutral if the global is absent
on this client, correct if present.

Not needed: his libpredict already fixed the always-true
'event == "A" or "B"' condition (libs/libpredict.lua:828).

(cherry picked from commit 4068110dc4134823f1c09f60ca5f8959302cd14f)

* mapreveal: look the explore cache up by the key it is actually stored under

explorecaches is keyed by the plain area name (line ~160), but the hover frame
carried only a decorated 'mapFileName (area)' display string, so every lookup
missed and the hover highlight never fired. Store the plain name alongside it
and key off that; the tooltip keeps the decorated string.

(cherry picked from commit 5e6fe969a03a88c68e28614548b9d44db562ab9a)

* socialmod: don't clobber the friend-online match with the offline one

The offline match was assigned unconditionally over the online match, so a
friend coming online never had lastseen recorded.

(cherry picked from commit ad927806c46042163f84bde4db1082726bedf28b)

* swingtimer: off-hand weapons are inventory type 22, not 21

The off-hand slot accepts one-hand (13) and off-hand (22) weapons. Type 21 is
INVTYPE_WEAPONMAINHAND and can never be equipped there, so the off-hand swing
timer never recognised a real off-hand weapon.

The other two swingtimer fixes are not needed here: his hunter check already
uses UnitClassBase (locale-independent, better than our UnitClass second
return), and his generic on-next-swing detection covers Raptor Strike without
our hardcoded spell-id list.

(cherry picked from commit 9ab7f5f7224d12361ca6cd5a49181cbb4bebd387)

* superwow: compare the version numerically, not by exact string

SUPERWOW_VERSION == "1.5" silently disables the GUID-to-name combat text hook
on any release past 1.5. Currently 1.5 here, so this is forward-compat only.

Not needed: the clickthrough slash commands already go through
RegisterSlashCommand, which writes _G properly.

(cherry picked from commit 82a37752a5782479849ce7e1304c24733c2ff97a)

* api: measure a real pixel against UIParent, not the uiScale cvar

The uiScale cvar caps at 1.0 while both the pixelperfect module and the
firstrun slider push UIParent past it via SetScale, and it is ignored entirely
while useUiScale is off, so borders came out the wrong thickness on the
Huge/Large presets. Ask the frame for its effective scale instead, and guard an
unparseable gxResolution.

Also cache GetItemLinkByName and count its failures: the scan walked every id
on each call with no memory, so an unresolvable name hitched on every tooltip
hover. Raise the ceiling from 25818 to 61000 as well -- Octo/Turtle custom
items live well past the vanilla range and never resolved.

(cherry picked from commit dac2d3416aef85a4c4b71c0239d93d309e76e30b)

* init: load pixelperfect first so GetPerfectPixel caches the right scale

pixelperfect sets the UI scale that GetPerfectPixel measures against, and that
value is cached on first use. Loading it 56th baked in the previous scale.

(cherry picked from commit dd89a210330583f890a51a82b29e968f3ad36b34)

* modules: route two global overrides through _G so they leave the sandbox

pfUI.env has __index but no __newindex, so a bare global assignment inside a
RegisterModule closure is written into the sandbox table and never reaches _G.
unitxp's BattlefieldFrame_Show override therefore never fired the BG queue-pop
notification, and RaidFrame.lua never saw GROUP_REPLACE_PARTY.

The slash-command half of this fix is not needed here: RegisterSlashCommand
already writes through _G.

(cherry picked from commit 617c8320aca2465af62cf0ff5be7dceaed29a3b2)

* bags: remove the duplicate search OnHide handler

Two byte-identical frame.search OnHide handlers were installed back to back;
the second overwrote the first, so the first was dead code.

(cherry picked from commit e77650448b92e5d7f18ae58632e4531cb2813ea6)

* buffwatch: invalidate the filter cache when a skill is listed

fcache is built once per config table and never cleared, so ctrl/shift-clicking
a skill onto the whitelist or blacklist had no effect until the next reload.

* roll: actually capture the everyone-passed subject

strfind(LOOT_ROLL_ALL_PASSED, LOOT_ROLL_PASSED) has no captures, so `everyone`
was always nil, never reached the blacklist, and "Everyone has passed on: X"
was recorded as a real player passing.

Builds a sample from LOOT_ROLL_ALL_PASSED and runs the same LOOT_ROLL_PASSED
match the scanner uses, so the subject is captured the way it will actually
appear.
2026-08-10 01:13:32 -05:00
roby-brok 69d778d6d6 Fix two dangling skin includes and four error paths (#39)
* skins: drop includes for two files that were never committed

init/skins.xml referenced custom_merchant.lua and arena_score.lua, neither of
which is tracked in git. Every install -- release zips included, since the
release workflow packages the repo -- throws two 'Error loading' lines at
login and ships without those two skins.

(cherry picked from commit b338b4a16d0def4ae89fde5c6026e58a796b8c00)

* map: don't re-anchor the world map to the frame GetPoint returned

Ctrl+scroll rescales the map and repositions it to keep the top-left fixed, but
it re-anchored using the relative frame GetPoint handed back. Once anything else
is anchored to WorldMapFrame that throws

  WorldMapFrame:SetPoint(): <unnamed> is dependent on this

and the error aborts the rest of the zoom handler, so SetScale never runs.

Anchor to the parent instead. That is what the rest of pfUI's movable system
already assumes -- LoadMovable uses the 3-arg form and SaveMovable stores only
xpos/ypos with no relative frame.

(cherry picked from commit bf055d87fc0a04ac912c13fa874a4331f47bdfa8)

* firstrun: return after bailing on a disabled chat module

All three chat setup steps printed 'Chat module is disabled' and then carried on
into the nil pfUI.chat they had just tested for.

(cherry picked from commit 1af427e3b38bb7c13f645ae7a48b8ade3e7455a9)

* unitxp: stop the free-frame distance poller on logout

The PLAYER_LOGOUT handler stops the indicators to avoid the UnitXP crash on
exit, but in free-frame distance mode the polling runs on a separate scanner
frame that was never exposed, so the handler could not reach it and its
OnUpdate kept calling into UnitXP during teardown.

Exposes the frame as pfUI.uf.target.distanceScanner and stops it alongside the
others.

* roll: bail out on an item the client has not cached

C_Item.GetItemInfo returns nil for an item that is not cached yet, and the next
line assigns pfUI.roll.cache[itemName], which throws "table index is nil" on a
nil key. Easy to hit on a fresh login when someone rolls on an item you have
never seen.

* cooldown: return after hiding on a nil parent

Without the return it falls straight through to parent:GetName() on the nil it
just tested for.
2026-08-10 01:00:47 -05:00
Brues 75a25cf614 Show a mouseover unit's buffs on the tooltip
Add a "Show Unit Buffs" option that draws a row of buff icons above the
tooltip for mouseover units. Icons come from a ClassicAPI object pool
and are re-anchored left-to-right on each refresh; a single throttled
ticker counts down the remaining time on the visible icons.
2026-08-09 23:12:20 -05:00
Brues 9daf6165fd Show a note-only menu for offline friends
The friend right-click menu only opens for online players, so notes
could not be edited on offline friends. The full menu is useless
offline anyway (Whisper/Invite/Target need an online player), so open
a menu of our own with just the note editor for offline friends.
2026-08-09 22:47:28 -05:00
Brues 06768c985a Merge classicapi-next: friend list and spell fields on ClassicAPI
Squashed from the classicapi-next branch:
- Read spell fields through ClassicAPI instead of nampower (libdebuff, swingtimer)
- Read friend and who-list class tokens from C_FriendList (socialmod, libunitscan)
- Count online friends with C_FriendList.GetNumOnlineFriends
- Add a friend notes module (modules/friendnotes.lua)
- Bump ClassicAPI minimum version to 10906
2026-08-09 19:14:40 -05:00
Brues 881a17e508 Build the class name lookup from FillLocalizedClassList
Replace the hardcoded per-locale ["class"] reverse-lookup tables (localized
class name -> token) with a runtime build in GetEnvironment:

  L["class"] = tInvert(FillLocalizedClassList({}))

The client's own class list supplies the localized names for whatever locale is
running, so the tables were pure duplication -- and this also covers locales the
hardcoded tables never listed. Consumers (libunitscan, panel, socialmod) are
unchanged. Drop ["class"] from every locale file.
2026-08-09 19:03:29 -05:00
Brues 4e461d766e Read debuff durations from C_UnitAuras instead of a static table
Rewrite libdebuff's duration lookups on ClassicAPI's C_UnitAuras, whose
expirationTime carries the real, talent-modified remaining time:

- GetDuration reads the live duration of a matching aura on the player
  (C_UnitAuras.GetAuraDataBySpellName) instead of L["debuffs"][effect][rank].
- GetBestAuraCast reads the active aura's expirationTime directly rather than
  scanning the ownDebuffs/allAuraCasts cast tables -- a unit only ever holds one
  instance of a given spell, so that is inherently the effective one.
- GetMaxRank deleted (it only fed the old GetDuration); AddPending's
  known-debuff guard removed.

The public tracking tables (pfUI.libdebuff_*) are untouched. Drop the now-unused
L["debuffs"] and L["dyndebuffs"] tables from every locale.
2026-08-09 19:02:35 -05:00
Brues 2dfaa65168 Gate combopoint updates and fold player class-color branches
- combopoints: only ever show on the target's plate, so re-issue Show/Hide
  only when the target's combo count changes, and skip non-target plates once
  cleared (they start hidden) -- instead of hiding all five every tick on every
  plate. plate.cpShown tracks the shown count and stays in sync with the frames.
- player class color: merge the identical ENEMY_PLAYER / FRIENDLY_PLAYER
  branches into one condition.
2026-08-09 13:01:29 -05:00
Brues 97ef039d3a Fetch the totem buff icon via GetBuffDataByIndex
Use C_UnitAuras.GetBuffDataByIndex(guid, 1) instead of GetUnitAuras(guid)[1]:
a passive totem's provided buff is its single helpful aura, so the buff-
filtered single-slot fetch is both more precise and cheaper than building the
full aura list to take the first entry.
2026-08-09 03:39:11 -05:00
Brues 25ef02705c Remove dead totems and critters locale tables
Nameplate totem/critter detection now uses UnitCreatureTypeID instead of
name-matching, so the L["totems"] and L["critters"] tables have no remaining
readers. Drop them from every locale file.
2026-08-09 03:17:00 -05:00
Brues 48d1da2015 Localize hardcoded user-facing nameplate/bag/frame strings
Route the remaining hardcoded English labels through the T translation
table and register the keys in enUS:

- bags: "Sort Bags" / "Sort Bank" tooltips
- farmmode: "FARM MODE" overlay
- unitxp: "BEHIND" / "NO LOS" target indicators
- unitframes: raid group header "Group" (reuses the existing key)
- bgscore: "Battleground Frames" mover title
2026-08-09 03:15:01 -05:00
Brues ff29e9d3c2 Detect nameplate totems and critters by creature type
Replace the localized L["totems"] / L["critters"] name-substring matching
with ClassicAPI's UnitCreatureTypeID (CreatureType.dbc: 8 = Critter,
11 = Totem), cached per plate and reset on reuse. Locale-independent,
covers custom/Turtle units, rejects mobs merely named "...Totem...", and
cheaper than the per-plate name loop.

Totem icons now come straight from the game instead of a hand-picked table:
passive totems self-cast their provided buff, so their single aura's icon
is read via C_UnitAuras.GetUnitAuras; active totems (Searing/Magma/Fire Nova)
carry no self-aura, so their icon is captured from UNIT_SPELLCAST_SUCCEEDED
(C_Spell.GetSpellTexture) and cached. Detection and icons read through the
plate's ClassicAPI-provided GUID (cachedGuid).
2026-08-09 03:15:01 -05:00
Brues f0f1c80e24 autoshift: stub shapeshifts table for pfUI-turtle compatibility
Closes #38
2026-08-08 19:59:36 -05:00
Brues 5b4cb2bc9f Hide redundant Total line in item count tooltip and localize labels
Only show "Total" when the item is split across more than one location;
a single-location item made "Total" duplicate the one breakdown line
(e.g. "Equipped: 1 / Total: 1").

Route the Bags/Bank/Equipped/Total labels through the T translation table
and add the keys to every locale file, using the Blizzard GlobalStrings as
the reference for each localized term.
2026-08-08 19:24:42 -05:00
Brues 5a3a962c90 Remove dead unitframes showtooltip setting
The mouseover-scripts migration dropped the unit frame OnEnter/OnLeave
handlers that read C.unitframes[unit].showtooltip, so nothing consulted the
setting anymore. The engine mouseover (driven by the frame's unit attribute)
now shows the native tooltip unconditionally, so the option could not gate it
even if a reader remained.

Drop the config default, the "Enable Mouseover Tooltip" GUI checkbox, and the
now-orphaned locale string from all translation files.
2026-08-08 16:16:33 -05:00
Brues cd08db75d2 Color button highlights from PFUI_CLASS_COLORS
Read the player class color from PFUI_CLASS_COLORS instead of
GetClassColor in SkinButton, SetHighlight, and SkinDropDown.
GetClassColor returns the stock pink for Shaman, but pfUI remaps it to
blue, so the button highlights and locked borders now match.
2026-08-07 23:52:22 -05:00
Brues 6365f0cdb1 Read the innervate cooldown through ClassicAPI
Replace nampower's GetSpellIdCooldown with C_Spell.GetSpellCooldown, and
compute the remaining time from startTime plus duration (both seconds).
Drop the presence guard, since ClassicAPI is a hard dependency. The
module still needs nampower for the AURA_CAST events.
2026-08-07 18:29:37 -05:00
Brues faa801e27d Read spell range through ClassicAPI in the hunter bar
Replace nampower's IsSpellInRange with C_Spell.IsSpellInRange. This drops
the last unguarded nampower call. The ClassicAPI function returns true,
false, or nil, so test == true and == false and leave the bar unchanged
on nil.
2026-08-07 17:39:10 -05:00
Brues 421a103f22 Show action button spell tooltips by spell ID
libspell.GetSpellInfo now returns the spell ID at position 9 and caches
it with SafePack and unpack.

The action bar tracks self.spellID for macro-cast spells and shows the
tooltip with GameTooltip:SetSpellByID. Gather the slot, book type, and
spell ID from one GetSpellInfo call instead of a separate GetSpellIndex
lookup.
2026-08-06 23:08:32 -05:00
Brues ecb28fb194 Strip leading 'v' from version tags before parsing
Release tags often include a leading 'v' (e.g. "v9.0.18"). Previously the code split the raw tag directly which could yield a nil major version and fall back to 0.
2026-08-06 22:10:21 -05:00
Brues 94268b1162 Add option to always show equipment slot flyouts
The per-slot popout arrows previously appeared only while the equipment
manager sidecar was open. Add a "Always Show Equipment Slot Flyouts"
option under Character -> Inventory (character.inventory.equipflyout,
off by default) that instead ties them to the paperdoll, so gear can be
swapped without opening the equipment manager.

Centralize the show/hide in a single UpdatePopouts(): by default the
arrows follow the sidecar, with the option on they follow PaperDollFrame.
Both the sidecar OnShow/OnHide and new PaperDollFrame OnShow/OnHide hooks
route through it, and the flyout hides whenever the arrows go inactive.
2026-08-06 20:28:32 -05:00
Brues 1c7c91fdf7 Fix power bar rendering black behind its backdrop
The power bar's frame level was pinned to f.power's live level
(f.power:GetFrameLevel() + 1). CreateBackdrop caches the backdrop at
f.power's level when it first builds it, but f.power's level can shift
afterward as strata changes propagate across UpdateConfig re-runs. When
it shifts below the cached backdrop, the fill drops behind the dark
backdrop and the bar renders black -- which reproduced on some clients
but not others depending on how the levels resolved.

Anchor the fill to the backdrop's own level instead
(f.power.backdrop:GetFrameLevel() + 1). The backdrop's level is fixed
once created, so the fill is always exactly one level above it
regardless of f.power's value, and the bar can never fall behind it.
2026-08-06 19:16:49 -05:00
brues-code 7f5d18bc30 Update README to simplify project description 2026-08-06 13:29:49 -05:00
Brues 7efc3334ae Add an aura caster line to tooltips
Hook GameTooltip:SetUnitAura to append the caster's name; every pfUI aura
tooltip (player buffs, buffwatch, unitframes) routes through it, so one hook
covers them all. Resolve the name from the live sourceUnit token, falling
back to the sourceGUID name cache (players only) when the token is gone.

Gated behind a new tooltip.aurasource option (off by default) with a matching
"Show Aura Caster" checkbox. The toggle reloads the UI, so the hook is
installed conditionally at load rather than re-checking the flag per tooltip.
2026-08-06 02:51:08 -05:00
Brues f322fbd6c6 CancelItemTempEnchantment can't exist in vanilla without server change 2026-08-06 02:03:21 -05:00
brues-code 41b77a5728 Add the macro icon picker and improve the equipment manager (#35)
* Add pfUI-native macro icon picker

Replace Blizzard's MacroPopupFrame (the name + icon dialog) with a
custom pfUI picker driven by IconDataProviderMixin, so the full spell +
item + loose icon set is available instead of the stock spell-only list.
It has a searchable, filterable icon grid and saves through
C_Macro.CreateMacro / C_Macro.EditMacro, which take the icon as a texture
string -- so arbitrary icons (including index-less INV_* item icons)
persist. The macro-frame API is identical on the modern (Turtle/Octo)
and stock-vanilla macro UIs, so the picker works on both with no client
detection.

The new macroicons module takes over the New / Change-Icon buttons and
retires the stock popup; the blizzard macro skin now only skins
MacroPopupFrame when that module is disabled.

* Gate the macro icon hook behind a config flag

Run the Blizzard_MacroUI hook only when C.disabled["macroicons"] is
"1".

* Add search to the icon pickers and fix set editing

Equipment manager:
- Move the OK button next to Cancel at the bottom-right.
- Add an icon search box in the freed bottom-left space.
- Shift the popup contents up and shrink the window after the title
  was removed.
- Show the current icon when you edit a set. Keep a full icon path as
  is instead of adding a second prefix, and match grid icons by name.
- Close the name/icon popup when the manager frame closes. Remove the
  duplicate OnHide hook.

Both pickers now use Blizzard global strings for the labels and the
icon filters.

* Replace the row hover poll with OnLeave handlers

The gear button sits inside the set row's rectangle, so MouseIsOver(row)
is true for both. Show the gear on row enter. Hide it from a shared
OnLeave on the row and the gear when the cursor leaves the row. This
removes the per-frame OnUpdate poll.

* Handle missing C_Macro.CreateMacro API

Add guards to detect if C_Macro.CreateMacro is unavailable. The macroicons module now returns early if the API doesn't exist, and turtle-wow.lua uses the alternative Blizzard_MacroUI fallback path in such cases.

* Remove the macro picker title and shrink the window

Delete the title font string and its SetText calls. Move every
top-anchored element up 14px and shrink the window height from 498 to
484. The OK, Cancel, and search controls are bottom-anchored, so they
keep their spacing to the grid.

* bump ClassicAPI min version to 1.9.3

* Extract a shared icon picker widget

The macro icon picker and the equipment manager's name/icon popup carried
near-identical copies of the icon grid, All/Spells/Items filter, name search,
and the IconDataProvider state machine. Pull that into a single
pfUI.api.CreateIconPicker helper; each module keeps only its own frame shell,
buttons, and save flow.

Also fix the grid tooltip: pass white to GameTooltip:SetText (it defaults to
red) and derive the icon name with the case-insensitive basename key so
mixed-case provider paths show a clean name instead of the full path.
2026-08-05 22:33:37 -05:00
Brues 06fea6c889 Cache the player guild name for nameplate coloring
Compare each plate's guild name against a cached myGuild value instead
of calling UnitIsInMyGuild for every plate. Refresh the cache on
PLAYER_GUILD_UPDATE and PLAYER_ENTERING_WORLD. This replaces a per-plate
C call with a Lua string compare.
2026-08-05 21:43:08 -05:00
Brues 940a1adae0 Restore Clique support on unit frames
Fixes #33.

Clique's pfUI plugin replaces pfUI.uf.ClickAction and calls it from an
OnClick script. The move to secure attribute clicks removed that
function, so Clique stopped working.

Add the legacy Lua click path back for Clique. When Clique is loaded,
EnableScripts sets an OnClick script that runs ClickAction. When Clique
is not loaded, the frames keep the secure attribute path.

Skip the secure attributes in Clique mode. The type1 target attribute
switches the target before Clique can cast. Right-click opens the unit
menu through ClassicAPI_ToggleUnitMenu.
2026-08-05 21:43:08 -05:00
Brues d13710c5a4 Rebuild macro icon list from the icon data provider
Hook Blizzard_MacroUI and replace UpdateMacroIconFilenames. The new
function reads each icon from IconDataProviderMixin, strips the path
prefix, and adds the name to MACRO_ICON_FILENAMES. A seen table skips
duplicate names.
2026-08-05 03:02:43 -05:00
Brues c3dd7cb601 Refactor player info: simplify haste and SP display
Minor readability and style cleanup.
2026-08-05 00:28:55 -05:00
Brues 9190b88974 Cache player color codes and use full ARGB hex
Replace the cfgColorToHex function with a memoized table. The table
caches the color code for each config string on first use.

Build the code with C_ColorUtil.GenerateTextColorCode instead of
string.format. Change the spell-school colors and the format strings
to 8-character ARGB hex with the |c prefix.
2026-08-04 23:00:51 -05:00
Brues fe0ec82ede Route config color strings through GetStringColor cache
Replace raw strsplit(",", ...) color parsing across action bars, chat,
nameplates, third-party skins, player, and roll with the cached
GetStringColor / GetStringColorObject helpers, dropping the per-build
string-table allocations they created.
2026-08-04 22:27:43 -05:00
Brues 350b1d63ae Revert breaking change for WorldMapFrame 2026-08-04 21:29:03 -05:00
Brues c7f42491ef Update README.md 2026-08-04 16:28:08 -05:00
brues-code 6b458c9e27 Modernize cast bars, unit-frame clicks, and mark tracking with ClassicAPI (#32)
* Migrate player castbar to ClassicAPI UNIT_SPELLCAST_* events

Drive the player cast path off ClassicAPI's synthesized, player-only
UNIT_SPELLCAST_* events instead of the vanilla SPELLCAST_* plus nampower
SPELL_{START,GO,DELAYED}_SELF mix. START/CHANNEL_START poll UnitCastingInfo/
UnitChannelInfo and stamp; STOP/CHANNEL_STOP/FAILED/INTERRUPTED clear;
SUCCEEDED drives tradeskill craft counting; DELAYED/CHANNEL_UPDATE re-poll.
Since UNIT_SPELLCAST_START fires for chained same-spell recasts, the nampower
SELF deps and their RunNextFrame co-hook-ordering workarounds are gone.
Remote target/focus bars keep SPELL_*_OTHER (the new events are player-only).

Fix the cast-start flash: StampBar now primes the fill on the stamp frame,
and ClearBar no longer snaps the bar to full (that snap lingered in the fade
tail and flashed when the next cast stamped).

Add a red flash on a cancelled cast: new appearance.castbar.failcolor,
flashed by ClearBar only when a cast was actually in progress.

Handle pushback Quartz-style: DELAYED/CHANNEL_UPDATE re-poll just the times
and accumulate the endMs shift into this.delay for the +/- indicator (cast
+X, channel -X), rather than a full restamp.

* Route target/focus castbars through remote UNIT_SPELLCAST_*

ClassicAPI now fires UNIT_SPELLCAST_* for remote tokens (target/focus/...)
via PollRemote, so drop the nampower SPELL_*_OTHER path and drive all three
bars off one event model. The gate is now token-based (arg1 == this.unitstr,
plus the arg1=="player" + UnitIsUnit case for target=self); the RunNextFrame
defer is gone since the remote poll fires after UnitCastingInfo is readable.
Cast detection is now nampower-free across every bar.

Use the event's rank payload (arg5): thread it through RefreshBar into
StampBar, which now only calls C_Spell.GetSpellSubtext as a fallback on the
retarget re-poll (PLAYER_TARGET/FOCUS_CHANGED) where no event is in hand.

* Drive nameplate castbars off UNIT_SPELLCAST_*

ClassicAPI now fires UNIT_SPELLCAST_* for nameplate tokens, so populate the
per-GUID castState cache from UNIT_SPELLCAST_{START,CHANNEL_START} (poll
PollCastInfo for the timing the payload omits) and clear it on
{STOP,CHANNEL_STOP} -- the remote poll fires STOP for natural end, interrupt,
and cancel alike. Replaces the nampower SPELL_{START,FAILED}_OTHER path; the
^nameplate arg1 gate ignores the target/focus/party fires of the same events,
and the NAME_PLATE_UNIT_ADDED seed still catches a plate spawning mid-cast.
Nameplate cast detection is now nampower-free.

* We no longer use these features from SuperWoW/Nampower

* Use secure unit attributes; remove mouseover scripts

Switch unitframes to attribute-driven clicks and remove mouseover tooltip handlers. Adds SetAttribute("unit") in UpdateVisibility and sets frame attributes (unit and type1='target') when creating frames. Removes OnEnter/OnLeave functions and their SetScript registrations and eliminates direct TargetUnit calls in ClickAction

* Use SetShown and simplify component default

Replace explicit Show/Hide conditionals in api/unitframes.lua with SetShown(...) for ressIcon, leaderIcon, lootIcon, pvpIcon, and restIcon to reduce branching and improve readability. Also remove the local shadowing of the parameter 'component' by using assignment (component = component or ""). No intended behavior changes.

* Drive unit-frame clicks via secure attributes

Replace the Lua OnClick dispatch (OnClick/ClickAction/RightClickAction) with
secure frame attributes: default type1=target / type2=menu, and EnableClickCast
now writes type/spell/macrotext/menu/target/focus attributes per button+modifier
instead of caching a clickactions table read at click time. Drops the now-dead
clickactions table and buttons list.

Also set a "unit" attribute on each frame (at creation and re-synced in
UpdateVisibility to the live token, so a party shown on the raid grid reports
partyN, not raidN) so the hovered unit resolves from the frame.

Match the target/focus/menu click keywords exactly rather than by prefix, so a
spell whose name starts with "focus"/"target"/"menu" (e.g. Focus Magic) casts
instead of being swallowed as the keyword action.

* Simplify marktracking colors and refresh per mark

Replace the hand-rolled ParseColor plus its default-color table with
GetStringColor -- the raidmarkercolor_* config keys already carry those same
defaults, so the fallback was dead code.

Restructure the refresh off observed mark tokens: UNIT_HEALTH/UNIT_MAXHEALTH
now arrive as arg1 == "markN", so refresh just that one row (UpdateRow) instead
of rescanning all eight on every nearby unit's health tick. A visibility flip
(into range / death / hp crossing 0) re-packs the rows, so UpdateRow hands off
to a full UpdateDisplay; RAID_TARGET_UPDATE / PLAYER_ENTERING_WORLD stay full
refreshes, with the 1s poll as the range-change backstop.

* not true anymore

* Poll marktracking fallback via C_Timer instead of OnUpdate

The 1s range-change safety net ran a per-frame OnUpdate that no-oped ~59 of
every 60 frames. Replace it with C_Timer.NewTicker(FALLBACK_INTERVAL,
UpdateDisplay) -- one wakeup per second off the shared timer driver -- and drop
the elapsed accumulator. The scanner frame is now purely event-driven.

* SuperWoW is now optional

* Update README feature list

Add 'Mouseover Unit Frames' and 'Click-casting' to the main features list. Update the SuperWoW entry to reflect that it tracks party/raid units on the minimap (replacing the prior SetMouseoverUnit note).

* Replace fixed-interval OnUpdate polls with C_Timer/RunNextFrame

Swap hand-rolled per-frame throttles for the modern timer primitives:

- turtle-wow: one-shot next-frame defer (self-hiding OnUpdate frame) -> RunNextFrame
- panel: clock, combat, and fps widgets -> NewTicker(1); guild roster -> NewTicker(60)
- minimap: coordinates text -> NewTicker(0.1)
- addonbuttons: one-shot init -> RunNextFrame; 5s button rescan -> NewTicker(5),
  guarded by IsShown() to preserve the old "paused while hidden" behavior

Ticker callbacks reference frames via upvalue since 'this' is unbound outside
OnUpdate. Genuine per-frame work (bar fills, fades, drag) and polls already
coordinated through pfUI.throttle are left as-is.

* update pfQuest link

* Use SetShown/SetSize in panel module

Replace manual Show/Hide toggles with SetShown(not ... ) and replace SetWidth/SetHeight with SetSize in modules/panel.lua. Changes simplify toggle logic (timer, WorldMap, chat hide buttons) and unify sizing calls for timer, frames, textures, and microbutton. No behavior changes intended; purely refactor for conciseness and consistency.

* Bump ClassicAPI min version to 1.9.0

* Drive reagent counter from events instead of a polling OnUpdate

The pfReagentCounter frame ran an OnUpdate that (1) progressively rescanned
all 120 action slots one-per-100ms on any slot change and (2) recounted
reagent inventory on a 1s throttle. Replace both with direct event handling:

- ACTIONBAR_SLOT_CHANGED updates just the changed slot (arg1), full-scanning
  only when arg1 is 0/nil, instead of restarting a ~12s rescan on every edit
- BAG_UPDATE_DELAYED recounts tracked reagents directly (it is already
  Blizzard's coalesced bag event, so the extra 1s throttle was redundant)
- PLAYER_ENTERING_WORLD seeds the full reagent map once

UpdateSlot now seeds a new reagent's real count via GetItemCount so a freshly
placed reagent spell shows the correct number immediately. The updatecache ->
BarsUpdate render path and the IsReagentAction/GetReagentCount accessors are
unchanged.
2026-08-04 14:27:15 -05:00
Brues f338deebe7 UNITFRAME_SECURE_TEMPLATE is always nil in vanilla 2026-08-01 13:12:14 -05:00
Brues c994d00596 Toggle bagslots visibility via SetShown
Replace explicit if/else calling :Hide()/:Show() with :SetShown(not IsShown())
2026-07-31 13:22:17 -05:00
Brues 4be680183a Use GetSize/SetSize for size operations
Replace separate GetWidth/GetHeight and SetWidth/SetHeight calls with GetSize/SetSize for consistency and brevity. Updated modules: addonbuttons (store size via GetSize), chatcopy (use SetSize), easteregg (use SetSize for explosions), farmmode (use GetSize/SetSize when adjusting map size), and game_menu (use GetSize/SetSize when resizing frame).
2026-07-30 14:29:30 -05:00
Brues 2352f1c6ed Use GetSize/SetSize for map frame and buttons
Replace separate GetWidth/GetHeight and SetWidth/SetHeight calls with GetSize and SetSize in modules/map.lua.
2026-07-30 14:11:34 -05:00
Brues 305ff6c86e Collapse frameState.hasTarget into targetGuid
hasTarget was always snapshotted alongside targetGuid (UnitExists("target")
next to UnitGUID("target")), so it was just targetGuid ~= nil. Drop the
field and derive it from targetGuid at both read sites; remove the now-unused
UnitExists perf-cache local.
2026-07-30 13:45:53 -05:00
Brues a8b131898b Event-drive nameplate target state; drop per-tick poll and targetPlateGuid
frameState.hasTarget/targetGuid were polled via UnitExists("target") every
central-loop tick, while targetPlateGuid held the same guid but was already
event-driven -- redundant. Set frameState target fields in PLAYER_TARGET_CHANGED
(seeded on PLAYER_ENTERING_WORLD for a target held across reload), remove the
poll, and collapse targetPlateGuid into frameState.targetGuid (the castbar
frame now reads that). The central loop's only remaining per-tick poll is
GetTime().
2026-07-30 11:59:56 -05:00
Brues 1f9be33772 Use GetStringColorObject for buffbar colors; numeric border check
Store the buffbar color/bordercolor/textcolor as cached read-only ColorMixins
via GetStringColorObject instead of building per-bar {r,g,b,a} tables from
GetStringColor. These color tables are only ever read (SetStatusBarColor /
SetTextColor / the border check), so sharing the cached objects is safe and
drops the intermediate locals and per-bar allocations.

GetStringColorObject's components are numbers, so fix CreateBuffBarFrame's
border check from ~= "0" (string) to ~= 0.
2026-07-30 02:44:56 -05:00
Brues a798e67b7f Use GetStringColor for buffbar color parsing
Route the three buffbar color config splits through GetStringColor (cached)
instead of bare strsplit. GetStringColor returns strings, so this is
behavior-preserving -- including the bordercolor ~= "0" check in
CreateBuffBarFrame -- and just adds the shared color cache and consistency
with the rest of the codebase.
2026-07-30 02:39:56 -05:00
Brues 8b87e30266 Revert GetStringColor to strings; keep object numeric; tidy cmatch
- GetStringColor returns strings again (its lifelong contract). The earlier
  numeric conversion was a return-type change that could break any caller
  doing string comparisons on components (e.g. buffwatch's `~= "0"`); every
  caller was written against strings and color setters coerce, so reverting
  is the safe fix without a codebase-wide audit.
- GetStringColorObject now tonumbers its own inputs, so its ColorMixin stays
  numerically correct (GenerateHexColor/IsEqualTo) independent of the above.
- cmatch: move its a-e / va-ve / ra-re scratch out of module scope into clear
  function-locals (idx*/val*/out*). Strict 1:1 rename, logic unchanged; also
  drops the shared-upvalue reentrancy concern.
2026-07-30 02:39:16 -05:00
Brues f68b14e53b Use SetSize instead of SetWidth/SetHeight
Replaced numerous SetWidth/SetHeight calls with SetSize for consistency and brevity across UI code. Touched api/ui-widgets.lua, api/unitframes.lua and multiple modules (actionbar, addonbuttons, addons, afkcam, autovendor, bags, bgscore, buff, buffwatch, nameplates). Also simplified some sizing math in buff module. No functional behavior intended to change — code modernization only.
2026-07-30 02:27:03 -05:00
Brues 8ab6fab04f Event-drive nameplate mouseover via UPDATE_MOUSEOVER_UNIT
ClassicAPI polyfills UPDATE_MOUSEOVER_UNIT to fire on mouseover loss as well
as gain (src/unit/Mouseover.cpp), so the per-tick UnitGUID("mouseover") poll
in the central loop is no longer needed. Update frameState.mouseoverGuid on
the event and flag just the plates losing/gaining hover (via plateByGuid,
which holds overlays) for an immediate refresh.
2026-07-30 02:01:10 -05:00
Brues 6d1bfe805e Use UnitClassBase for class detection 2026-07-30 01:26:29 -05:00
Brues 838f7f5d25 guard against nil units
UPDATE_MOUSEOVER_UNIT can fire when unit is dropped now so guard against that
2026-07-30 01:20:50 -05:00
Brues fad078fa87 Drop dead GUID-label branch in unit frame OnEnter
No unit frame ever has a GUID label -- CreateUnitFrame is only ever called
with fixed type names (Player/Target/Focus/Party/Raid/...), and .label is only
ever assigned those. The string.find(this.label, "^0x") branch was a leftover
from an older focus implementation; focus now uses the real "focus" unit
token, so OnEnter always resolves the mouseover via the normal unitstr path.
2026-07-30 01:09:53 -05:00
Brues 48d76138ed Iterate active nameplates only; fix global eventcache propagation
- The central OnUpdate looped the entire plate pool (registry) every tick with
  an IsVisible guard. Maintain a visiblePlates set via NAME_PLATE_UNIT_ADDED/
  _REMOVED and iterate that instead, so hidden pool slots aren't touched. The
  IsVisible guard stays as a safety net.
- Fix the global refresh propagation: it set .eventcache on the base frame,
  but OnUpdate reads/clears it on the overlay (nameplate) -- so the propagation
  was a no-op and global refreshes (e.g. target-change alpha/strata) fell
  through to the 0.5s catch-all timer. Set plate.nameplate.eventcache and scope
  to visiblePlates, so those refreshes land on the next tick as intended.

OnConfigChange still iterates the full registry (hidden plates must pick up
config changes before they next show).
2026-07-29 23:43:27 -05:00
Brues fe22dfc456 Detect nameplate mouseover by GUID compare, not Blizzard glow texture
Both mouseover checks relied on original.glow:IsShown() (a fragile proxy for
the hovered plate, on a Blizzard texture pfUI hides/restyles) gated by
UnitExists("mouseover"). Cache the engine mouseover unit's GUID once per
central-loop tick (frameState.mouseoverGuid) and have each plate compare its
cachedGuid against it.

More correct for the data path: the "mouseover" unit token is only chosen
for the plate whose GUID actually matches the engine's mouseover unit, so
overlapping plates can't double-match and paint the wrong unit's data. Also
cheaper -- one UnitGUID("mouseover") per tick plus a per-plate table compare,
versus the old per-plate IsShown gated on a per-tick UnitExists.
2026-07-29 16:57:25 -05:00
Brues 5eaab2784f Resolve target castbar plate via cached GUID, not per-frame lookup
The unthrottled target castbar frame called C_NamePlate.GetNamePlateForUnit
every frame. Stash the target's GUID on PLAYER_TARGET_CHANGED (seeded on
PLAYER_ENTERING_WORLD for a target held across reload) and resolve the plate
through plateByGuid instead -- a table lookup plus a real idle skip when
there's no target. The plate is looked up per frame (not cached) so a plate
spawning/despawning while the unit stays targeted still resolves correctly.
2026-07-29 16:36:29 -05:00
Brues f41d5ac6d0 Make nameplate castbars event-driven; unthrottle target bar
Previously every visible plate polled C_Spell.UnitCastingInfo each throttled
tick just to detect casts. Now cast state is event-driven:

- SPELL_START_OTHER (nampower) stamps a per-GUID castState cache (spellId,
  timing, channel flag from spellType); SPELL_FAILED_OTHER clears it; normal
  completion expires at endTime. GetCastInfo just reads the cache, so all
  call sites (castbar update, non-target detection, casting name-color) stop
  polling.
- plateByGuid routes events to plates in O(1) and bounds the cache to on-screen
  casters; NAME_PLATE_UNIT_ADDED seeds an already-casting unit with one poll.
- The vestigial nameplate.castUpdate flag now fires on cast start to bypass the
  throttle for an immediate bar.

With the poll gone, per-tick work is a cache read + SetValue, so the dedicated
target castbar frame now runs unthrottled (every frame) for the smoothest
sweep, and the non-target nameplates_castbar default rises 50 -> 100 FPS.

Known limits: other-unit cast pushback isn't reported by nampower, and a
mob-cancelled channel with no fail event lingers until endTime.
2026-07-29 16:29:12 -05:00
Brues af8780bb41 Use GetStringColor for newitem glow color
Replace CreateColor/Color:GetRGBA usage with pfUI.api.GetStringColor in modules/newitem.lua
2026-07-29 14:39:25 -05:00
Brues ea37f41db1 Check r[3] instead of table.getn in rgbhex
Replace table.getn(r) >= 3 with r[3] ~= nil in api/api.lua
2026-07-29 14:35:44 -05:00
Brues 6f36da7aa1 Cache and streamline color helpers in api
- GetStringColor: memoize via a metatable __index cache (single lookup on
  hits) and store numeric components so ColorMixin comparisons/arithmetic
  behave, not just setter coercion.
- GetStringColorObject: new accessor returning a cached, shared read-only
  ColorMixin for callers that want an object instead of raw values.
- rgbhex: memoize the markup keyed on the byte values that actually determine
  the output (Round(x*255)), so continuously-varying inputs like health
  gradients collapse onto a bounded set instead of leaking a cache entry per
  shade. Build misses via C_ColorUtil.GenerateTextColorCode on a plain table
  instead of allocating a throwaway ColorMixin. Fix a latent bug where the
  r/g/b/a temporaries were file-scoped, so a malformed input returned the
  previous call's color instead of an empty string.
2026-07-29 14:06:25 -05:00
Brues 149d5dd362 Scope tooltip cursor-follow to when shown; default it to smooth
The cursor-follow OnUpdate polled GetCursorPosition() 10x/second forever,
even with no tooltip visible. Rework it so the follower frame is created
once, hidden, and only shown while a tooltip is up -- an OnUpdate fires only
while its frame is shown, so the poll now runs solely during tooltip display.
Position the follower immediately on show to avoid a one-frame flash.

Also bump the tooltip_cursor throttle default from custom/10 FPS to the
fastest preset (50 FPS) so cursor tracking is smooth out of the box while
the Throttling tooltip knob stays available for low-end machines.
2026-07-29 11:42:18 -05:00
Brues 0156d9dfec Harden strsplit against third-party global clobbering
BigWigs (SpellRequests) redefines the global string:split to return a table,
and another addon clobbers the strsplit global too. pfUI.api.strsplit and the
bare strsplit callers inherited the broken versions depending on load order,
producing 'attempt to compare number with nil' from GetStringColor.

- Make pfUI.api.strsplit fully self-contained (no delegation to global
  strsplit / string.split), so no override can reach it.
- Optimize the hot path: single-char delimiters use plain-text find (no
  pattern compilation, no per-call char-class string); localize string.find
  and string.sub.
- Route the per-frame castbar/nameplate color splits through GetStringColor,
  which caches, instead of re-splitting a constant string every update.
2026-07-29 10:37:29 -05:00
Brues 6b945c2c97 buff min classicapi version to 1.8.2 2026-07-28 19:26:09 -05:00
Brues 452eef3864 Drop custom debuff durations from turtle-wow.lua
C_UnitAuras supplies Turtle-adjusted durations directly to the aura readers,
so the L["debuffs"] database fallback for these four custom debuffs is dead.
2026-07-28 13:29:11 -05:00
Brues 6f7a57f530 Restore UnitDebuff/UnitOwnDebuff as C_UnitAuras adapters
Third-party addons (e.g. pfUI-WeakIcons) still expect libdebuff's legacy
multi-return reader signature. Reimplement UnitDebuff/UnitOwnDebuff as thin
adapters over C_UnitAuras that remap AuraData onto:
  effect, rank, texture, stacks, dtype, duration, timeleft, caster

No GetUnitField slot mapping or ownDebuffs/allAuraCasts bookkeeping involved;
C_UnitAuras already resolves source and expiration. timeleft is gated on
duration > 0 to avoid stale expirationTime on permanent auras.
2026-07-28 10:48:42 -05:00
Brues a55460e543 Add reverse sort direction and priority options to bag sorter
libbagsort:Sort now accepts an opts table:
  - reverse: place the first-ranked item into the last slot of the last
    bag (junk fills from the opposite end)
  - reversePrio: flip the category ranking (e.g. hearthstone sorts last)

Wired to two new checkboxes under Bags & Bank, both defaulting off.
2026-07-27 18:15:07 -05:00
Brues 58aaeef5f0 can't have any fun 2026-07-27 17:17:56 -05:00
Brues 487af0c8f4 Use string.split instead of strsplit
Some users have addons that pollute the global namespace with a version of strsplit that doesn't match Blizzard's spec
Closes #31
2026-07-27 15:47:28 -05:00
Brues 00292ca3b4 Focus/Nameplates now respond solely to UNIT_* events
commit 70b1e66c2d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sun Jul 26 18:30:18 2026 -0500

    Use SetSize/SetShown and simplify minimap/map

commit 7b6bfe9975
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 11:27:14 2026 -0500

    Include raidpet frames in /pftest test mode

    The unit-frame test toggle (showall) only previews frames that exist and
    are positioned. Raidpet frames are created when raidpet.visible == "1",
    but LayoutPets' collapse mode only positions pets whose raidpet<N> unit
    actually exists, so solo/in test mode they stayed hidden.

    Add a showall branch to LayoutPets that mirror-lays every pet cell and
    shows it (bypassing collapse and the roster gate), still guarded by the
    existing showpets check so nothing happens when raidpet is disabled. Call
    LayoutPets from the /pftest handler so the grid updates immediately on
    toggle-on and restores to the normal layout on toggle-off.

commit 4c65c38647
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Remove unused RangeCache local in UnitInRange

commit 6c96bbbe6c
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Use Clamp() for the two-sided clamps in ui-widgets

    Replace the hand-rolled math.min/math.max and if/elseif clamp idioms in the
    status bar and scroll frame with Clamp(). Equivalent for every value seen
    (min <= max always holds), just clearer.

commit 830e0a0be1
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:34:33 2026 -0500

    Drop vanilla GetItemInfo shim for C_Item.GetItemInfo

    The compat/vanilla.lua GetItemInfo override reshaped vanilla's tuple into
    retail order by inserting nil at slot 4 (itemLevel), but truncated at 8
    fields, dropping itemEquipLoc/itemTexture. ClassicAPI's global GetItemInfo
    keeps the vanilla shape (its hook only warms the item cache), so the shim
    stayed necessary but incomplete.

    Remove it and point the three callers at ClassicAPI's C_Item.GetItemInfo,
    which returns the full 18-field retail tuple. Positions 1-8 are identical
    to the old shim output, so bags/roll are unchanged; character.lua's
    itemSlot (equipLoc, field 9) was always nil under the truncating shim and
    now resolves correctly for ShaguScore.

commit c0da63657d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 10:09:34 2026 -0500

    Various cleanup

    Removes version compatibility checks for TBC/Vanilla, consolidating code to target a single WoW version. Refactors repetitive SetWidth/SetHeight calls to SetSize for cleaner code. Removes duplicate function definitions from unitxp module and simplifies conditional show/hide operations using SetShown.

commit 11a6302c2d
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 09:53:37 2026 -0500

    Delegate pfUI.api.strsplit to ClassicAPI's strsplit

    Replace the Lua pattern-based implementation with a thin wrapper around
    ClassicAPI's C-level strsplit. Keeps the pfUI.api.strsplit entry point for
    backwards compatibility with addons that call it, while dropping the
    redundant reimplementation.

    Behavioral note: the old version used ([^delim]+) which silently collapsed
    empty fields; delegating to real strsplit now preserves them
    ("a,,b" -> "a", "", "b"). All in-repo callers split numeric color tuples,
    version strings, or build name-keyed lookup tables, none of which are
    affected by empty-field preservation.

commit 67c126eac8
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 01:01:02 2026 -0500

    Bump ClassicAPI minimum version to 1.8.0

commit a6cf157518
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:49:50 2026 -0500

    read spell rank via C_Spell.GetSpellSubtext

    The rank string comes from the spell subtext ("Rank N"), which ClassicAPI's
    C_Spell.GetSpellSubtext returns directly -- so drop nampower's
    GetSpellRecField(spellId, "rank") here. The existing "Rank " gsub parse is
    unchanged.

commit 4b1ba99b4f
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:33:20 2026 -0500

    Move player info overlay onto ClassicAPI (drop Nampower)

    The haste/spell-power overlay read both values through Nampower and disabled
    itself entirely without it. Move both to ClassicAPI so it works on any
    ClassicAPI client:

    - Spell power: GetSpellPower("net") (nampower) -> GetSpellBonusDamage(i)
      (ClassicAPI, same per-school field). Merged the build+scan into one loop;
      the default school seeds the tiebreak so equal schools still favor it.
    - Haste: GetUnitField("player", "modCastSpeed") -> UnitSpellHaste("player"),
      which returns the haste percentage directly (the (1/modCastSpeed-1)*100
      conversion is now baked in, off the same UNIT_MOD_CAST_SPEED field, signed).
    - Dropped the "if not GetUnitField then return" gate -- UpdateInfoText no
      longer touches Nampower, so the overlay runs everywhere.

commit 7df4aa6d50
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Sat Jul 25 00:32:44 2026 -0500

    Hook the real global _G.UnitHealth for feign death

    Inside a RegisterModule body, `function UnitHealth(...)` defines UnitHealth on
    the pfUI environment, not the real global -- so the feign-death real-HP fix
    only reached callers that resolve UnitHealth through pfUI's env, and missed
    _G consumers (Blizzard frames, other addons). Hook _G.UnitHealth explicitly
    (and capture oldUnitHealth from _G) so the un-gate applies everywhere.

commit b0bf2fd869
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 21:10:58 2026 -0500

    Refactor nampower module

    Simplify reactive spell storage by using spell IDs instead of texture/name tables. Update to use modern C_Spell APIs (GetSpellTexture, GetSpellName) instead of manual texture paths. Consolidate SetWidth/SetHeight calls to SetSize and use print() instead of DEFAULT_CHAT_FRAME:AddMessage().

commit 0b06961333
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:54:23 2026 -0500

    Use GetNamePlateForUnit for target lookups; drop dead ScanGuid block

    - Replace the three GetNamePlateForGUID(UnitGUID("target")) round-trips with
      GetNamePlateForUnit("target"), which resolves the token to a GUID internally
      -- no UnitGUID string detour, and it returns nil for no-target/no-plate so
      the UnitExists guards collapse. GetNamePlateForGUID is left for raw-GUID cases.
    - Remove the dead libunitscan.ScanGuid nameplate block (ScanGuid was deleted
      from libunitscan long ago, so the guard was never true) -- it carried the
      last GetUnitField("npcFlags") read.

commit 3e6210086e
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:54:23 2026 -0500

    Drop Nampower stats system and polling from unit frames

    GetUnitStats now reads health/power straight from UnitHealth/UnitPower
    (the descriptor fields the server broadcasts) -- for a real unit token
    GetUnitField read nothing different, so the whole Nampower-vs-fallback
    apparatus was measuring a distinction that no longer exists. Removed:

    - The stats system: pfUI.uf.stats, pfUIStatsFrame + UpdateStatsDisplay, the
      lastUnitStats change-cache, the /pfuistats slash command, and every counter
      increment (event/heartbeat/earlyReturn/throttledSkip/nampower/fallback).
    - All GetUnitField health reads (GetUnitStats, heal-prediction, health-gradient
      color) -- collapsed to the UnitHealth/UnitHealthMax they already fell back to.
    - The heartbeat-polling backstop and its fallbackThrottle/lastEventUpdate deps.
      Frames now refresh on events only; eventless frames still use their own tick,
      and range/aggro still run in the eventless-actions block.

commit 63001b7b0c
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 20:09:42 2026 -0500

    Move nameplates onto ClassicAPI stable nameplate tokens

    ClassicAPI now assigns retail-exact, per-plate-stable "nameplateN" tokens and
    fires vanilla UNIT_* events for them, so the nameplate module can key off the
    token instead of Nampower/SuperWoW GUID primitives:

    - Events: UNIT_AURA_GUID/UNIT_FLAGS_GUID -> UNIT_AURA/UNIT_FLAGS, matched by
      the "nameplateN" token (guarded on the token prefix, since these also fire
      for target/party/raid). Registered unconditionally -- no GetUnitField gate.
    - Health: GetUnitField(guid, "health"/"maxHealth") -> UnitHealth/UnitHealthMax
      on the plate's cached token. Same UNIT_FIELD_HEALTH the server broadcasts
      (real HP on Turtle; the ~= 100 scaled-vs-real guard is unchanged).
    - Combat/target in GetCombatStateColor: GetUnitField("flags") + HasFlag ->
      UnitAffectingCombat(token); GetUnitField("target") + SuperWoW "<guid>target"
      -> the "nameplateNtarget" chain. Dropped the now-dead HasFlag,
      UNIT_FLAG_IN_COMBAT, and guidTargetTokenCache.
    - GetCastInfo now takes the token directly; every caller already holds it, so
      the UnitTokenFromGUID(guid) round-trip is gone (unused module-wide now).

    NAME_PLATE_UNIT_ADDED caches the token as plate.nameplate.unit alongside the
    GUID; REMOVED clears both. GUID is retained only as the stable cache key
    (debuffCache/threatMemory/combatColorCache). Only GetUnitField("npcFlags")
    remains -- it has no token/vanilla equivalent.

commit ce1c49fcbb
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Fri Jul 24 18:20:06 2026 -0500

    Make focus/focustarget event-driven via ClassicAPI unit events

    ClassicAPI now fires UNIT_* (health/mana/aura/...) with arg1 == "focus" and
    arg1 == "focustarget", observed per-unit like target/party/raid. Both frames
    already registered those events (focus/focustarget are in pfValidUnits) and
    their OnEvent already matches arg1 == label, so the 0.2s polling ticks were
    pure workarounds for the missing events. Drop both ticks; the frames now
    refresh on-event like target, with range/glow still on the shared 0.5s state
    pass and PLAYER_FOCUS_CHANGED still driving assign/clear.
2026-07-26 18:32:36 -05:00
Brues cba3604906 Use UnitGUID instead of UnitExists for GUID
Replace the previous extended UnitExists GUID retrieval with UnitGUID and simplify the Nampower health lookup flow. Also minor whitespace/formatting cleanup.
2026-07-24 17:06:12 -05:00
Brues a31d10384b Read unit power from ClassicAPI instead of Nampower's GetUnitField
GetUnitStats parsed the power type out of the bytes0 descriptor field and
read each power slot via GetUnitField(guid, "powerN")/"maxPowerN", manually
dividing rage by 10. ClassicAPI's UnitPower/UnitPowerMax read the same
descriptor slots and apply the engine's own power-divisor table (rage /10,
happiness scaling), so:

  powerType = UnitPowerType(unitstr) or 0
  power = UnitPower(unitstr, powerType)
  maxPower = UnitPowerMax(unitstr, powerType)

is equivalent and drops nine GetUnitField calls plus the bytes0 parsing.
Power now resolves through the hard-dep ClassicAPI even without Nampower;
GetUnitField in this path is left only for health, which has no ClassicAPI
real-HP equivalent.
2026-07-24 17:01:09 -05:00
Brues f06af48bc2 nampower: Use SetSize, UnitClassBase and simplify icon logic
Replace SetWidth/SetHeight with SetSize for pfUI.spellqueue and reactive icons. Use UnitClassBase("player") to obtain the player's class token. Simplify reactive icon visibility by using SetShown and aggregating a single anyVisible flag, then calling SetShown on the parent frame. Minor readability and API modernization changes.
2026-07-24 16:49:35 -05:00
Brues d73c4de695 Modernize power-API usage onto ClassicAPI
- Replace all UnitMana/UnitManaMax calls with UnitPower/UnitPowerMax. The
  no-arg form returns the unit's primary power from the same field vanilla's
  UnitMana read, so these are behavior-preserving. Drops two dead
  UnitMana/UnitManaMax local caches in nameplates.lua.
- Replace magic power-type numbers (0/1/2/3) with Enum.PowerType.Mana/Rage/
  Focus/Energy in the GetUnitStats branches, the power-bar color block, the
  druid mana bar, GetStatusValue's powerdyn, and energytick's mode checks.
2026-07-24 16:37:34 -05:00
Brues dd8c529463 Move druid mana bar into the unit frame, off nampower
The druid secondary mana bar (shown while shapeshifted into a form that
uses energy/rage) lived in nampower.lua and read base mana through
nampower's GetUnitField. Extract it into the unit frame proper and drive
it with ClassicAPI instead:

- Create pfDruidMana_<unit> as f.druidmana in CreateUnitFrame (player and
  target), lay it out in UpdateConfig from the existing C.unitframes.druidmana*
  keys, and update it in a new pfUI.uf:UpdateDruidMana driven by the frame's
  own base-refresh pass (UNIT_MANA / UNIT_DISPLAYPOWER). No separate event
  frames, no nampower dependency.
- Read mana via UnitPower(unit, 0) / UnitPowerMax(unit, 0), the ClassicAPI
  slot getters that return the mana pool regardless of the active power, so
  it works while in Cat/Bear form.
- Add a "Show Druid Mana Bar Text" toggle (druidmanatext) so the current/max
  readout can be hidden while keeping the bar; config default, GUI checkbox,
  and locale stubs.
- Remove the now-dead block from nampower.lua.
2026-07-24 16:23:28 -05:00
Brues 47a7b4c686 Simplify totems frame sizing
Replace separate SetWidth/SetHeight calls with a single SetSize using precomputed 'thickness' and 'length' values. This refactors the totems layout math into clearer variables (thickness = iconsize + spacing*2, length = thickness * count) for horizontal and vertical directions, improving readability and maintainability without changing behavior.
2026-07-24 16:08:36 -05:00
Brues cf3f1e5440 Rework raid self/group frame visibility and rename the solo option
- selfinraid now gates on `not IsInGroup()`, so "show self in raid frames"
  applies only when truly solo (both party and raid suppress it), matching
  the option's actual behavior.
- Hide the redundant group frames when a party is promoted to the raid grid
  (raidforgroup + hide_in_raid), not just in an actual raid. A shared
  hide_group local drives both the party-member and self branches; the
  party-member branch is scoped to cache_raid == 0 so the raidforgroup-mapped
  raid frames (which themselves carry label "party") aren't hidden too.
- Rename "Always Show Self In Raid Frames" to "Show Self In Raid Frames When
  Solo" in gui.lua and all locale files; the four previously-translated
  strings are reset to nil stubs since the meaning changed.
2026-07-24 15:02:38 -05:00
Brues 182127bd67 Refactor totems to use CreateColor API
Replace manual color tables with CreateColor() function calls for better code consistency and API usage. Update tooltip color handling to use WHITE_FONT_COLOR:GetRGB() instead of hardcoded hex color codes. Rename 'slots' variable to 'slotColors' for clarity.
2026-07-24 15:00:16 -05:00
Brues 3d2e6e202b corrected rangecheck vanilla label 2026-07-24 14:14:46 -05:00
Brues 3a062ee2ac Recast Totem will now use the same rank totem 2026-07-24 10:00:22 -05:00
Brues 5ed1d98ecc Raid Pets and Optimized Chat Bubble Styling
commit f19d7402810637fc32460864104cb792ac5af863
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:05:52 2026 -0500

    remove comment

commit 60f4968f06d19d42bdc6347f98ff4d5a34785e97
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:05:06 2026 -0500

    Bump ClassicAPI minimum version to 10705

    Update the minimum required ClassicAPI version from 10704 (1.7.4) to 10705 (1.7.5).

commit 088dba4c23f4aa7ce98b9ce9d75bc5892cd40520
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Wed Jul 22 01:04:04 2026 -0500

    Add raid-pet frames: an independent, roster-driven pet grid

    New "raidpet" unitframe type that shows raid members' pets (raidpet1..40)
    in their own movable block (pfRaidPetCluster), off by default. It's a
    flat pool of frames laid out by pfUI.uf.raid:LayoutPets straight from the
    raid roster -- cell N shows raidpet<N> -- so it's fully decoupled from how
    the raid grid arranges its own slots.

    Layout is independent of the raid grid: raidpet carries its own
    width/height plus a Layout section (raidlayout / raidpadding / raidfill),
    and its own Collapse Empty Slots toggle that packs only the pets that
    exist into the leading cells. The raid grid gets the same collapse option
    (sequential slot assignment in AddUnitToGroup instead of by subgroup).
    Collapsed pets re-pack on roster changes and on UNIT_PET so summons and
    dismisses track live without polling.

    Also:
    - unitframes: a "raidpet" branch in UpdateVisibility (hide when the pet is
      out of range or its raid<N> owner is gone), and fix cache_raid so the
      "pfRaid" prefix check doesn't misread pfRaidPet<n> frames (char 7 is
      non-numeric -> nil compare crash).
    - New "Owner Name" text option: on any pet frame (raidpet/partypet/pet) it
      shows the owner's class-colored name so you can tell whose pet it is.
    - unlock: a pfRaidPet drag cluster, a numeric-suffix guard so pfRaid no
      longer matches (and crashes on) pet frames, and RaidPet config mappings.
    - config/gui/translations for all of the above.

commit 52f02c8963fe7ec90f36100ebe069c7807529301
Author: Brues <5278969+brues-code@users.noreply.github.com>
Date:   Mon Jul 20 23:09:06 2026 -0500

    Enumerate chat bubbles via ClassicAPI instead of scanning WorldFrame

    ClassicAPI's C_ChatBubbles.GetAllChatBubbles() walks the engine's own
    bubble list and returns the exact set of live bubble frames, with real
    GetRegions(), so the decoration idiom works unchanged. Replace the
    WorldFrame:GetChildren() sweep and drop the IsBubble heuristic (unnamed
    frame whose first region is the ChatBubble-Background texture) -- the API
    only ever hands back bubbles, so that guess is both redundant and more
    fragile than the engine list. Cheaper too: it iterates only live bubbles
    rather than every world child on each chat event.
2026-07-23 23:08:05 -05:00
169 changed files with 22101 additions and 20956 deletions
+3 -3
View File
@@ -23,12 +23,12 @@ jobs:
IFS=. read -r MAJOR MINOR PATCH <<<"$LATEST" IFS=. read -r MAJOR MINOR PATCH <<<"$LATEST"
PACKED=$((MAJOR * 10000 + MINOR * 100 + PATCH)) PACKED=$((MAJOR * 10000 + MINOR * 100 + PATCH))
echo "Pinning PFUI_CLASSIC_API_LATEST to $LATEST ($PACKED)" echo "Pinning PFUI_CLASSIC_API_LATEST to $LATEST ($PACKED)"
sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST = .*/\1local PFUI_CLASSIC_API_LATEST = $PACKED/" pfUI.lua sed -i "s/^\([[:space:]]*\)local PFUI_CLASSIC_API_LATEST = .*/\1local PFUI_CLASSIC_API_LATEST = $PACKED/" API_Check.lua
grep 'local PFUI_CLASSIC_API_' pfUI.lua grep 'local PFUI_CLASSIC_API_' API_Check.lua
env: env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Package and release to GitHub - name: Package and release to GitHub
uses: BigWigsMods/packager@v2 uses: brues-code/packager@vCAPI
env: env:
GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }} GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}
+22
View File
@@ -0,0 +1,22 @@
{
"runtime": {
"version": "Lua 5.1"
},
"diagnostics": {
"disable": ["deprecated"],
"globals": [
"this",
"event",
"arg",
"arg1",
"arg2",
"arg3",
"arg4",
"arg5",
"arg6",
"arg7",
"arg8",
"arg9"
]
}
}
+4
View File
@@ -0,0 +1,4 @@
package-as: pfUI
ignore:
- .luarc.json
+78
View File
@@ -0,0 +1,78 @@
do
-- ClassicAPI dependency gate.
--
-- Which TOC the client opened already answers "is ClassicAPI here?". Whenever
-- the DLL is loaded it redirects the read of `pfUI\pfUI.toc` to
-- `pfUI_Turtle.toc` (Turtle clients) or `pfUI_ClassicAPI.toc` (everything
-- else). Reaching this file from the plain `pfUI.toc` therefore means
-- ClassicAPI is absent -- and that TOC deliberately loads nothing but this
-- file, so there is nothing to disable, only a notice to show.
--
-- The flavor TOCs still need a version gate of their own: the redirect has
-- existed since ClassicAPI v1.11.0, well below the API surface pfUI relies
-- on. There pfUI does load, and will throw wherever it reaches for something
-- the installed DLL doesn't have yet -- the popup names the cause so those
-- errors aren't a mystery.
local PFUI_CLASSIC_API_MIN = 11813 -- (X*10000 + Y*100 + Z)
local PFUI_CLASSIC_API_LATEST = PFUI_CLASSIC_API_MIN
local PFUI_CLASSIC_API_WEBSITE = "https://github.com/brues-code/ClassicAPI"
local PFUI_CLASSIC_API_LATEST_URL = PFUI_CLASSIC_API_WEBSITE .. "/releases/latest"
local function FormatVersion(packed)
local x = math.floor(packed / 10000)
local y = math.floor(math.mod(packed, 10000) / 100)
local z = math.mod(packed, 100)
return string.format("v%d.%d.%d", x, y, z)
end
local headline, detail
if not CLASSIC_API_VERSION then
headline = "|cff33ffccpf|cffffffffUI|r has been disabled."
detail = "The ClassicAPI DLL isn't loaded. Download the latest release from:"
elseif CLASSIC_API_VERSION < PFUI_CLASSIC_API_MIN then
headline = "|cff33ffccpf|cffffffffUI|r will not work correctly on ClassicAPI " .. FormatVersion(CLASSIC_API_VERSION) .. "."
detail = FormatVersion(PFUI_CLASSIC_API_MIN) .. " or newer is required -- any errors alongside this one are the APIs it is missing. Download the latest release from:"
end
if detail then
local function ShowRequiredPopup()
StaticPopupDialogs["PFUI_CLASSICAPI_REQUIRED"] = {
text = headline .. "\n\n" .. detail,
button1 = OKAY,
hasEditBox = 1,
editBoxWidth = 280,
timeout = 0,
whileDead = 1,
hideOnEscape = 1,
preferredIndex = 3,
OnShow = function()
local editBox = getglobal(this:GetName().."EditBox")
if editBox then
editBox:SetText(PFUI_CLASSIC_API_LATEST_URL)
editBox:HighlightText()
editBox:SetFocus()
end
end,
}
StaticPopup_Show("PFUI_CLASSICAPI_REQUIRED")
DEFAULT_CHAT_FRAME:AddMessage(
headline .. " " .. detail .. " " .. PFUI_CLASSIC_API_LATEST_URL,
1, 0.3, 0.3
)
end
local loginFrame = CreateFrame("Frame")
loginFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
loginFrame:SetScript("OnEvent", function()
loginFrame:UnregisterEvent("PLAYER_ENTERING_WORLD")
ShowRequiredPopup()
end)
elseif CLASSIC_API_VERSION < PFUI_CLASSIC_API_LATEST then
EventUtil.ContinueOnPlayerLogin(function()
C_Timer.After(8, function()
DEFAULT_CHAT_FRAME:AddMessage(
"|cff33ffccpf|rUI: ClassicAPI " .. FormatVersion(PFUI_CLASSIC_API_LATEST) .. " is available — " .. PFUI_CLASSIC_API_LATEST_URL,
1, 0.85, 0.3
)
end)
end)
end
end
+18 -17
View File
@@ -1,12 +1,9 @@
# pfUI - ClassicAPI Edition # pfUI - ClassicAPI Edition
[![Octo WoW](https://img.shields.io/badge/Octo%20WoW-1.18.1-brightgreen.svg)](https://octowow.st/)
[![ClassicAPI](https://img.shields.io/badge/ClassicAPI-Required-purple.svg)](https://github.com/brues-code/ClassicAPI) [![ClassicAPI](https://img.shields.io/badge/ClassicAPI-Required-purple.svg)](https://github.com/brues-code/ClassicAPI)
[![SuperWoW](https://img.shields.io/badge/SuperWoW-Required-purple.svg)](https://github.com/balakethelock/SuperWoW)
[![Nampower](https://img.shields.io/badge/Nampower-Required-purple.svg)](https://github.com/brues-code/nampower) [![Nampower](https://img.shields.io/badge/Nampower-Required-purple.svg)](https://github.com/brues-code/nampower)
[![UnitXP](https://img.shields.io/badge/UnitXP__SP3-Optional-yellow.svg)](https://codeberg.org/konaka/UnitXP_SP3) [![SuperWoW](https://img.shields.io/badge/SuperWoW-Optional-yellow.svg)](https://github.com/balakethelock/SuperWoW)
[![UnitXP](https://img.shields.io/badge/UnitXP__SP3-Optional-yellow.svg)](https://github.com/brues-code/UnitXP_SP3)
**A pfUI fork specifically optimized for ClassicAPI on [Octo WoW](https://octowow.st/) which requires Nampower and SuperWoW with optional UnitXP_SP3 DLL integration.**
This version includes significant performance improvements and DLL-enhanced features. This version includes significant performance improvements and DLL-enhanced features.
@@ -16,9 +13,9 @@ This version includes significant performance improvements and DLL-enhanced feat
4. Copy "pfUI" into Wow-Directory\Interface\AddOns 4. Copy "pfUI" into Wow-Directory\Interface\AddOns
5. Restart Wow 5. Restart Wow
## Optional DLL Enhancements ## DLL Enhancements
Since pfUI 6.0.0 includes integrations with client-side DLLs for enhanced functionality. These DLLs are permitted on Octo WoW: Since pfUI 6.0.0 includes integrations with client-side DLLs for enhanced functionality:
### [ClassicAPI](https://github.com/brues-code/ClassicAPI) ### [ClassicAPI](https://github.com/brues-code/ClassicAPI)
@@ -36,23 +33,26 @@ Provides:
- Faster, safer profile sharing - Engine-side serialize/compress/base64 via C_EncodingUtil - Faster, safer profile sharing - Engine-side serialize/compress/base64 via C_EncodingUtil
- C_Timer - After / NewTicker replacing hand-rolled OnUpdate throttles - C_Timer - After / NewTicker replacing hand-rolled OnUpdate throttles
- Feign death, shapeshift and quest-item detection via real API calls - Feign death, shapeshift and quest-item detection via real API calls
- Mouseover Unit Frames
- Click-casting
- Loot Roll History (/loothistory)
- New item highlighting
- Loss of control alert - Stuns, fears, silences and school lockouts from C_LossOfControl
- Dressing room zoom, pan and per-slot undress (PlayerModel / DressUpModel methods)
- Plenty other functions - Plenty other functions
### [SuperWoW](https://github.com/balakethelock/SuperWoW)
Provides:
- UnitPosition for distance calculations
- SetMouseoverUnit for improved targeting
### [Nampower](https://github.com/brues-code/nampower) ### [Nampower](https://github.com/brues-code/nampower)
Provides: Provides:
- Spell queue indicator - Spell queue indicator
- GCD indicator - GCD indicator
- Reactive spell detection
- Enhanced cast information
### [UnitXP_SP3](https://codeberg.org/konaka/UnitXP_SP3) ### [SuperWoW](https://github.com/balakethelock/SuperWoW)
Provides:
- Tracks party/raid units on the minimap
### [UnitXP_SP3](https://github.com/brues-code/UnitXP_SP3)
Provides: Provides:
- Line of Sight detection - Line of Sight detection
@@ -79,6 +79,7 @@ Use `/pfdll` in-game to check which DLLs are detected.
/swapfocus Toggle Focus and Target-Frame /swapfocus Toggle Focus and Target-Frame
/pftest Toggle pfUI Unitframe Test Mode /pftest Toggle pfUI Unitframe Test Mode
/abp Addon Button Panel /abp Addon Button Panel
/loothistory Show Loot Roll History
## Languages ## Languages
pfUI supports and contains language specific code for the following gameclients. pfUI supports and contains language specific code for the following gameclients.
@@ -91,7 +92,7 @@ pfUI supports and contains language specific code for the following gameclients.
* Russian (ruRU) * Russian (ruRU)
## Recommended Addons ## Recommended Addons
* [pfQuest](https://shagu.org/pfQuest) A simple database and quest helper * [pfQuest](https://github.com/brues-code/pfQuest) A simple database and quest helper
* [SuperCleveRoidMacros](https://github.com/brues-code/SuperCleveRoidMacros) Supports modern macro formats * [SuperCleveRoidMacros](https://github.com/brues-code/SuperCleveRoidMacros) Supports modern macro formats
## Plugins ## Plugins
+271 -368
View File
@@ -1,5 +1,3 @@
pfUI.api = { }
-- load pfUI environment -- load pfUI environment
setfenv(1, pfUI:GetEnvironment()) setfenv(1, pfUI:GetEnvironment())
@@ -59,21 +57,15 @@ function pfUI.api.GetUnitDistance(unit1, unit2)
return nil return nil
end end
-- [ UnitInLineOfSight ]
-- Returns true if unit1 has line of sight to unit2
-- Requires UnitXP_SP3
function pfUI.api.UnitInLineOfSight(unit1, unit2)
if not pfUI.api.HasUnitXP() then return nil end
local success, inSight = pcall(UnitXP, "inSight", unit1, unit2)
if success then return inSight end
return nil
end
-- [ UnitIsBehind ] -- [ UnitIsBehind ]
-- Returns true if unit1 is behind unit2 -- Returns true if unit1 is behind unit2
-- Requires UnitXP_SP3 -- Requires UnitXP_SP3
function pfUI.api.UnitIsBehind(unit1, unit2) function pfUI.api.UnitIsBehind(unit1, unit2)
if not pfUI.api.HasUnitXP() then return nil end if not pfUI.api.HasUnitXP() then return nil end
if not unit2 then
unit2 = unit1
unit1 = "player"
end
local success, behind = pcall(UnitXP, "behind", unit1, unit2) local success, behind = pcall(UnitXP, "behind", unit1, unit2)
if success then return behind end if success then return behind end
return nil return nil
@@ -84,26 +76,11 @@ gfind = string.gmatch or string.gfind
mod = math.mod or mod mod = math.mod or mod
-- [ strsplit ] -- [ strsplit ]
-- Splits a string using a delimiter. -- ClassicAPI's strsplit, taken from the ClassicAPI table, which no addon can
-- 'delimiter' [string] characters that will be interpreted as delimiter -- overwrite. Third-party addons replace the global strsplit / string.split
-- characters (bytes) in the string. -- (e.g. BigWigs' SpellRequests makes string:split return a table), and bare
-- 'subject' [string] String to split. -- strsplit calls inside the pfUI environment resolve to this copy.
-- return: [list] a list of strings. pfUI.api.strsplit = ClassicAPI.strsplit
function pfUI.api.strsplit(delimiter, subject)
if not subject then return nil end
local delimiter, fields = delimiter or ":", {}
local pattern = string.format("([^%s]+)", delimiter)
string.gsub(subject, pattern, function(c) fields[table.getn(fields)+1] = c end)
return unpack(fields)
end
-- [ isempty ]
-- Returns true if a table is empty or not existing, otherwise false.
-- 'tbl' [table] the table that shall be checked
-- return: [boolean] result of the check.
function pfUI.api.isempty(tbl)
return next(tbl or {}) == nil
end
-- [ checkversion ] -- [ checkversion ]
-- Compares a given version (major,minor,fix) and compares it to the current -- Compares a given version (major,minor,fix) and compares it to the current
@@ -127,11 +104,9 @@ function pfUI.api.checkversion(chkmajor, chkminor, chkfix)
end end
-- [ UnitInRange ] -- [ UnitInRange ]
-- Returns whether a party/raid member is nearby. -- Returns whether a party/raid member is nearby, by the configured range check.
-- It takes care of the rangecheck module if existing.
-- unit [string] A unit to query (string, unitID) -- unit [string] A unit to query (string, unitID)
-- return: [bool] "1" if in range otherwise "nil" -- return: [bool] "1" if in range otherwise "nil"
local RangeCache = {}
function pfUI.api.UnitInRange(unit) function pfUI.api.UnitInRange(unit)
if not UnitExists(unit) or not UnitIsVisible(unit) then if not UnitExists(unit) or not UnitIsVisible(unit) then
return nil return nil
@@ -144,40 +119,21 @@ function pfUI.api.UnitInRange(unit)
-- returned nil above, matching the pre-collapse behavior. -- returned nil above, matching the pre-collapse behavior.
if C.unitframes.rangecheck == "0" then return 1 end if C.unitframes.rangecheck == "0" then return 1 end
-- UnitXP precise mode: skip librange entirely, use direct distance check -- UnitXP precise mode: direct distance check against the configured range
if C.unitframes.rangecheck_mode == "unitxp" and _G.UnitXP then if C.unitframes.rangecheck_mode == "unitxp" and _G.UnitXP then
local threshold = tonumber(C.unitframes.rangecheck_distance) or 40 local threshold = tonumber(C.unitframes.rangecheck_distance) or 40
local success, distance = pcall(_G.UnitXP, "distanceBetween", "player", unit) local success, distance = pcall(_G.UnitXP, "distanceBetween", "player", unit)
if success and distance then if success and distance then
return distance <= threshold and 1 or nil return distance <= threshold and 1 or nil
end end
-- fallthrough to librange if UnitXP fails -- fallthrough to the 40y check if UnitXP fails
end end
if pfUI.api.librange then -- ClassicAPI's 40y check, _G-qualified since the bare name is this function
return pfUI.api.librange:UnitInSpellRange(unit) -- inside the pfUI environment. A unit it can't place (outside the client's
end -- sync range) counts as in range.
return nil local inRange, checked = _G.UnitInRange(unit)
end return (inRange or not checked) and 1 or nil
-- [ RunOOC ]
-- Runs a function once, as soon as the combat lockdown fades.
-- func [function] The function that shall run ooc.
-- return: [bool] true if the function was added,
-- nil if the function already exists in queue
local queue, frame = {}
function pfUI.api.RunOOC(func)
if not frame then
frame = CreateFrame("Frame")
frame:SetScript("OnUpdate", function()
for key, func in pairs(queue) do func(); queue[key] = nil end
end)
end
if not queue[tostring(func)] then
queue[tostring(func)] = func
return true
end
end end
-- [ UnitHasBuff ] -- [ UnitHasBuff ]
@@ -189,6 +145,32 @@ function pfUI.api.UnitHasBuff(unit, name)
return C_UnitAuras.GetAuraDataBySpellName(unit, name, "HELPFUL") ~= nil or nil return C_UnitAuras.GetAuraDataBySpellName(unit, name, "HELPFUL") ~= nil or nil
end end
-- [ ScanAuraSlots ]
-- Fills `buf` with the slot ids of the auras on `unit` that match `filter` and
-- returns how many (buf[1..n]; entries past n are cleared), so a module can
-- keep one buffer and refill it every refresh. Read each aura with
-- C_UnitAuras.UnitAuraBySlot(unit, buf[i]) (positional, no table) or
-- GetAuraDataBySlot. One enumeration walks the aura array once, where a
-- by-index loop (UnitAura(unit, i)) re-walks it from the start for every i.
-- Uses GetAuraSlots' fill-a-table form (table as the 5th argument) instead of
-- its vararg return: Lua 5.0 builds an `arg` table for every vararg call, so
-- collecting the returns in a Lua helper would allocate once per scan.
-- unit [string] unit token
-- filter [string] aura filter ("HELPFUL", "HARMFUL|PLAYER", ...)
-- buf [table] reusable buffer, filled in place
-- max [number] optional cap on the slot count (nil = all)
-- return: [number] count of slot ids written to buf
function pfUI.api.ScanAuraSlots(unit, filter, buf, max)
local _, n = C_UnitAuras.GetAuraSlots(unit, filter, max, nil, buf)
return n
end
-- [ IsPlayerGuid ]
-- Returns whether a GUID or unit token refers to the local player.
-- guid [string] A unit GUID (or unitID) to test.
-- return: [bool] true if it is the player otherwise "false"
pfUI.api.IsPlayerGuid = _G.IsPlayerGuid
-- [ GetUnbuffedRoster ] -- [ GetUnbuffedRoster ]
-- Returns a comma-joined, colored list of group members missing the named aura. -- Returns a comma-joined, colored list of group members missing the named aura.
-- name [string] the localized aura name to check for -- name [string] the localized aura name to check for
@@ -216,11 +198,42 @@ end
-- unit [string] the unitstring -- unit [string] the unitstring
-- return: [table] string, r, g, b -- return: [table] string, r, g, b
function pfUI.api.GetUnitColor(unitstr) function pfUI.api.GetUnitColor(unitstr)
local _, class = UnitClass(unitstr) local class = UnitClassBase(unitstr)
local classColor = PFUI_CLASS_COLORS[class] local classColor = PFUI_CLASS_COLORS[class]
return classColor:GenerateHexColorMarkup(), classColor:GetRGB() return classColor:GenerateHexColorMarkup(), classColor:GetRGB()
end end
-- [ GetRaceIcon ]
-- Builds an inline race icon texture from the shared races atlas.
-- 'raceKey' [string] englishRace key (e.g. "NightElf")
-- 'sex' [int] unit sex (3 = female)
-- return: [string] inline texture escape, or an empty string
function pfUI.api.GetRaceIcon(raceKey, sex)
if not raceKey then return "" end
local gender = sex == 3 and "FEMALE" or "MALE"
local coords = RACE_ICON_TCOORDS[strupper(raceKey) .. "_" .. gender]
if not coords then return "" end
return string.format(
"|TInterface\\Glues\\CharacterCreate\\UI-CharacterCreate-Races:0:0:0:0:512:512:%d:%d:%d:%d|t",
coords[1] * 512, coords[2] * 512, coords[3] * 512, coords[4] * 512)
end
-- inline faction emblems (cropped from the target-frame PvP banners)
local FACTION_ICON = {
Alliance = "|TInterface\\TargetingFrame\\UI-PVP-Alliance:0:0:0:0:64:64:5:37:3:35|t",
Horde = "|TInterface\\TargetingFrame\\UI-PVP-Horde:0:0:0:0:64:64:5:37:3:35|t",
}
-- [ GetFactionIcon ]
-- Resolves an inline faction emblem from the englishRace key stored in L["race"].
-- 'raceKey' [string] englishRace key (e.g. "Orc")
-- return: [string] inline texture escape, or an empty string
function pfUI.api.GetFactionIcon(raceKey)
local info = raceKey and L["race"][raceKey]
if not info then return "" end
return FACTION_ICON[info.faction] or ""
end
-- [ strvertical ] -- [ strvertical ]
-- Creates vertical text using linebreaks. Multibyte char friendly. -- Creates vertical text using linebreaks. Multibyte char friendly.
-- 'str' [string] String to columnize. -- 'str' [string] String to columnize.
@@ -248,28 +261,6 @@ function pfUI.api.round(input, places)
end end
end end
-- [ clamp ]
-- Clamps a number between given range.
-- 'x' [number] the number that should be clamped.
-- 'min' [number] minimum value.
-- 'max' [number] maximum value.
-- returns: [number] clamped value: 'x', 'min' or 'max' value itself.
function pfUI.api.clamp(x, min, max)
if type(x) == "number" and type(min) == "number" and type(max) == "number" then
return x < min and min or x > max and max or x
else
return x
end
end
-- [ modf ]
-- Returns integral and fractional part of a number.
-- 'f' [float] the number to breakdown.
-- returns: [int],[float] whole and fractional part.
function pfUI.api.modf(f)
return math.modf(f)
end
-- [ GetServerEpoch ] -- [ GetServerEpoch ]
-- Returns a Unix epoch (seconds) representing the current server wall -- Returns a Unix epoch (seconds) representing the current server wall
-- clock, packed in the player's local timezone so that date(fmt, epoch) -- clock, packed in the player's local timezone so that date(fmt, epoch)
@@ -362,36 +353,53 @@ end
-- 'str' [string] input string that should be matched -- 'str' [string] input string that should be matched
-- 'pat' [string] unformatted pattern -- 'pat' [string] unformatted pattern
-- returns: [strings] matched string in capture order -- returns: [strings] matched string in capture order
local a, b, c, d, e
local _, va, vb, vc, vd, ve
local ra, rb, rc, rd, re
function pfUI.api.cmatch(str, pat) function pfUI.api.cmatch(str, pat)
-- read capture indexes -- idx* = the logical %N index of each physical capture slot (nil when the
a, b, c, d, e = GetCaptures(pat) -- pattern has no %N$ markers); val* = the matched values in physical order.
_, _, va, vb, vc, vd, ve = string.find(str, pfUI.api.SanitizePattern(pat)) local idx1, idx2, idx3, idx4, idx5 = GetCaptures(pat)
local _, _, val1, val2, val3, val4, val5 = string.find(str, pfUI.api.SanitizePattern(pat))
-- put entries into the proper return values -- reorder the physical matches into logical (%1..%5) order
ra = e == 1 and ve or d == 1 and vd or c == 1 and vc or b == 1 and vb or va local out1 = idx5 == 1 and val5 or idx4 == 1 and val4 or idx3 == 1 and val3 or idx2 == 1 and val2 or val1
rb = e == 2 and ve or d == 2 and vd or c == 2 and vc or a == 2 and va or vb local out2 = idx5 == 2 and val5 or idx4 == 2 and val4 or idx3 == 2 and val3 or idx1 == 2 and val1 or val2
rc = e == 3 and ve or d == 3 and vd or a == 3 and va or b == 3 and vb or vc local out3 = idx5 == 3 and val5 or idx4 == 3 and val4 or idx1 == 3 and val1 or idx2 == 3 and val2 or val3
rd = e == 4 and ve or a == 4 and va or c == 4 and vc or b == 4 and vb or vd local out4 = idx5 == 4 and val5 or idx1 == 4 and val1 or idx3 == 4 and val3 or idx2 == 4 and val2 or val4
re = a == 5 and va or d == 5 and vd or c == 5 and vc or b == 5 and vb or ve local out5 = idx1 == 5 and val1 or idx4 == 5 and val4 or idx3 == 5 and val3 or idx2 == 5 and val2 or val5
return ra, rb, rc, rd, re return out1, out2, out3, out4, out5
end end
-- [ GetItemLinkByName ] -- [ GetItemLinkByName ]
-- Returns an itemLink for the given itemname -- Returns an itemLink for the given itemname
-- 'name' [string] name of the item -- 'name' [string] name of the item
-- returns: [string] entire itemLink for the given item -- returns: [string] entire itemLink for the given item
local itemLinkCache = {}
local itemLinkMisses = {}
local ITEMLINK_MAX_SCANS = 2
function pfUI.api.GetItemLinkByName(name) function pfUI.api.GetItemLinkByName(name)
for itemID = 1, 25818 do -- GetInboxItem() hands us a nil name for attachment-less mail
if not name then return end
-- cache successful resolutions so repeated lookups (e.g. per inbox click) are free
if itemLinkCache[name] then return itemLinkCache[name] end
-- Failures have to be counted, not just retried. An unresolvable name walks
-- the entire id range and finds nothing -- a visible hitch on every tooltip
-- hover. Allow a couple of attempts (rendering the tooltip caches the item,
-- so the next hover usually resolves), then stop scanning for that name.
local misses = itemLinkMisses[name] or 0
if misses >= ITEMLINK_MAX_SCANS then return end
-- Octo/Turtle custom items live well past the 25818 vanilla ceiling
for itemID = 1, 61000 do
local itemName = C_Item.GetItemNameByID(itemID) local itemName = C_Item.GetItemNameByID(itemID)
if itemName and itemName == name then if itemName and itemName == name then
local _, itemLink = C_Item.GetItemInfo(itemID) local _, itemLink = C_Item.GetItemInfo(itemID)
itemLinkCache[name] = itemLink
return itemLink return itemLink
end end
end end
itemLinkMisses[name] = misses + 1
end end
-- [ FindItem ] -- [ FindItem ]
@@ -440,37 +448,32 @@ function pfUI.api.GetBagFamily(bag)
end end
-- [ Abbreviate ] -- [ Abbreviate ]
-- Abbreviates a number from 1234 to 1.23k -- Abbreviates a number from 1234 to 1.23k, as the unitframes.abbrevnum
-- setting asks: "0" full numbers, "1" 2 decimals (4250 -> 4.25k),
-- "2" 1 decimal rounded down (4250 -> 4.2k)
-- 'number' [number] the number that should be abbreviated -- 'number' [number] the number that should be abbreviated
-- 'returns: [string] the abbreviated value -- 'returns: [string] the abbreviated value
local function CreateAbbreviateFormatter(step, rounding)
local Down = Enum.NumericRuleFormatRounding.Down
local formatter = C_StringUtil.CreateNumericRuleFormatter()
formatter:SetBreakpoints({
{ threshold = 0, format = "%d", components = { { step = 1, rounding = Down } } },
{ threshold = 1000, format = "%gk", components = { { div = 1000, step = step, rounding = rounding } } },
{ threshold = 1000000, format = "%gm", components = { { div = 1000000, step = step, rounding = rounding } } },
})
return formatter
end
local abbreviateFormatters = {
["1"] = CreateAbbreviateFormatter(0.01, Enum.NumericRuleFormatRounding.Nearest),
["2"] = CreateAbbreviateFormatter(0.1, Enum.NumericRuleFormatRounding.Down),
}
function pfUI.api.Abbreviate(number) function pfUI.api.Abbreviate(number)
local mode = pfUI_config.unitframes.abbrevnum local formatter = abbreviateFormatters[pfUI_config.unitframes.abbrevnum]
-- mode "0" = disabled (full numbers) if not formatter then return math.floor(number) end
-- mode "1" = 2 decimals (4250 -> 4.25k) [legacy/default] if number < 0 then return "-" .. formatter:FormatNumber(-number) end
-- mode "2" = 1 decimal (4250 -> 4.2k) - always rounds DOWN return formatter:FormatNumber(number)
if mode == "1" or mode == "2" then
local sign = number < 0 and -1 or 1
number = math.abs(number)
if number > 1000000 then
if mode == "2" then
-- 1 decimal, round DOWN: 4.18m -> 4.1m
return (floor(number/100000) / 10 * sign) .. "m"
else
return pfUI.api.round(number/1000000*sign, 2) .. "m"
end
elseif number > 1000 then
if mode == "2" then
-- 1 decimal, round DOWN: 4180 -> 4.1k (not 4.2k)
return (floor(number/100) / 10 * sign) .. "k"
else
return pfUI.api.round(number/1000*sign, 2) .. "k"
end
end
end
return math.floor(number)
end end
-- [ SendChatMessageWide ] -- [ SendChatMessageWide ]
@@ -490,6 +493,14 @@ function pfUI.api.SendChatMessageWide(msg)
SendChatMessage(msg,channel) SendChatMessage(msg,channel)
end end
-- [ CopyText ]
-- Copies text to the clipboard and says so in the colour of a UI_INFO_MESSAGE
-- 'text' [string] the text to copy
function pfUI.api.CopyText(text)
CopyToClipboard(text)
UIErrorsFrame:AddMessage(T["Copied to clipboard"], 1, 1, 0, 1)
end
-- [ GroupInfoByName ] -- [ GroupInfoByName ]
-- Gets the unit id by name -- Gets the unit id by name
-- 'name' [string] party or raid member -- 'name' [string] party or raid member
@@ -554,75 +565,21 @@ function hooksecurefunc(tbl, name, func)
return _G.hooksecurefunc(tbl, name, func) return _G.hooksecurefunc(tbl, name, func)
end end
-- [ HookAddonOrVariable ] -- [ HookAddon ]
-- Sets a function to be called automatically once an addon gets loaded -- Runs a function once an addon has loaded, but never before PLAYER_LOGIN.
-- 'addon' [string] addon or variable name -- Module and skin bodies run inside pfUI's own ADDON_LOADED, so an addon that
-- is already loaded there would otherwise run its hook before later pfUI
-- modules exist and before the addon's own VARIABLES_LOADED setup. A
-- load-on-demand addon runs its hook on its ADDON_LOADED. Hooks for addons
-- that are not installed are dropped. Hooks on the same addon run in no
-- particular order.
-- 'addon' [string] addon name
-- 'func' [function] function that should run -- 'func' [function] function that should run
do function pfUI.api.HookAddon(addon, func)
local lurker if not C_AddOns.DoesAddOnExist(addon) then return end
local pending = {} EventUtil.ContinueOnPlayerLogin(function()
EventUtil.ContinueOnAddOnLoaded(addon, func)
local function ProcessPending() end)
if not lurker.foundConfig then return end
for i = table.getn(pending), 1, -1 do
local hook = pending[i]
if IsAddOnLoaded(hook.addon) or _G[hook.addon] then
hook.func()
table.remove(pending, i)
end
end
if table.getn(pending) == 0 then
lurker:UnregisterAllEvents()
end
end
function pfUI.api.HookAddonOrVariable(addon, func)
if not lurker then
lurker = CreateFrame("Frame", nil)
lurker:SetScript("OnEvent", function()
if event == "VARIABLES_LOADED" or event == "PLAYER_ENTERING_WORLD" then
this.foundConfig = true
end
ProcessPending()
end)
end
table.insert(pending, { addon = addon, func = func })
lurker:RegisterEvent("ADDON_LOADED")
lurker:RegisterEvent("VARIABLES_LOADED")
lurker:RegisterEvent("PLAYER_ENTERING_WORLD")
ProcessPending()
end
end
-- [ QueueFunction ]
-- Add functions to a FIFO queue for execution after a short delay.
-- '...' [vararg] function, [arguments]
local timer
function pfUI.api.QueueFunction(a1,a2,a3,a4,a5,a6,a7,a8,a9)
if not timer then
timer = CreateFrame("Frame")
timer.queue = {}
timer.interval = TOOLTIP_UPDATE_TIME
timer.DeQueue = function()
local item = table.remove(timer.queue,1)
if item then
item[1](item[2],item[3],item[4],item[5],item[6],item[7],item[8],item[9])
end
if table.getn(timer.queue) == 0 then
timer:Hide() -- no need to run the OnUpdate when the queue is empty
end
end
timer:SetScript("OnUpdate",function()
this.sinceLast = (this.sinceLast or 0) + arg1
while (this.sinceLast > this.interval) do
this.DeQueue()
this.sinceLast = this.sinceLast - this.interval
end
end)
end
table.insert(timer.queue,{a1,a2,a3,a4,a5,a6,a7,a8,a9})
timer:Show() -- start the OnUpdate
end end
-- [ Create Gold String ] -- [ Create Gold String ]
@@ -633,63 +590,29 @@ end
function pfUI.api.CreateGoldString(money) function pfUI.api.CreateGoldString(money)
if type(money) ~= "number" then return "-" end if type(money) ~= "number" then return "-" end
local gold = floor(money/ 100 / 100) return "|cffffffff" .. _G.GetCoinTextureString(money) .. "|r"
local silver = floor(mod((money/100),100))
local copper = floor(mod(money,100))
local string = ""
if gold > 0 then string = string .. "|cffffffff" .. gold .. "|cffffd700g" end
if silver > 0 or gold > 0 then string = string .. "|cffffffff " .. silver .. "|cffc7c7cfs" end
string = string .. "|cffffffff " .. copper .. "|cffeda55fc"
return string
end end
-- [ Enable Movable ] -- [ Enable Movable ]
-- Set all necessary functions to make a already existing frame movable. -- Set all necessary functions to make a already existing frame movable.
-- 'name' [frame/string] Name of the Frame that should be movable -- 'name' [frame/string] Name of the Frame that should be movable
-- 'addon' [string] Addon that must be loaded before being able to access the frame
-- 'blacklist' [table] A list of frames that should be deactivated for mouse usage -- 'blacklist' [table] A list of frames that should be deactivated for mouse usage
local function OnDragStart() this:StartMoving() end local function OnDragStart() this:StartMoving() end
local function OnDragStop() this:StopMovingOrSizing() end local function OnDragStop() this:StopMovingOrSizing() end
function pfUI.api.EnableMovable(name, addon, blacklist) function pfUI.api.EnableMovable(name, blacklist)
if addon then if blacklist then
local scan = CreateFrame("Frame") for _, disable in pairs(blacklist) do
scan:RegisterEvent("ADDON_LOADED") _G[disable]:EnableMouse(false)
scan:SetScript("OnEvent", function()
if arg1 == addon then
local frame = _G[name]
if blacklist then
for _, disable in pairs(blacklist) do
_G[disable]:EnableMouse(false)
end
end
frame:SetMovable(true)
frame:EnableMouse(true)
frame:RegisterForDrag("LeftButton")
frame:SetScript("OnDragStart", OnDragStart)
frame:SetScript("OnDragStop", OnDragStop)
this:UnregisterAllEvents()
end
end)
else
if blacklist then
for _, disable in pairs(blacklist) do
_G[disable]:EnableMouse(false)
end
end end
local frame = name
if type(name) == "string" then frame = _G[name] end
frame:SetMovable(true)
frame:EnableMouse(true)
frame:RegisterForDrag("LeftButton")
frame:SetScript("OnDragStart", OnDragStart)
frame:SetScript("OnDragStop", OnDragStop)
end end
local frame = name
if type(name) == "string" then frame = _G[name] end
frame:SetMovable(true)
frame:EnableMouse(true)
frame:RegisterForDrag("LeftButton")
frame:SetScript("OnDragStart", OnDragStart)
frame:SetScript("OnDragStop", OnDragStop)
end end
-- [ Copy Table ] -- [ Copy Table ]
@@ -982,16 +905,34 @@ end
-- [ GetStringColor ] -- [ GetStringColor ]
-- Queries the pfUI setting strings and extract its color codes -- Queries the pfUI setting strings and extract its color codes
-- returns r,g,b,a -- returns r,g,b,a as strings
local color_cache = {} local color_cache = setmetatable({}, {
function pfUI.api.GetStringColor(colorstr) __index = function(t, k)
if not color_cache[colorstr] then local color = { pfUI.api.strsplit(",", k) }
local r, g, b, a = pfUI.api.strsplit(",", colorstr) rawset(t, k, color)
color_cache[colorstr] = { r, g, b, a } return color
end end
})
function pfUI.api.GetStringColor(colorstr)
return unpack(color_cache[colorstr]) return unpack(color_cache[colorstr])
end end
-- [ GetStringColorObject ]
-- Like GetStringColor, but returns a cached ColorMixin instead of raw values.
-- The object is a shared per-string singleton, so treat it as read-only.
-- returns a ColorMixin
local color_object_cache = setmetatable({}, {
__index = function(t, k)
local r,g,b,a = pfUI.api.GetStringColor(k)
local color = CreateColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
rawset(t, k, color)
return color
end
})
function pfUI.api.GetStringColorObject(colorstr)
return color_object_cache[colorstr]
end
-- [ rgbhex ] -- [ rgbhex ]
-- Returns color format from color info -- Returns color format from color info
-- 'r' [table | number] color table or r color component -- 'r' [table | number] color table or r color component
@@ -999,12 +940,13 @@ end
-- 'b' [number] optional b color component -- 'b' [number] optional b color component
-- 'a' [number] optional alpha component -- 'a' [number] optional alpha component
-- returns color string in the form of '|caarrggbb' -- returns color string in the form of '|caarrggbb'
local _r, _g, _b, _a local rgbhex_cache = {}
function pfUI.api.rgbhex(r, g, b, a) function pfUI.api.rgbhex(r, g, b, a)
local _r, _g, _b, _a
if type(r) == "table" then if type(r) == "table" then
if r.r then if r.r then
_r, _g, _b, _a = r.r, r.g, r.b, (r.a or 1) _r, _g, _b, _a = r.r, r.g, r.b, (r.a or 1)
elseif table.getn(r) >= 3 then elseif r[3] ~= nil then
_r, _g, _b, _a = r[1], r[2], r[3], (r[4] or 1) _r, _g, _b, _a = r[1], r[2], r[3], (r[4] or 1)
end end
elseif tonumber(r) then elseif tonumber(r) then
@@ -1012,7 +954,13 @@ function pfUI.api.rgbhex(r, g, b, a)
end end
if _r and _g and _b and _a then if _r and _g and _b and _a then
return CreateColor(_r, _g, _b, _a):GenerateHexColorMarkup() local key = ((Round(_r*255)*256 + Round(_g*255))*256 + Round(_b*255))*256 + Round(_a*255)
local hex = rgbhex_cache[key]
if not hex then
hex = "|c" .. C_ColorUtil.GenerateTextColorCode({ r = _r, g = _g, b = _b, a = _a })
rgbhex_cache[key] = hex
end
return hex
end end
return "" return ""
@@ -1207,17 +1155,46 @@ function pfUI.api.CreateBackdropShadow(f)
f.backdrop_shadow:SetBackdropBorderColor(0, 0, 0, tonumber(pfUI_config.appearance.border.shadow_intensity)) f.backdrop_shadow:SetBackdropBorderColor(0, 0, 0, tonumber(pfUI_config.appearance.border.shadow_intensity))
end end
-- [ Set Castbar Shield ]
-- Colors a castbar for a cast that none of the player's own interrupts or
-- silences can stop. The bar and the icon's border both take the shield color,
-- so the state still reads on a bar configured without an icon. Not shielded
-- restores the normal cast/channel color and the configured border.
-- 'bar' [frame] the castbar statusbar
-- 'icon' [frame] the icon frame, or nil for a bar without one
-- 'shielded' [bool] whether the cast is uninterruptible
-- 'isChannel' [bool] selects the unshielded color
function pfUI.api.SetCastbarShield(bar, icon, shielded, isChannel)
if shielded then
bar:SetStatusBarColor(pfUI.api.GetStringColor(C.appearance.castbar.shieldcolor))
else
bar:SetStatusBarColor(pfUI.api.GetStringColor(C.appearance.castbar[isChannel and "channelcolor" or "castbarcolor"]))
end
local iconborder = icon and icon.backdrop
if not iconborder then return end
if shielded then
iconborder:SetBackdropBorderColor(pfUI.api.GetStringColor(C.appearance.castbar.shieldcolor))
else
iconborder:SetBackdropBorderColor(pfUI.api.GetStringColor(C.appearance.border.color))
end
end
-- [ Bar Layout Options ] -- -- [ Bar Layout Options ] --
-- 'barsize' size of bar in number of buttons -- 'barsize' size of bar in number of buttons
-- returns: array of options as strings for pfUI.gui.bar -- returns: array of options as strings for pfUI.gui.bar: every grid
-- that fits the bar exactly, plus common uneven ones
function pfUI.api.BarLayoutOptions(barsize) function pfUI.api.BarLayoutOptions(barsize)
assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarLayoutOptions: barsize "..tostring(barsize).." is invalid") assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarLayoutOptions: barsize "..tostring(barsize).." is invalid")
local options, seen = {}, {} local options, seen = {}, {}
local function add(option) local function add(option)
if not seen[option] then table.insert(options, option); seen[option] = true end if not seen[option] then table.insert(options, option); seen[option] = true end
end end
for i,layout in ipairs(pfGridmath[barsize]) do for cols = 1, barsize do
add(string.format("%d x %d",layout[1],layout[2])) if barsize % cols == 0 then
add(string.format("%d x %d", cols, barsize / cols))
end
end end
for _, option in ipairs({ for _, option in ipairs({
"1 x 12", "1 x 10", "2 x 10", "2 x 5", "3 x 10", "3 x 5", "3 x 3", "1 x 12", "1 x 10", "2 x 10", "2 x 5", "3 x 10", "3 x 5", "3 x 3",
@@ -1237,49 +1214,23 @@ function pfUI.api.BarLayoutOptions(barsize)
return options return options
end end
-- [ Bar Layout Formfactor ] -- -- 'formfactor' has to be a "cols x rows" string; the actionbar module resets
-- 'option' string option as used in pfUI_config.bars[bar].option -- a stored layout that isn't one before it lays out a bar
-- returns: integer formfactor
local formfactors = {}
setmetatable(formfactors, {__mode = "v"}) -- weak table so values not referenced are collected on next gc
function pfUI.api.BarLayoutFormfactor(option)
if formfactors[option] then
return formfactors[option]
else
for barsize,_ in ipairs(pfGridmath) do
local options = pfUI.api.BarLayoutOptions(barsize)
for i,opt in ipairs(options) do
if opt == option then
formfactors[option] = i
return formfactors[option]
end
end
end
end
end
local function ResolveBarLayout(barsize, formfactor, uneven) local function ResolveBarLayout(barsize, formfactor, uneven)
local layout = tostring(formfactor or "") local _, _, a, b = string.find(formfactor, "(%d+)%s*x%s*(%d+)")
local _, _, a, b = string.find(layout, "(%d+)%s*x%s*(%d+)") local cols, rows = tonumber(a), tonumber(b)
if a and b then cols = math.min(NUM_ACTIONBAR_BUTTONS, math.max(1, cols))
local cols, rows = tonumber(a), tonumber(b) rows = math.min(NUM_ACTIONBAR_BUTTONS, math.max(1, rows))
cols = math.min(NUM_ACTIONBAR_BUTTONS, math.max(1, cols)) local orientation = string.upper(uneven or "DOWN")
rows = math.min(NUM_ACTIONBAR_BUTTONS, math.max(1, rows)) local mode = (orientation == "LEFT" or orientation == "RIGHT") and "cols" or "rows"
local orientation = string.upper(uneven or "DOWN") if mode == "rows" then
local mode = (orientation == "LEFT" or orientation == "RIGHT") and "cols" or "rows" cols = math.max(1, math.min(cols, barsize))
if mode == "rows" then rows = math.max(1, math.ceil(barsize / cols))
cols = math.max(1, math.min(cols, barsize)) else
rows = math.max(1, math.ceil(barsize / cols)) rows = math.max(1, math.min(rows, barsize))
else cols = math.max(1, math.ceil(barsize / rows))
rows = math.max(1, math.min(rows, barsize))
cols = math.max(1, math.ceil(barsize / rows))
end
return cols, rows, mode, orientation
end end
local index = pfUI.api.BarLayoutFormfactor(layout) return cols, rows, mode, orientation
if not index then return nil end
local cols, rows = unpack(pfGridmath[barsize][index])
return cols, rows, "rows", "DOWN"
end end
-- [ Bar Layout Size ] -- -- [ Bar Layout Size ] --
@@ -1290,7 +1241,6 @@ end
function pfUI.api.BarLayoutSize(bar,barsize,formfactor,iconsize,bordersize,padding,uneven,fillmode) function pfUI.api.BarLayoutSize(bar,barsize,formfactor,iconsize,bordersize,padding,uneven,fillmode)
assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarLayoutSize: barsize "..tostring(barsize).." is invalid") assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarLayoutSize: barsize "..tostring(barsize).." is invalid")
local cols, rows = ResolveBarLayout(barsize, formfactor, uneven) local cols, rows = ResolveBarLayout(barsize, formfactor, uneven)
if not cols or not rows then cols, rows = unpack(pfGridmath[barsize][1]) end
local width = (iconsize + bordersize*2+padding) * cols + padding local width = (iconsize + bordersize*2+padding) * cols + padding
local height = (iconsize + bordersize*2+padding) * rows + padding local height = (iconsize + bordersize*2+padding) * rows + padding
bar._size = {width,height} bar._size = {width,height}
@@ -1308,9 +1258,6 @@ end
function pfUI.api.BarButtonAnchor(button,basename,buttonindex,barsize,formfactor,iconsize,bordersize,padding,uneven,fillmode) function pfUI.api.BarButtonAnchor(button,basename,buttonindex,barsize,formfactor,iconsize,bordersize,padding,uneven,fillmode)
assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarButtonAnchor: barsize "..tostring(barsize).." is invalid") assert(barsize > 0 and barsize <= NUM_ACTIONBAR_BUTTONS,"BarButtonAnchor: barsize "..tostring(barsize).." is invalid")
local cols, rows, mode, orientation = ResolveBarLayout(barsize, formfactor, uneven) local cols, rows, mode, orientation = ResolveBarLayout(barsize, formfactor, uneven)
if not cols or not rows then
cols, rows, mode, orientation = unpack(pfGridmath[barsize][1]), "rows", "DOWN"
end
-- fillmode: remap buttonindex to slotindex (grid position in native fill order) -- fillmode: remap buttonindex to slotindex (grid position in native fill order)
-- only needed when fill direction differs from layout mode -- only needed when fill direction differs from layout mode
@@ -1391,6 +1338,18 @@ function pfUI.api.BarButtonAnchor(button,basename,buttonindex,barsize,formfactor
return button._anchor return button._anchor
end end
-- [ MouseIsOverHitRect ] --
-- Like frame:IsMouseOver(), but tests the frame's hit rect, the area the
-- engine uses for mouse focus and OnEnter/OnLeave. CreateBackdrop widens
-- that rect by the border, so plain IsMouseOver misses a band around it.
-- 'frame' the frame to test
-- return true when the cursor is inside the frame's hit rect
function pfUI.api.MouseIsOverHitRect(frame)
if not frame.GetHitRectInsets then return frame:IsMouseOver() end
local left, right, top, bottom = frame:GetHitRectInsets()
return frame:IsMouseOver(-top, bottom, left, -right)
end
-- [ Enable Autohide ] -- -- [ Enable Autohide ] --
-- 'frame' the frame that should be hidden -- 'frame' the frame that should be hidden
function pfUI.api.EnableAutohide(frame, timeout, combat) function pfUI.api.EnableAutohide(frame, timeout, combat)
@@ -1403,11 +1362,20 @@ function pfUI.api.EnableAutohide(frame, timeout, combat)
frame.hover.parent = frame frame.hover.parent = frame
frame.hover:Show() frame.hover:Show()
if not frame.hover.fade then
frame.hover.fade = frame:CreateAnimationGroup()
local fade = frame.hover.fade:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(1)
frame.hover.fade:SetScript("OnFinished", function() frame:SetAlpha(0) end)
end
if combat then if combat then
frame.hover:RegisterEvent("PLAYER_REGEN_ENABLED") frame.hover:RegisterEvent("PLAYER_REGEN_ENABLED")
frame.hover:RegisterEvent("PLAYER_REGEN_DISABLED") frame.hover:RegisterEvent("PLAYER_REGEN_DISABLED")
frame.hover:SetScript("OnEvent", function() frame.hover:SetScript("OnEvent", function()
if event == "PLAYER_REGEN_DISABLED" then if event == "PLAYER_REGEN_DISABLED" then
this.fade:Stop()
this.parent:SetAlpha(1) this.parent:SetAlpha(1)
this.activeTo = "keep" this.activeTo = "keep"
elseif event == "PLAYER_REGEN_ENABLED" then elseif event == "PLAYER_REGEN_ENABLED" then
@@ -1423,13 +1391,13 @@ function pfUI.api.EnableAutohide(frame, timeout, combat)
if this.activeTo == "keep" then return end if this.activeTo == "keep" then return end
if MouseIsOver(this, 10, -10, -10, 10) then if this:IsMouseOver(10, -10, -10, 10) then
this.activeTo = GetTime() + timeout this.activeTo = GetTime() + timeout
this.fade:Stop()
this.parent:SetAlpha(1) this.parent:SetAlpha(1)
elseif this.activeTo then elseif this.activeTo then
if this.activeTo < GetTime() and this.parent:GetAlpha() > 0 then if this.activeTo < GetTime() and this.parent:GetAlpha() > 0 and not this.fade:IsPlaying() then
local fps = (60 / math.max(GetFramerate(), 1)) this.fade:Play()
this.parent:SetAlpha(this.parent:GetAlpha() - 0.05*fps)
end end
else else
this.activeTo = GetTime() + timeout this.activeTo = GetTime() + timeout
@@ -1446,75 +1414,10 @@ function pfUI.api.DisableAutohide(frame)
frame.hover:SetScript("OnEvent", nil) frame.hover:SetScript("OnEvent", nil)
frame.hover:SetScript("OnUpdate", nil) frame.hover:SetScript("OnUpdate", nil)
frame.hover:Hide() frame.hover:Hide()
frame.hover.fade:Stop()
frame:SetAlpha(1) frame:SetAlpha(1)
end end
-- [ GetColoredTime ] --
-- 'remaining' the time in seconds that should be converted
-- return a colored string including a time unit (m/h/d)
local color_day, color_hour, color_minute, color_low, color_normal
function pfUI.api.GetColoredTimeString(remaining)
if not remaining then return "" end
-- Show days if remaining is > 99 Hours (99 * 60 * 60)
if remaining > 356400 then
if not color_day then
local r,g,b,a = pfUI.api.GetStringColor(C.appearance.cd.daycolor)
color_day = pfUI.api.rgbhex(r,g,b)
end
return color_day .. round(remaining / 86400) .. "|rd"
-- Show hours if remaining is > 99 Minutes (99 * 60)
elseif remaining > 5940 then
if not color_hour then
local r,g,b,a = pfUI.api.GetStringColor(C.appearance.cd.hourcolor)
color_hour = pfUI.api.rgbhex(r,g,b)
end
return color_hour .. round(remaining / 3600) .. "|rh"
-- Show minutes if remaining is > 99 Seconds (99)
elseif remaining > 99 then
if not color_minute then
local r,g,b,a = pfUI.api.GetStringColor(C.appearance.cd.minutecolor)
color_minute = pfUI.api.rgbhex(r,g,b)
end
return color_minute .. round(remaining / 60) .. "|rm"
-- Show milliseconds on low
elseif remaining <= 5 and pfUI_config.appearance.cd.milliseconds == "1" then
if not color_low then
local r,g,b,a = pfUI.api.GetStringColor(C.appearance.cd.lowcolor)
color_low = pfUI.api.rgbhex(r,g,b)
end
return color_low .. string.format("%.1f", round(remaining,1))
-- Show seconds on low
elseif remaining <= 5 then
if not color_low then
local r,g,b,a = pfUI.api.GetStringColor(C.appearance.cd.lowcolor)
color_low = pfUI.api.rgbhex(r,g,b)
end
return color_low .. round(remaining)
-- Show seconds on normal
elseif remaining >= 0 then
if not color_normal then
local r, g, b, a = pfUI.api.GetStringColor(C.appearance.cd.normalcolor)
color_normal = pfUI.api.rgbhex(r,g,b)
end
return color_normal .. round(remaining)
-- Return empty
else
return ""
end
end
-- [ GetColorGradient ] -- -- [ GetColorGradient ] --
-- 'perc' percentage (0-1) -- 'perc' percentage (0-1)
-- return r,g,b and hexcolor -- return r,g,b and hexcolor
+178 -57
View File
@@ -138,23 +138,55 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "border", "panels", "-1") pfUI:UpdateConfig("appearance", "border", "panels", "-1")
pfUI:UpdateConfig("appearance", "border", "chat", "-1") pfUI:UpdateConfig("appearance", "border", "chat", "-1")
pfUI:UpdateConfig("appearance", "border", "bags", "-1") pfUI:UpdateConfig("appearance", "border", "bags", "-1")
pfUI:UpdateConfig("appearance", "cd", "lowcolor", "1,.2,.2,1")
pfUI:UpdateConfig("appearance", "cd", "normalcolor", "1,1,1,1") pfUI:UpdateConfig("cooldown", nil, "font", "Interface\\AddOns\\pfUI\\fonts\\BigNoodleTitling.ttf")
pfUI:UpdateConfig("appearance", "cd", "minutecolor", ".2,1,1,1") pfUI:UpdateConfig("cooldown", nil, "font_size", "12")
pfUI:UpdateConfig("appearance", "cd", "hourcolor", ".2,.5,1,1") pfUI:UpdateConfig("cooldown", nil, "dynamicsize", "1")
pfUI:UpdateConfig("appearance", "cd", "daycolor", ".2,.2,1,1") pfUI:UpdateConfig("cooldown", nil, "threshold", "2")
pfUI:UpdateConfig("appearance", "cd", "threshold", "2") pfUI:UpdateConfig("cooldown", nil, "milliseconds", "1")
pfUI:UpdateConfig("appearance", "cd", "font_size", "12") pfUI:UpdateConfig("cooldown", nil, "lowcolor", "1,.2,.2,1")
pfUI:UpdateConfig("appearance", "cd", "font_size_blizz", "12") pfUI:UpdateConfig("cooldown", nil, "normalcolor", "1,1,1,1")
pfUI:UpdateConfig("appearance", "cd", "font_size_foreign","12") pfUI:UpdateConfig("cooldown", nil, "minutecolor", ".2,1,1,1")
pfUI:UpdateConfig("appearance", "cd", "blizzard", "1") pfUI:UpdateConfig("cooldown", nil, "hourcolor", ".2,.5,1,1")
pfUI:UpdateConfig("appearance", "cd", "foreign", "0") pfUI:UpdateConfig("cooldown", nil, "daycolor", ".2,.2,1,1")
pfUI:UpdateConfig("appearance", "cd", "milliseconds", "1") pfUI:UpdateConfig("cooldown", "actionbar", "text", "1")
pfUI:UpdateConfig("appearance", "cd", "hideanim", "0") pfUI:UpdateConfig("cooldown", "actionbar", "animation", "1")
pfUI:UpdateConfig("appearance", "cd", "font", "Interface\\AddOns\\pfUI\\fonts\\BigNoodleTitling.ttf") pfUI:UpdateConfig("cooldown", "actionbar", "reverse", "0")
pfUI:UpdateConfig("appearance", "cd", "dynamicsize", "1") pfUI:UpdateConfig("cooldown", "bags", "text", "1")
pfUI:UpdateConfig("cooldown", "bags", "animation", "1")
pfUI:UpdateConfig("cooldown", "bags", "reverse", "0")
pfUI:UpdateConfig("cooldown", "blizzard", "text", "1")
pfUI:UpdateConfig("cooldown", "blizzard", "animation", "1")
pfUI:UpdateConfig("cooldown", "blizzard", "reverse", "0")
pfUI:UpdateConfig("cooldown", "unitframe", "text", "1")
pfUI:UpdateConfig("cooldown", "unitframe", "animation", "0")
pfUI:UpdateConfig("cooldown", "unitframe", "reverse", "1")
pfUI:UpdateConfig("cooldown", "indicator", "text", "1")
pfUI:UpdateConfig("cooldown", "indicator", "animation", "0")
pfUI:UpdateConfig("cooldown", "indicator", "reverse", "0")
pfUI:UpdateConfig("cooldown", "nameplate", "text", "1")
pfUI:UpdateConfig("cooldown", "nameplate", "animation", "0")
pfUI:UpdateConfig("cooldown", "nameplate", "reverse", "1")
pfUI:UpdateConfig("cooldown", "buff", "text", "1")
pfUI:UpdateConfig("cooldown", "buff", "animation", "1")
pfUI:UpdateConfig("cooldown", "buff", "reverse", "1")
pfUI:UpdateConfig("cooldown", "tooltip", "text", "1")
pfUI:UpdateConfig("cooldown", "tooltip", "animation", "0")
pfUI:UpdateConfig("cooldown", "tooltip", "reverse", "0")
pfUI:UpdateConfig("cooldown", "totem", "text", "1")
pfUI:UpdateConfig("cooldown", "totem", "animation", "1")
pfUI:UpdateConfig("cooldown", "totem", "reverse", "1")
pfUI:UpdateConfig("cooldown", "lossofcontrol", "text", "1")
pfUI:UpdateConfig("cooldown", "lossofcontrol", "animation", "1")
pfUI:UpdateConfig("cooldown", "lossofcontrol", "reverse", "0")
pfUI:UpdateConfig("cooldown", "foreign", "text", "0")
pfUI:UpdateConfig("cooldown", "foreign", "animation", "1")
pfUI:UpdateConfig("appearance", "castbar", "castbarcolor", ".7,.7,.9,.8") pfUI:UpdateConfig("appearance", "castbar", "castbarcolor", ".7,.7,.9,.8")
pfUI:UpdateConfig("appearance", "castbar", "channelcolor", ".9,.9,.7,.8") pfUI:UpdateConfig("appearance", "castbar", "channelcolor", ".9,.9,.7,.8")
pfUI:UpdateConfig("appearance", "castbar", "failcolor", "1,.2,.2,.8")
pfUI:UpdateConfig("appearance", "castbar", "shieldcolor", ".8,.45,.45,.8")
pfUI:UpdateConfig("appearance", "castbar", "fsrcolor", ".9,.6,.2,.8")
pfUI:UpdateConfig("appearance", "castbar", "texture", "Interface\\AddOns\\pfUI\\img\\bar") pfUI:UpdateConfig("appearance", "castbar", "texture", "Interface\\AddOns\\pfUI\\img\\bar")
pfUI:UpdateConfig("appearance", "infight", "screen", "0") pfUI:UpdateConfig("appearance", "infight", "screen", "0")
pfUI:UpdateConfig("appearance", "infight", "aggro", "0") pfUI:UpdateConfig("appearance", "infight", "aggro", "0")
@@ -166,7 +198,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "bags", "newitem_color", "1,1,1,1") pfUI:UpdateConfig("appearance", "bags", "newitem_color", "1,1,1,1")
pfUI:UpdateConfig("appearance", "bags", "borderlimit", "1") pfUI:UpdateConfig("appearance", "bags", "borderlimit", "1")
pfUI:UpdateConfig("appearance", "bags", "borderonlygear", "0") pfUI:UpdateConfig("appearance", "bags", "borderonlygear", "0")
pfUI:UpdateConfig("appearance", "bags", "fulltext", "1")
pfUI:UpdateConfig("appearance", "bags", "movable", "0") pfUI:UpdateConfig("appearance", "bags", "movable", "0")
pfUI:UpdateConfig("appearance", "bags", "abovechat", "0") pfUI:UpdateConfig("appearance", "bags", "abovechat", "0")
pfUI:UpdateConfig("appearance", "bags", "hidechat", "0") pfUI:UpdateConfig("appearance", "bags", "hidechat", "0")
@@ -174,6 +205,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("appearance", "bags", "bagrowlength", "10") pfUI:UpdateConfig("appearance", "bags", "bagrowlength", "10")
pfUI:UpdateConfig("appearance", "bags", "bankrowlength", "10") pfUI:UpdateConfig("appearance", "bags", "bankrowlength", "10")
pfUI:UpdateConfig("appearance", "bags", "autoSortOnOpen", "0") pfUI:UpdateConfig("appearance", "bags", "autoSortOnOpen", "0")
pfUI:UpdateConfig("appearance", "bags", "sortreverse", "0")
pfUI:UpdateConfig("appearance", "bags", "sortprioreverse", "0")
pfUI:UpdateConfig("appearance", "minimap", "size", "140") pfUI:UpdateConfig("appearance", "minimap", "size", "140")
pfUI:UpdateConfig("appearance", "minimap", "arrowscale", "1") pfUI:UpdateConfig("appearance", "minimap", "arrowscale", "1")
pfUI:UpdateConfig("appearance", "minimap", "zonetext", "off") pfUI:UpdateConfig("appearance", "minimap", "zonetext", "off")
@@ -215,15 +248,14 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", nil, "ragecolor", "1,.5,.5,1") pfUI:UpdateConfig("unitframes", nil, "ragecolor", "1,.5,.5,1")
pfUI:UpdateConfig("unitframes", nil, "focuscolor", "1,1,.75,1") pfUI:UpdateConfig("unitframes", nil, "focuscolor", "1,1,.75,1")
pfUI:UpdateConfig("unitframes", nil, "animation_speed", "5") pfUI:UpdateConfig("unitframes", nil, "animatebars", "1")
pfUI:UpdateConfig("unitframes", nil, "portraitalpha", "0.1") pfUI:UpdateConfig("unitframes", nil, "portraitalpha", "0.1")
pfUI:UpdateConfig("unitframes", nil, "always2dportrait", "0") pfUI:UpdateConfig("unitframes", nil, "portraitstyle", "3d")
pfUI:UpdateConfig("unitframes", nil, "portraittexture", "1") pfUI:UpdateConfig("unitframes", nil, "portraittexture", "1")
pfUI:UpdateConfig("unitframes", nil, "layout", "default") pfUI:UpdateConfig("unitframes", nil, "layout", "default")
pfUI:UpdateConfig("unitframes", nil, "rangecheck", "0") pfUI:UpdateConfig("unitframes", nil, "rangecheck", "0")
pfUI:UpdateConfig("unitframes", nil, "rangecheck_mode", "vanilla") pfUI:UpdateConfig("unitframes", nil, "rangecheck_mode", "vanilla")
pfUI:UpdateConfig("unitframes", nil, "rangecheck_distance", "40") pfUI:UpdateConfig("unitframes", nil, "rangecheck_distance", "40")
pfUI:UpdateConfig("unitframes", nil, "buffdetect", "0")
pfUI:UpdateConfig("unitframes", nil, "druidmanabar", "1") pfUI:UpdateConfig("unitframes", nil, "druidmanabar", "1")
pfUI:UpdateConfig("unitframes", nil, "druidmanaheight", "10") pfUI:UpdateConfig("unitframes", nil, "druidmanaheight", "10")
pfUI:UpdateConfig("unitframes", nil, "druidmanawidth", "-1") pfUI:UpdateConfig("unitframes", nil, "druidmanawidth", "-1")
@@ -231,6 +263,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", nil, "druidmanaoffy", "0") pfUI:UpdateConfig("unitframes", nil, "druidmanaoffy", "0")
pfUI:UpdateConfig("unitframes", nil, "druidmanaspace", "-3") pfUI:UpdateConfig("unitframes", nil, "druidmanaspace", "-3")
pfUI:UpdateConfig("unitframes", nil, "druidmanatexture", "Interface\\AddOns\\pfUI\\img\\bar") pfUI:UpdateConfig("unitframes", nil, "druidmanatexture", "Interface\\AddOns\\pfUI\\img\\bar")
pfUI:UpdateConfig("unitframes", nil, "druidmanatext", "1")
pfUI:UpdateConfig("unitframes", nil, "combowidth", "6") pfUI:UpdateConfig("unitframes", nil, "combowidth", "6")
pfUI:UpdateConfig("unitframes", nil, "comboheight", "6") pfUI:UpdateConfig("unitframes", nil, "comboheight", "6")
@@ -246,6 +279,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", nil, "swingtimerohcolor",".3,.8,.3,1") pfUI:UpdateConfig("unitframes", nil, "swingtimerohcolor",".3,.8,.3,1")
pfUI:UpdateConfig("unitframes", nil, "swingtimerrangedcolor",".3,.6,1,1") pfUI:UpdateConfig("unitframes", nil, "swingtimerrangedcolor",".3,.6,1,1")
pfUI:UpdateConfig("unitframes", nil, "swingtimerrangedwarncolor",".9,0,0,1") pfUI:UpdateConfig("unitframes", nil, "swingtimerrangedwarncolor",".9,0,0,1")
pfUI:UpdateConfig("unitframes", nil, "swingtimeroutrangecolor",".5,.5,.5,1")
pfUI:UpdateConfig("unitframes", nil, "swingtimerhsqueue","1") pfUI:UpdateConfig("unitframes", nil, "swingtimerhsqueue","1")
pfUI:UpdateConfig("unitframes", nil, "swingtimerattackspeed","0") pfUI:UpdateConfig("unitframes", nil, "swingtimerattackspeed","0")
pfUI:UpdateConfig("unitframes", nil, "raidmarkerwidth", "80") pfUI:UpdateConfig("unitframes", nil, "raidmarkerwidth", "80")
@@ -278,9 +312,11 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", nil, "reactive_size", "28") pfUI:UpdateConfig("unitframes", nil, "reactive_size", "28")
pfUI:UpdateConfig("unitframes", nil, "damage_tracking", "0") pfUI:UpdateConfig("unitframes", nil, "damage_tracking", "0")
-- UnitXP Settings -- Target Indicators
pfUI:UpdateConfig("unitframes", nil, "unitxp_font_size", "13") pfUI:UpdateConfig("unitframes", nil, "indicator_font_size", "13")
pfUI:UpdateConfig("unitframes", nil, "los_indicator", "0") pfUI:UpdateConfig("unitframes", nil, "los_indicator", "0")
-- UnitXP Settings
pfUI:UpdateConfig("unitframes", nil, "behind_indicator", "0") pfUI:UpdateConfig("unitframes", nil, "behind_indicator", "0")
pfUI:UpdateConfig("unitframes", nil, "hide_distance_yd", "0") pfUI:UpdateConfig("unitframes", nil, "hide_distance_yd", "0")
pfUI:UpdateConfig("unitframes", nil, "unitxp_notify", "0") pfUI:UpdateConfig("unitframes", nil, "unitxp_notify", "0")
@@ -320,6 +356,9 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "player", "showRest", "0") pfUI:UpdateConfig("unitframes", "player", "showRest", "0")
pfUI:UpdateConfig("unitframes", "player", "energy", "1") pfUI:UpdateConfig("unitframes", "player", "energy", "1")
pfUI:UpdateConfig("unitframes", "player", "manatick", "0") pfUI:UpdateConfig("unitframes", "player", "manatick", "0")
pfUI:UpdateConfig("unitframes", "player", "showfsr", "1")
pfUI:UpdateConfig("unitframes", "player", "fsrheight", "4")
pfUI:UpdateConfig("unitframes", "player", "fsrstyle", "0")
pfUI:UpdateConfig("unitframes", "player", "display_haste", "0") pfUI:UpdateConfig("unitframes", "player", "display_haste", "0")
pfUI:UpdateConfig("unitframes", "player", "display_haste_color", "1,1,1,1") pfUI:UpdateConfig("unitframes", "player", "display_haste_color", "1,1,1,1")
pfUI:UpdateConfig("unitframes", "player", "display_spellpower", "1") pfUI:UpdateConfig("unitframes", "player", "display_spellpower", "1")
@@ -382,6 +421,27 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "grouppet", "glowcombat", "0") pfUI:UpdateConfig("unitframes", "grouppet", "glowcombat", "0")
pfUI:UpdateConfig("unitframes", "grouppet", "txthpright", "healthperc") pfUI:UpdateConfig("unitframes", "grouppet", "txthpright", "healthperc")
pfUI:UpdateConfig("unitframes", "raidpet", "portrait", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "width", "50")
pfUI:UpdateConfig("unitframes", "raidpet", "height", "14")
pfUI:UpdateConfig("unitframes", "raidpet", "pheight", "0")
pfUI:UpdateConfig("unitframes", "raidpet", "buffs", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "buffsize", "16")
pfUI:UpdateConfig("unitframes", "raidpet", "debuffs", "off")
pfUI:UpdateConfig("unitframes", "raidpet", "debuffsize", "16")
pfUI:UpdateConfig("unitframes", "raidpet", "faderange", "1")
pfUI:UpdateConfig("unitframes", "raidpet", "glowcombat", "0")
pfUI:UpdateConfig("unitframes", "raidpet", "txthpright", "healthperc")
-- off by default; mirrors the raid grid layout when enabled
pfUI:UpdateConfig("unitframes", "raidpet", "visible", "0")
-- collapse: pack only pets that exist (from the roster snapshot) instead
-- of mirroring every raid slot
pfUI:UpdateConfig("unitframes", "raidpet", "collapse", "1")
-- pet block has its own layout, independent of the raid grid
pfUI:UpdateConfig("unitframes", "raidpet", "raidlayout", "8x5")
pfUI:UpdateConfig("unitframes", "raidpet", "raidpadding", "3")
pfUI:UpdateConfig("unitframes", "raidpet", "raidfill", "VERTICAL")
pfUI:UpdateConfig("unitframes", "raid", "portrait", "off") pfUI:UpdateConfig("unitframes", "raid", "portrait", "off")
pfUI:UpdateConfig("unitframes", "raid", "width", "50") pfUI:UpdateConfig("unitframes", "raid", "width", "50")
pfUI:UpdateConfig("unitframes", "raid", "height", "26") pfUI:UpdateConfig("unitframes", "raid", "height", "26")
@@ -400,6 +460,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "raid", "raidlayout", "8x5") pfUI:UpdateConfig("unitframes", "raid", "raidlayout", "8x5")
pfUI:UpdateConfig("unitframes", "raid", "raidpadding", "3") pfUI:UpdateConfig("unitframes", "raid", "raidpadding", "3")
pfUI:UpdateConfig("unitframes", "raid", "raidfill", "VERTICAL") pfUI:UpdateConfig("unitframes", "raid", "raidfill", "VERTICAL")
pfUI:UpdateConfig("unitframes", "raid", "collapse", "0")
pfUI:UpdateConfig("unitframes", "raid", "raidgrouplabel", "0") pfUI:UpdateConfig("unitframes", "raid", "raidgrouplabel", "0")
pfUI:UpdateConfig("unitframes", "raid", "grouplabelxoff", "0") pfUI:UpdateConfig("unitframes", "raid", "grouplabelxoff", "0")
pfUI:UpdateConfig("unitframes", "raid", "grouplabelyoff", "8") pfUI:UpdateConfig("unitframes", "raid", "grouplabelyoff", "8")
@@ -455,7 +516,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", "ptarget", "txthpright", "none") pfUI:UpdateConfig("unitframes", "ptarget", "txthpright", "none")
pfUI:UpdateConfig("unitframes", "ptarget", "overhealperc", "10") pfUI:UpdateConfig("unitframes", "ptarget", "overhealperc", "10")
local ufs = { "player", "target", "focus", "focustarget", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback", "tttarget" } local ufs = { "player", "target", "focus", "focustarget", "group", "grouptarget", "grouppet", "raid", "raidpet", "ttarget", "pet", "ptarget", "fallback", "tttarget" }
for _, unit in pairs(ufs) do for _, unit in pairs(ufs) do
pfUI:UpdateConfig("unitframes", unit, "selfdebuff", "0") pfUI:UpdateConfig("unitframes", unit, "selfdebuff", "0")
pfUI:UpdateConfig("unitframes", unit, "visible", "1") pfUI:UpdateConfig("unitframes", unit, "visible", "1")
@@ -484,16 +545,20 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", unit, "portraitwidth", "-1") pfUI:UpdateConfig("unitframes", unit, "portraitwidth", "-1")
pfUI:UpdateConfig("unitframes", unit, "panchor", "TOP") pfUI:UpdateConfig("unitframes", unit, "panchor", "TOP")
pfUI:UpdateConfig("unitframes", unit, "pspace", "-3") pfUI:UpdateConfig("unitframes", unit, "pspace", "-3")
pfUI:UpdateConfig("unitframes", unit, "cooldown_text", "1")
pfUI:UpdateConfig("unitframes", unit, "cooldown_anim", "0")
pfUI:UpdateConfig("unitframes", unit, "buffs", "TOPLEFT") pfUI:UpdateConfig("unitframes", unit, "buffs", "TOPLEFT")
pfUI:UpdateConfig("unitframes", unit, "buffsize", "20") pfUI:UpdateConfig("unitframes", unit, "buffsize", "20")
pfUI:UpdateConfig("unitframes", unit, "bufflimit", "32") pfUI:UpdateConfig("unitframes", unit, "bufflimit", "32")
pfUI:UpdateConfig("unitframes", unit, "buffperrow", "8") pfUI:UpdateConfig("unitframes", unit, "buffperrow", "8")
pfUI:UpdateConfig("unitframes", unit, "ownbuffsize", "-1")
pfUI:UpdateConfig("unitframes", unit, "buffspacingx", "1")
pfUI:UpdateConfig("unitframes", unit, "buffspacingy", "1")
pfUI:UpdateConfig("unitframes", unit, "debuffs", "TOPLEFT") pfUI:UpdateConfig("unitframes", unit, "debuffs", "TOPLEFT")
pfUI:UpdateConfig("unitframes", unit, "debuffsize", "20") pfUI:UpdateConfig("unitframes", unit, "debuffsize", "20")
pfUI:UpdateConfig("unitframes", unit, "debufflimit", "32") pfUI:UpdateConfig("unitframes", unit, "debufflimit", "32")
pfUI:UpdateConfig("unitframes", unit, "debuffperrow", "8") pfUI:UpdateConfig("unitframes", unit, "debuffperrow", "8")
pfUI:UpdateConfig("unitframes", unit, "owndebuffsize", "-1")
pfUI:UpdateConfig("unitframes", unit, "debuffspacingx", "1")
pfUI:UpdateConfig("unitframes", unit, "debuffspacingy", "1")
pfUI:UpdateConfig("unitframes", unit, "invert_healthbar", "0") pfUI:UpdateConfig("unitframes", unit, "invert_healthbar", "0")
pfUI:UpdateConfig("unitframes", unit, "verticalbar", "0") pfUI:UpdateConfig("unitframes", unit, "verticalbar", "0")
pfUI:UpdateConfig("unitframes", unit, "buff_indicator", "0") pfUI:UpdateConfig("unitframes", unit, "buff_indicator", "0")
@@ -510,7 +575,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", unit, "show_procs", "0") pfUI:UpdateConfig("unitframes", unit, "show_procs", "0")
pfUI:UpdateConfig("unitframes", unit, "show_totems", "0") pfUI:UpdateConfig("unitframes", unit, "show_totems", "0")
pfUI:UpdateConfig("unitframes", unit, "all_procs", "0") pfUI:UpdateConfig("unitframes", unit, "all_procs", "0")
pfUI:UpdateConfig("unitframes", unit, "indicator_time", "1")
pfUI:UpdateConfig("unitframes", unit, "indicator_stacks", "1") pfUI:UpdateConfig("unitframes", unit, "indicator_stacks", "1")
pfUI:UpdateConfig("unitframes", unit, "indicator_size", "10") pfUI:UpdateConfig("unitframes", unit, "indicator_size", "10")
pfUI:UpdateConfig("unitframes", unit, "indicator_spacing","1") pfUI:UpdateConfig("unitframes", unit, "indicator_spacing","1")
@@ -528,7 +592,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", unit, "glowaggro", "1") pfUI:UpdateConfig("unitframes", unit, "glowaggro", "1")
pfUI:UpdateConfig("unitframes", unit, "glowcombat", "1") pfUI:UpdateConfig("unitframes", unit, "glowcombat", "1")
pfUI:UpdateConfig("unitframes", unit, "showtooltip", "1")
pfUI:UpdateConfig("unitframes", unit, "healthcolor", "1") pfUI:UpdateConfig("unitframes", unit, "healthcolor", "1")
pfUI:UpdateConfig("unitframes", unit, "powercolor", "1") pfUI:UpdateConfig("unitframes", unit, "powercolor", "1")
pfUI:UpdateConfig("unitframes", unit, "levelcolor", "1") pfUI:UpdateConfig("unitframes", unit, "levelcolor", "1")
@@ -620,7 +683,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("bars", nil, "animation", "zoomfade") pfUI:UpdateConfig("bars", nil, "animation", "zoomfade")
pfUI:UpdateConfig("bars", nil, "animmode", "keypress") pfUI:UpdateConfig("bars", nil, "animmode", "keypress")
pfUI:UpdateConfig("bars", nil, "animalways", "0") pfUI:UpdateConfig("bars", nil, "animalways", "0")
pfUI:UpdateConfig("bars", nil, "macroscan", "1")
pfUI:UpdateConfig("bars", nil, "reagents", "1") pfUI:UpdateConfig("bars", nil, "reagents", "1")
pfUI:UpdateConfig("bars", nil, "hunterbar", "0") pfUI:UpdateConfig("bars", nil, "hunterbar", "0")
pfUI:UpdateConfig("bars", nil, "pagemasteralt", "0") pfUI:UpdateConfig("bars", nil, "pagemasteralt", "0")
@@ -647,7 +709,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("bars", nil, "count_color", ".2,1,.8,1") pfUI:UpdateConfig("bars", nil, "count_color", ".2,1,.8,1")
pfUI:UpdateConfig("bars", nil, "bind_size", "8") pfUI:UpdateConfig("bars", nil, "bind_size", "8")
pfUI:UpdateConfig("bars", nil, "bind_color", "1,1,0,1") pfUI:UpdateConfig("bars", nil, "bind_color", "1,1,0,1")
pfUI:UpdateConfig("bars", nil, "cd_size", "12")
pfUI:UpdateConfig("bars", "gryphons", "texture", "None") pfUI:UpdateConfig("bars", "gryphons", "texture", "None")
pfUI:UpdateConfig("bars", "gryphons", "color", ".6,.6,.6,1") pfUI:UpdateConfig("bars", "gryphons", "color", ".6,.6,.6,1")
@@ -759,6 +820,10 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("tooltip", nil, "extguild", "1") pfUI:UpdateConfig("tooltip", nil, "extguild", "1")
pfUI:UpdateConfig("tooltip", nil, "itemid", "0") pfUI:UpdateConfig("tooltip", nil, "itemid", "0")
pfUI:UpdateConfig("tooltip", nil, "movespeed", "0") pfUI:UpdateConfig("tooltip", nil, "movespeed", "0")
pfUI:UpdateConfig("tooltip", nil, "aurasource", "0")
pfUI:UpdateConfig("tooltip", nil, "spellid", "0")
pfUI:UpdateConfig("tooltip", nil, "unitid", "0")
pfUI:UpdateConfig("tooltip", nil, "showbuffs", "0")
pfUI:UpdateConfig("tooltip", nil, "alpha", "0.8") pfUI:UpdateConfig("tooltip", nil, "alpha", "0.8")
pfUI:UpdateConfig("tooltip", nil, "alwaysperc", "0") pfUI:UpdateConfig("tooltip", nil, "alwaysperc", "0")
pfUI:UpdateConfig("tooltip", "compare", "basestats", "1") pfUI:UpdateConfig("tooltip", "compare", "basestats", "1")
@@ -782,13 +847,15 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("chat", "text", "timeformat", "%H:%M:%S") pfUI:UpdateConfig("chat", "text", "timeformat", "%H:%M:%S")
pfUI:UpdateConfig("chat", "text", "timebracket", "[]") pfUI:UpdateConfig("chat", "text", "timebracket", "[]")
pfUI:UpdateConfig("chat", "text", "timecolor", ".8,.8,.8,1") pfUI:UpdateConfig("chat", "text", "timecolor", ".8,.8,.8,1")
pfUI:UpdateConfig("chat", "text", "copytime", "1")
pfUI:UpdateConfig("chat", "text", "tintunknown", "1") pfUI:UpdateConfig("chat", "text", "tintunknown", "1")
pfUI:UpdateConfig("chat", "text", "unknowncolor", ".7,.7,.7,1") pfUI:UpdateConfig("chat", "text", "unknowncolor", ".7,.7,.7,1")
pfUI:UpdateConfig("chat", "text", "channelnumonly", "1") pfUI:UpdateConfig("chat", "text", "channelnumonly", "1")
pfUI:UpdateConfig("chat", "text", "playerlinks", "1") pfUI:UpdateConfig("chat", "text", "playerlinks", "1")
pfUI:UpdateConfig("chat", "text", "detecturl", "1") pfUI:UpdateConfig("chat", "text", "detecturl", "1")
pfUI:UpdateConfig("chat", "text", "classcolor", "1") pfUI:UpdateConfig("chat", "text", "classcolor", "1")
pfUI:UpdateConfig("chat", "text", "whosearchunknown", "0") pfUI:UpdateConfig("chat", "text", "factionicons", "0")
pfUI:UpdateConfig("chat", "text", "raceicons", "0")
pfUI:UpdateConfig("chat", "text", "playerlevel", "0") pfUI:UpdateConfig("chat", "text", "playerlevel", "0")
pfUI:UpdateConfig("chat", "left", "width", "380") pfUI:UpdateConfig("chat", "left", "width", "380")
pfUI:UpdateConfig("chat", "left", "height", "180") pfUI:UpdateConfig("chat", "left", "height", "180")
@@ -900,9 +967,6 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("nameplates", "debuffs", "blacklist", "") pfUI:UpdateConfig("nameplates", "debuffs", "blacklist", "")
pfUI:UpdateConfig("nameplates", "debuffs", "showstacks", "0") pfUI:UpdateConfig("nameplates", "debuffs", "showstacks", "0")
pfUI:UpdateConfig("nameplates", "debuffs", "position", "BOTTOM") pfUI:UpdateConfig("nameplates", "debuffs", "position", "BOTTOM")
pfUI:UpdateConfig("nameplates", nil, "debufftimers", "1")
pfUI:UpdateConfig("nameplates", nil, "debufftext", "1")
pfUI:UpdateConfig("nameplates", nil, "debuffanim", "0")
pfUI:UpdateConfig("abuttons", nil, "enable", "1") pfUI:UpdateConfig("abuttons", nil, "enable", "1")
pfUI:UpdateConfig("abuttons", nil, "position", "bottom") pfUI:UpdateConfig("abuttons", nil, "position", "bottom")
@@ -929,13 +993,20 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("questlog", nil, "showQuestLevels", "0") pfUI:UpdateConfig("questlog", nil, "showQuestLevels", "0")
pfUI:UpdateConfig("character", "inventory", "durability", "1") pfUI:UpdateConfig("character", "inventory", "durability", "1")
pfUI:UpdateConfig("character", "inventory", "equipflyout", "0")
pfUI:UpdateConfig("equipmentmanager", nil, "autoswitch", "1")
pfUI:UpdateConfig("equipmentmanager", nil, "announce", "1")
pfUI:UpdateConfig("equipmentmanager", nil, "unusedquality", "1")
pfUI:UpdateConfig("equipmentmanager", nil, "unusedbank", "1")
pfUI:UpdateConfig("character", "reputation", "repRequired", "1") pfUI:UpdateConfig("character", "reputation", "repRequired", "1")
pfUI:UpdateConfig("radar", nil, "range", "10")
pfUI:UpdateConfig("thirdparty", nil, "chatbg", "1") pfUI:UpdateConfig("thirdparty", nil, "chatbg", "1")
pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0") pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0")
pfUI:UpdateConfig("thirdparty", "dpsmate", "skin", "0") pfUI:UpdateConfig("thirdparty", "dpsmate", "skin", "0")
pfUI:UpdateConfig("thirdparty", "dpsmate", "dock", "0") pfUI:UpdateConfig("thirdparty", "dpsmate", "dock", "0")
pfUI:UpdateConfig("thirdparty", "shagudps", "skin", "0") pfUI:UpdateConfig("thirdparty", "shagudps", "skin", "0")
pfUI:UpdateConfig("thirdparty", "shagudps", "dock", "0") pfUI:UpdateConfig("thirdparty", "shagudps", "dock", "0")
pfUI:UpdateConfig("thirdparty", "greedmeter", "dock", "0")
pfUI:UpdateConfig("thirdparty", "swstats", "skin", "0") pfUI:UpdateConfig("thirdparty", "swstats", "skin", "0")
pfUI:UpdateConfig("thirdparty", "swstats", "dock", "0") pfUI:UpdateConfig("thirdparty", "swstats", "dock", "0")
pfUI:UpdateConfig("thirdparty", "ktm", "skin", "0") pfUI:UpdateConfig("thirdparty", "ktm", "skin", "0")
@@ -1090,25 +1161,6 @@ function pfUI:MigrateConfig()
end end
end end
-- migrating animation_speed (> 3.1.2)
if checkversion(3, 1, 2) then
if tonumber(pfUI_config.unitframes.animation_speed) >= 13 then
pfUI_config.unitframes.animation_speed = "13"
elseif tonumber(pfUI_config.unitframes.animation_speed) >= 8 then
pfUI_config.unitframes.animation_speed = "8"
elseif tonumber(pfUI_config.unitframes.animation_speed) >= 5 then
pfUI_config.unitframes.animation_speed = "5"
elseif tonumber(pfUI_config.unitframes.animation_speed) >= 3 then
pfUI_config.unitframes.animation_speed = "3"
elseif tonumber(pfUI_config.unitframes.animation_speed) >= 2 then
pfUI_config.unitframes.animation_speed = "2"
elseif tonumber(pfUI_config.unitframes.animation_speed) >= 1 then
pfUI_config.unitframes.animation_speed = "1"
else
pfUI_config.unitframes.animation_speed = "5"
end
end
-- migrating legacy buff/debuff naming (> 3.5.0) -- migrating legacy buff/debuff naming (> 3.5.0)
if checkversion(3, 5, 0) then if checkversion(3, 5, 0) then
local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback" } local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback" }
@@ -1314,7 +1366,7 @@ function pfUI:MigrateConfig()
-- migrate buff indicators into seperate options (> 4.6.2) -- migrate buff indicators into seperate options (> 4.6.2)
if checkversion(4, 6, 2) and pfUI_config.unitframes.show_hots then if checkversion(4, 6, 2) and pfUI_config.unitframes.show_hots then
local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback", "tttarget" } local unitframes = { "player", "target", "focus", "group", "grouptarget", "grouppet", "raid", "ttarget", "pet", "ptarget", "fallback", "tttarget" }
local options = { "show_hots", "all_hots", "show_procs", "show_totems", "all_procs", "indicator_time", "indicator_stacks", "indicator_size" } local options = { "show_hots", "all_hots", "show_procs", "show_totems", "all_procs", "indicator_stacks", "indicator_size" }
for _, unitframe in pairs(unitframes) do for _, unitframe in pairs(unitframes) do
for _, option in pairs(options) do for _, option in pairs(options) do
@@ -1361,11 +1413,6 @@ function pfUI:MigrateConfig()
end end
end end
-- migrate cooldown font from unit_font to separate setting
if checkversion(5, 4, 18) then
pfUI_config.appearance.cd.font = pfUI_config.global.font_unit
end
-- migrate combopoint size to separate settings -- migrate combopoint size to separate settings
if checkversion(5, 4, 18) then if checkversion(5, 4, 18) then
if pfUI_config.unitframes.combosize then if pfUI_config.unitframes.combosize then
@@ -1375,6 +1422,80 @@ function pfUI:MigrateConfig()
end end
end end
-- migrate "Always Use 2D Portraits" to the portrait style; keyed on the old
-- setting rather than the version, which dev installs stamp as 999.999.999
if pfUI_config.unitframes.always2dportrait then
if pfUI_config.unitframes.always2dportrait == "1" then
pfUI_config.unitframes.portraitstyle = "2d"
end
pfUI_config.unitframes.always2dportrait = nil
end
-- migrate the scattered cooldown settings into the cooldown table; keyed
-- on the old settings rather than the version, like the portrait style
local cooldown = pfUI_config.cooldown
local cd = pfUI_config.appearance.cd
if cd then
for _, entry in pairs({ "font", "font_size", "dynamicsize", "threshold", "milliseconds",
"lowcolor", "normalcolor", "minutecolor", "hourcolor", "daycolor" }) do
cooldown[entry] = cd[entry] or cooldown[entry]
end
cooldown.foreign.text = cd.foreign or cooldown.foreign.text
if cd.hideanim then
cooldown.foreign.animation = cd.hideanim == "1" and "0" or "1"
end
-- spellbook and character slots took the foreign sweep, and with the
-- Blizzard toggle off the foreign numbers too
cooldown.blizzard.animation = cooldown.foreign.animation
if cd.blizzard == "0" then
cooldown.blizzard.text = cooldown.foreign.text
end
-- pfUI drew its own numbers before; the native countdown shows them
-- only with this cvar on, which only the first-run setup sets
SetCVar("countdownForCooldowns", "1")
pfUI_config.appearance.cd = nil
end
local function move(config, old, kind, entry)
if config[old] then
cooldown[kind][entry] = config[old]
config[old] = nil
end
end
move(pfUI_config.bars, "cooldown_reverse", "actionbar", "reverse")
move(pfUI_config.appearance.bags, "cooldown_reverse", "bags", "reverse")
move(pfUI_config.buffs, "cooldown_anim", "buff", "animation")
move(pfUI_config.buffs, "cooldown_reverse", "buff", "reverse")
move(pfUI_config.totems, "cooldown_reverse", "totem", "reverse")
move(pfUI_config.nameplates, "debufftext", "nameplate", "text")
move(pfUI_config.nameplates, "debuffanim", "nameplate", "animation")
move(pfUI_config.nameplates, "debreverse", "nameplate", "reverse")
if pfUI_config.nameplates.debufftimers == "0" then
cooldown.nameplate.text, cooldown.nameplate.animation = "0", "0"
end
-- one setting now covers every unit frame: the target frame's auras and
-- the raid frames' indicators stand for the rest
move(pfUI_config.unitframes.target, "cooldown_text", "unitframe", "text")
move(pfUI_config.unitframes.target, "cooldown_anim", "unitframe", "animation")
move(pfUI_config.unitframes.target, "cooldown_reverse", "unitframe", "reverse")
move(pfUI_config.unitframes.raid, "indicator_time", "indicator", "text")
for _, unit in pairs(pfUI_config.unitframes) do
if type(unit) == "table" then
unit.cooldown_text, unit.cooldown_anim, unit.cooldown_reverse, unit.indicator_time = nil, nil, nil, nil
end
end
pfUI_config.nameplates.debufftimers = nil
pfUI_config.bars.cd_size = nil
-- Remove "Show only own debuffs" from unitframes and nameplates -- Remove "Show only own debuffs" from unitframes and nameplates
-- (feature was removed; only Target Debuff Bar in buffwatch keeps it) -- (feature was removed; only Target Debuff Bar in buffwatch keeps it)
if pfUI_config.nameplates then if pfUI_config.nameplates then
+194
View File
@@ -0,0 +1,194 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
-- Every pfUI cooldown is a Cooldown frame from CreateCooldown, made for one
-- kind of timer. Settings -> Cooldown (C.cooldown) sets for each kind its
-- countdown numbers, its sweep and the sweep's direction, and shares one font
-- and one formatter between them all. The numbers are the frame's own
-- countdown (ClassicAPI): the engine ticks them, gated by the
-- countdownForCooldowns cvar. Other addons' Cooldown frames take the
-- "foreign" settings as their timers start.
-- kinds that time spells or items: no numbers for the global cooldown
local spell = { actionbar = true, bags = true, blizzard = true, foreign = true }
-- every cooldown CreateCooldown made, for UpdateCooldowns
local cooldowns = {}
local function ColorCode(color)
local r, g, b = pfUI.api.GetStringColor(color)
return pfUI.api.rgbhex(r, g, b)
end
-- The formatter behind every pfUI time: the number in its unit's color,
-- rounded up, with a unit (m/h/d) once the unit below passes 99. Cooldown
-- frames share it instead of copying it, so new breakpoints reach every
-- countdown on its next update.
local formatter
local function UpdateFormatter()
local up = Enum.NumericRuleFormatRounding.Up
local tenths = C.cooldown.milliseconds == "1"
formatter:SetBreakpoints({
{ threshold = 0, step = tenths and .1 or 1, rounding = up, format = ColorCode(C.cooldown.lowcolor) .. (tenths and "%.1f" or "%d") .. "|r" },
{ threshold = 5, step = 1, rounding = up, format = ColorCode(C.cooldown.normalcolor) .. "%d|r" },
{ threshold = 99, format = ColorCode(C.cooldown.minutecolor) .. "%d|rm", components = { { div = 60, step = 1, rounding = up } } },
{ threshold = 5940, format = ColorCode(C.cooldown.hourcolor) .. "%d|rh", components = { { div = 3600, step = 1, rounding = up } } },
{ threshold = 356400, format = ColorCode(C.cooldown.daycolor) .. "%d|rd", components = { { div = 86400, step = 1, rounding = up } } },
})
end
local function GetFormatter()
if not formatter then
formatter = C_StringUtil.CreateNumericRuleFormatter()
UpdateFormatter()
end
return formatter
end
-- [ GetCooldownFontSize ] --
-- 'height' [number] the height of the frame the numbers sit on
-- return [number] the font size of cooldown numbers on that frame
function pfUI.api.GetCooldownFontSize(height)
local size = tonumber(C.cooldown.font_size)
if C.cooldown.dynamicsize == "1" and height > 0 then
size = math.max(height * .64, size)
end
return size
end
-- sizes the numbers to the cooldown's parent; the size follows its height,
-- so a timer start calls this again whenever that height changed
local function UpdateFont(cooldown)
local height = (cooldown:GetParent() or cooldown):GetHeight()
cooldown.pfCountdownHeight = height
cooldown:GetCountdownFontString():SetFont(pfUI.media[C.cooldown.font], pfUI.api.GetCooldownFontSize(height), "OUTLINE")
end
-- applies the settings of its kind to one of pfUI's cooldowns
local function SetupCooldown(cooldown)
local kind = cooldown.pfCooldownKind
local config = C.cooldown[kind]
local sweep = config.animation == "1" and not cooldown.pfTimeLeftOnly
cooldown:SetHideCountdownNumbers(config.text ~= "1")
cooldown:SetDrawSwipe(sweep)
cooldown:SetDrawBling(sweep)
cooldown:SetReverse(config.reverse == "1")
cooldown:SetMinimumCountdownDuration(spell[kind] and tonumber(C.cooldown.threshold) * 1000 or 0)
cooldown:SetCountdownFormatter(GetFormatter())
UpdateFont(cooldown)
end
-- applies the "foreign" settings to another addon's cooldown. They only take
-- the numbers or the sweep away, which the addon may have set up itself, so
-- turning one back on needs a reload.
local function SetupForeign(cooldown)
local config = C.cooldown.foreign
if config.animation ~= "1" then
cooldown:SetDrawSwipe(false)
cooldown:SetDrawBling(false)
end
-- omnicc's flag for cooldowns that want no numbers
if config.text ~= "1" or cooldown.noCooldownCount then
cooldown:SetHideCountdownNumbers(true)
return
end
cooldown:SetMinimumCountdownDuration(tonumber(C.cooldown.threshold) * 1000)
cooldown:SetCountdownFormatter(GetFormatter())
UpdateFont(cooldown)
end
-- runs as a pfUI cooldown's timer starts: a timer with a total brings back
-- the sweep a time-left-only one took away, and the font follows a changed
-- height
local function StartTimer(cooldown, timeleftOnly)
if cooldown.pfTimeLeftOnly ~= timeleftOnly then
cooldown.pfTimeLeftOnly = timeleftOnly
SetupCooldown(cooldown)
elseif cooldown:GetParent():GetHeight() ~= cooldown.pfCountdownHeight then
UpdateFont(cooldown)
end
end
-- every timer, pfUI's or another addon's, Cooldown frame or 1.12 indicator
-- Model, is started through CooldownFrame_SetTimer
hooksecurefunc("CooldownFrame_SetTimer", function(cooldown)
-- the Models have no numbers and keep the stock timer
if not cooldown:IsObjectType("Cooldown") then return end
if cooldown.pfCooldownKind then
StartTimer(cooldown, nil)
else
SetupForeign(cooldown)
end
end)
-- [ CreateCooldown ] --
-- Creates one of pfUI's cooldowns: a Cooldown frame over all of 'parent'
-- with the settings of its kind. Start it with CooldownFrame_SetTimer.
-- 'parent' [frame] the frame the cooldown covers
-- 'kind' [string] what it times, a group of C.cooldown: actionbar,
-- bags, blizzard, unitframe, indicator, nameplate,
-- buff, tooltip, totem or lossofcontrol
-- 'name' [string] optional frame name
-- return [frame] the Cooldown frame
function pfUI.api.CreateCooldown(parent, kind, name)
local cooldown = CreateFrame("Cooldown", name, parent, "CooldownFrameTemplate")
cooldown.pfCooldownKind = kind
table.insert(cooldowns, cooldown)
SetupCooldown(cooldown)
return cooldown
end
-- [ SetCooldownTimeLeft ] --
-- Starts a cooldown from its time left alone, for timers that report no
-- total (weapon enchants): the numbers show, the sweep stays off until a
-- timer with a total starts.
-- 'cooldown' [frame] a cooldown from CreateCooldown
-- 'timeleft' [number] the seconds left
function pfUI.api.SetCooldownTimeLeft(cooldown, timeleft)
StartTimer(cooldown, true)
cooldown:SetCooldown(GetTime(), timeleft)
end
-- [ UpdateCooldowns ] --
-- Applies changed cooldown settings to every pfUI cooldown.
function pfUI.api.UpdateCooldowns()
if formatter then UpdateFormatter() end
for _, cooldown in ipairs(cooldowns) do
SetupCooldown(cooldown)
end
end
-- [ GetAuraTimer ] --
-- The cooldown start and duration of an aura from C_UnitAuras, 0, 0 when it
-- has none. Talent-extended auras run past their Spell.dbc base duration, and
-- a start in the future would hold the timer until then, so the start is
-- capped to now.
-- 'duration' [number] the aura's duration
-- 'expirationTime' [number] the aura's expiration time
-- return [number] start, duration
function pfUI.api.GetAuraTimer(duration, expirationTime)
if expirationTime <= 0 then return 0, 0 end
local now = GetTime()
local start, dur = expirationTime - duration, duration
if start > now or dur <= 0 then
start, dur = now, expirationTime - now
end
if dur <= 0 then return 0, 0 end
return start, dur
end
-- [ GetColoredTimeString ] --
-- 'remaining' [number] the time in seconds that should be converted
-- return [string] the time as cooldown numbers show it
function pfUI.api.GetColoredTimeString(remaining)
return GetFormatter():FormatNumber(remaining)
end
+585 -724
View File
File diff suppressed because it is too large Load Diff
+153
View File
@@ -0,0 +1,153 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/">
<!--
pfUI's scroll bar for ClassicAPI's ScrollBox: a thin track with a flat
thumb. ScrollBarMixin needs Back and Forward steppers, so they exist but
stay hidden. Hook it up with ScrollUtil.InitScrollBoxListWithScrollBar.
-->
<EventFrame name="pfUIScrollBarTemplate" inherits="VerticalScrollBarTemplate" virtual="true">
<Size x="7"/>
<KeyValues>
<KeyValue key="hideIfUnscrollable" value="true" type="boolean"/>
</KeyValues>
<Frames>
<Frame parentKey="Track" setAllPoints="true" enableMouse="true">
<Frames>
<EventButton parentKey="Thumb">
<Size x="7"/>
<Layers>
<Layer level="ARTWORK">
<Texture setAllPoints="true">
<Color r=".3" g="1" b=".8" a=".5"/>
</Texture>
</Layer>
</Layers>
</EventButton>
</Frames>
</Frame>
<EventButton parentKey="Back" hidden="true"/>
<EventButton parentKey="Forward" hidden="true"/>
</Frames>
</EventFrame>
<!--
A ScrollFrame for free-form content, with pfUIScrollBarTemplate inside its
right edge. Put the content in frame.Content, which spans the frame: the
engine measures the scroll range from the shown frames inside it, so the
content needs no height. Changes inside it are not measured until
frame:UpdateScrollChildRect().
-->
<ScrollFrame name="pfUIScrollFrameTemplate" virtual="true">
<Frames>
<EventFrame parentKey="ScrollBar" inherits="pfUIScrollBarTemplate">
<Anchors>
<Anchor point="TOPRIGHT"/>
<Anchor point="BOTTOMRIGHT"/>
</Anchors>
</EventFrame>
</Frames>
<ScrollChild>
<Frame parentKey="Content">
<Size x="1" y="1"/>
</Frame>
</ScrollChild>
<Scripts>
<OnLoad>
self.Content:SetAllPoints()
self:EnableMouseWheel(true)
ScrollUtil.InitScrollFrameWithScrollBar(self, self.ScrollBar)
</OnLoad>
</Scripts>
</ScrollFrame>
<!--
A WowScrollBoxList with pfUIScrollBarTemplate beside it, both 5px inside the
frame so CreateBackdrop(frame, nil, true) can frame them. Fill it with
ScrollUtil.InitScrollBoxListWithScrollBar(frame.ScrollBox, frame.ScrollBar, view).
-->
<Frame name="pfUIScrollBoxListTemplate" virtual="true">
<Frames>
<EventFrame parentKey="ScrollBar" inherits="pfUIScrollBarTemplate">
<Anchors>
<Anchor point="TOPRIGHT" x="-5" y="-5"/>
<Anchor point="BOTTOMRIGHT" x="-5" y="5"/>
</Anchors>
</EventFrame>
<Frame parentKey="ScrollBox" inherits="WowScrollBoxList">
<Anchors>
<Anchor point="TOPLEFT" x="5" y="-5"/>
<Anchor point="BOTTOMRIGHT" relativeKey="$parent.ScrollBar" relativePoint="BOTTOMLEFT"/>
</Anchors>
</Frame>
</Frames>
</Frame>
<!--
ClassicAPI's ScrollingEditBoxTemplate with pfUIScrollBarTemplate beside the
text. The frame needs a name: SetFont(font, size, flags) names its font
object after it.
-->
<Frame name="pfUIScrollingEditBoxTemplate" inherits="ScrollingEditBoxTemplate" mixin="pfUIScrollingEditBoxMixin" virtual="true">
<KeyValues>
<KeyValue key="maxLetters" value="0" type="number"/>
</KeyValues>
<Frames>
<EventFrame parentKey="ScrollBar" inherits="pfUIScrollBarTemplate">
<Anchors>
<Anchor point="TOPRIGHT"/>
<Anchor point="BOTTOMRIGHT"/>
</Anchors>
</EventFrame>
</Frames>
<Scripts>
<OnLoad method="InitScrollBar" inherit="prepend"/>
</Scripts>
</Frame>
<!--
A ClassicAPI dropdown in pfUI's style: the selection as right-aligned text
and pfUI's arrow box at the right. Its menu takes pfUIMenuStyleMixin. Fill it
with dropdown:SetupMenu(function(dropdown, rootDescription) ... end), and call
dropdown:GenerateMenu() when the data behind the selection changes.
-->
<DropdownButton name="pfUIDropdownTemplate" mixin="pfUIDropdownMixin" virtual="true">
<Size y="20"/>
<KeyValues>
<KeyValue key="menuMixin" value="pfUIMenuStyleMixin" type="global"/>
<KeyValue key="menuPointY" value="-2" type="number"/>
</KeyValues>
<Frames>
<Frame parentKey="Arrow">
<Size x="16" y="16"/>
<Anchors>
<Anchor point="RIGHT" x="-2"/>
</Anchors>
<Layers>
<Layer level="ARTWORK">
<Texture parentKey="Icon">
<Anchors>
<Anchor point="TOPLEFT" x="3" y="-3"/>
<Anchor point="BOTTOMRIGHT" x="-3" y="3"/>
</Anchors>
</Texture>
</Layer>
</Layers>
</Frame>
</Frames>
<Layers>
<Layer level="OVERLAY">
<FontString parentKey="Text" inherits="GameFontWhite" wordwrap="false" justifyH="RIGHT">
<Anchors>
<Anchor point="LEFT" x="2"/>
<Anchor point="RIGHT" relativeKey="$parent.Arrow" relativePoint="LEFT" x="-4"/>
</Anchors>
</FontString>
</Layer>
</Layers>
<Scripts>
<OnLoad method="OnLoad"/>
<OnShow method="OnShow"/>
<OnEnter method="OnEnter"/>
<OnLeave method="OnLeave"/>
</Scripts>
</DropdownButton>
</Ui>
+1061 -1285
View File
File diff suppressed because it is too large Load Diff
-53
View File
@@ -1,53 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
-- [[ Constants ]]--
EVENTS_MINIMAP_ZONE_UPDATE = {"PLAYER_ENTERING_WORLD", "MINIMAP_ZONE_CHANGED"}
MICRO_BUTTONS = {
'CharacterMicroButton', 'SpellbookMicroButton', 'TalentMicroButton',
'QuestLogMicroButton', 'SocialsMicroButton', 'WorldMapMicroButton',
'MainMenuMicroButton', 'HelpMicroButton',
}
NAMEPLATE_OBJECTORDER = { "border", "glow", "name", "level", "levelicon", "raidicon" }
NAMEPLATE_FRAMETYPE = "Button"
MINIMAP_TRACKING_FRAME = _G.MiniMapTrackingFrame
FRIENDS_NAME_LOCATION = "ButtonTextNameLocation"
COOLDOWN_FRAME_TYPE = "Model"
LOOT_BUTTON_FRAME_TYPE = "LootButton"
PLAYER_BUFF_START_ID = -1
ACTIONBAR_SECURE_TEMPLATE_BAR = nil
ACTIONBAR_SECURE_TEMPLATE_BUTTON = nil
UNITFRAME_SECURE_TEMPLATE = nil
--[[ Vanilla API Extensions ]]--
do -- GetItemInfo
local name, link, rarity, minlevel, itype, isubtype, stack
function GetItemInfo(item)
if not item then return end
name, link, rarity, minlevel, itype, isubtype, stack = _G.GetItemInfo(item)
return name, link, rarity, nil, minlevel, itype, isubtype, stack
end
end
do -- RunMacroText
local obj = { ["GetText"] = function(self) return self.text end }
obj = setmetatable(obj, {__index = function(tab,key)
local value = function() return end
rawset(tab,key,value)
return value
end})
function RunMacroText(text)
obj.text = text
ChatEdit_ParseText(obj, 1)
end
end
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (DE) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["deDE"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "verletzt",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%2$s von %1$s reflektiert %9$s %7$s auf %4$s.%6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s reflektiert %9$s %7$s auf %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED = "verfehlt",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "(Geblockt)",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%4$s blockt %2$s von %1$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s blockt %2$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(Abgewehrt)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%4$s wehrt %2$s von %1$s ab.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s wehrt %2$s ab.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "(Ausgewichen)",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%4$s weicht %2$s von %1$s aus.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s weicht %2$s aus.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(Entkommen)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%4$s entkommt %2$s von %1$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%4$s entkommt %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%1$s wirkt %2$s auf %4$s an und verfehlt.",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "(Immun)",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%2$s von %1$s schlägt fehl. %4$s ist immun.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s schlägt fehl. %4$s ist immun.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(Verfehlt)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%1$s wirkt %2$s auf %4$s und verfehlt.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "(Pariert)",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%1$s pariert %2$s von %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s pariert %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "(Widerstanden)",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%4$s widersteht %2$s von %1$s vollständig.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s widersteht %2$s vollständig.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "teilt Schaden",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%2$s von %1$s wurde durch %6$s von %4$s absorbiert.",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%2$s von %1$s verursacht bei %4$s %9$s.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%2$s von %1$s fügt %6$s von %4$s %9$s Schaden zu.",
ACTION_ENCHANT_APPLIED = "verzaubert",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s wirkt %2$s auf %5$s von %4$s.",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "Verzauberung schwindet",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%2$s auf %5$s von %4$s schwindet.",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "verletzt",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "Ertrinken",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s ertrinkt und verliert %9$s Gesundheit.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "Sturz",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s stürzt und verliert %9$s Gesundheit.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "Erschöpfung",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s ist erschöpft und verliert %9$s Gesundheit.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "Feuer",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s erleidet %9$s Feuerschaden.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s verliert durch Umgebungsschaden %9$s Gesundheit.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "Lava",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s verliert durch das Schwimmen in Lava %9$s Gesundheit. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "Schleim",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s verliert durch das Schwimmen in Schleim %9$s Gesundheit. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "besiegt",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s besiegt %4$s!",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "umgehauen",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "%1$s hat %4$s umgehauen!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "Schuss",
ACTION_RANGE_DAMAGE = "trifft",
ACTION_RANGE_DAMAGE_FULL_TEXT = "%1$s schießt auf %4$s, verursacht %5$s.%6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "Ein Distanzangriff trifft %4$s, verursacht %5$s.%6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "verfehlt",
ACTION_RANGE_MISSED_ABSORB = "(Absorbiert)",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%4$s absorbiert den Schuss von %1$s.%6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "(Geblockt)",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%4$s blockt den Schuss von %1$s.%6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(Abgewehrt)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%4$s wehrt den Schuss von %1$s ab.",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "(Ausgewichen)",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%4$s weicht dem Schuss von %1$s aus.",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(Entkommen)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "%4$s entkommt dem Schuss von %1$s.",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "%1$s schießt auf %4$s und verfehlt.",
ACTION_RANGE_MISSED_IMMUNE = "(Immun)",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "Der Schuss von %1$s schlägt fehl. %4$s ist immun.",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(Verfehlt)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "%1$s schießt auf %4$s und verfehlt.",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(Verfehlt)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "%1$s schießt auf %4$s und verfehlt.",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "(Pariert)",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%4$s pariert den Schuss von %1$s.",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "(Widerstanden)",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%4$s widersteht dem Schuss von %1$s vollständig.%6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "wirkt",
ACTION_SPELL_AURA_APPLIED_BUFF = "wirkt",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s gewinnt %1$s %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gewinnt %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s gewinnt %1$s %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s gewinnt %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "beeinträchtigt",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s wird durch %2$s von %1$s beeinträchtigt.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s wird von %2$s beeinträchtigt.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s wird durch %2$s von %1$s beeinträchtigt. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s wird von %2$s beeinträchtigt. %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "Stapel",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "Stapel",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s gewinnt %1$s %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s erhält %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "peinigt",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s wird durch %2$s von %1$s beeinträchtigt. (%9$s)",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s wird von %2$s beeinträchtigt (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "bricht",
ACTION_SPELL_AURA_BROKEN_BUFF = "bricht",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%2$s von %4$s wird durch %1$s gebrochen.",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s von %1$s wird durch jemanden gebrochen.",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "bricht",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%2$s von %4$s wird durch %1$s gebrochen.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s von %1$s wurde durch jemanden gebrochen.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "bricht",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s bricht %2$s von %4$s durch %5$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s bricht %2$s von %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "bricht",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s bricht %2$s von %4$s durch %5$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s bricht %2$s von %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "aufgefrischt",
ACTION_SPELL_AURA_REFRESH_BUFF = "aufgefrischt",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s wird aufgefrischt.",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s wird aufgefrischt.",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s wird aufgefrischt. %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s wird aufgefrischt. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "aufgefrischt",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s wird aufgefrischt.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s wird aufgefrischt.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s wird aufgefrischt. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s wird aufgefrischt. %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "entfernt",
ACTION_SPELL_AURA_REMOVED_BUFF = "schwindet",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s schwindet.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s schwindet.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s schwindet. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s schwindet. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "erlischt",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s erlischt.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s erlischt.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s erlischt. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s erlischt. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "verringert",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "verringert",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%2$s von %1$s lässt nach. (%9$s)",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) lässt nach.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "lässt nach",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%2$s von %1$s nimmt ab. (%9$s)",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) nimmt ab.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "Das auf %4$s wirkende %2$s von %1$s wird entfernt.",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "Das auf %4$s wirkende %2$s von %1$s wird entfernt.",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "trifft",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%2$s von %1$s trifft %4$s für %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s trifft %4$s für %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "repariert",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%2$s von %1$s repariert %4$s für %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s repariert %4$s für %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "schlägt fehl",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%1$s kann %2$s nicht wirken.%6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "initiiert",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s beginnt, %2$s auf %4$s zu wirken.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s beginnt, %2$s zu wirken.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "Etwas beginnt, %2$s auf %4$s zu wirken.",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "wirkt",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s wirkt %2$s auf %4$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s wirkt %2$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "Etwas wirkt %2$s auf %4$s.",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "erschafft",
ACTION_SPELL_CREATE_FULL_TEXT = "%4$s wird von %1$s durch %2$s erschaffen.%6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%4$s wird durch %2$s erschaffen.%6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "trifft",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%1$s trifft %4$s mit %2$s für %5$s.%6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s trifft %4$s für %5$s.%6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "bannt",
ACTION_SPELL_DISPEL_BUFF = "bannt",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%5$s auf %4$s wird von %1$s durch %2$s gebannt.",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s auf %4$s wird durch %2$s gebannt.",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "läutert",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%5$s auf %4$s wird von %1$s durch %2$s geläutert.",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s auf %4$s wird durch %2$s geläutert.",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "Magiebannung schlägt fehl",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%2$s von %1$s kann %5$s auf %4$s nicht bannen.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s kann %5$s auf %4$s nicht bannen.",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "entzieht",
ACTION_SPELL_DRAIN_FULL_TEXT = "%1$s entzieht von %4$s durch %2$s %9$s %8$s.",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = " %2$s entzieht von %4$s %9$s %8$s.",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "Haltbarkeitsverlust",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "kompletter Haltbarkeitsverlust",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%2$s von %1$s trifft %4$s: Alle Gegenstände beschädigt.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%2$s von %1$s trifft %4$s: %5$s beschädigt.",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "aufgeladen",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s gewinnt durch %2$s von %1$s %9$s %8$s.",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gewinnt durch %2$s %9$s %8$s.",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "%9$s %8$s gewonnen.",
ACTION_SPELL_EXTRA_ATTACKS = "gewährt zusätzliche Angriffe",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s werden durch %2$s %9$s zusätzliche Angriffe gewährt.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "%2$s gewährt %9$s zusätzliche Angriffe.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "heilt",
ACTION_SPELL_HEAL_FULL_TEXT = "%2$s von %1$s heilt %4$s um %9$s.%6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s heilt %4$s um %9$s.%6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "besiegt",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%1$s besiegt %4$s durch %2$s sofort.",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s besiegt %4$s sofort.",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "umgehauen",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s haut %4$s um.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s haut %4$s um.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "unterbricht",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%1$s unterbricht %4$s durch %2$s beim Wirken von %5$s.",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s unterbricht %4$s beim Wirken von %5$s.",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "entzieht",
ACTION_SPELL_LEECH_FULL_TEXT = "%1$s entzieht durch %2$s %9$s %8$s von %4$s. %1$s gewinnt %10$s %8$s.",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s entzieht %4$s %9$s %8$s.",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "%10$s %8$s gewonnen",
ACTION_SPELL_MISSED = "verfehlt",
ACTION_SPELL_MISSED_ABSORB = "Absorbiert",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%4$s absorbiert %2$s von %1$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%4$s absorbiert %2$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "Geblockt",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%4$s blockt %2$s von %1$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s blockt %2$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "Abgewehrt",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%4$s wehrt %2$s von %1$s ab.",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s wehrt %2$s ab.",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "Ausgewichen",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%4$s weicht %2$s von %1$s aus.",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s weicht %2$s aus.",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "Entkommen",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%4$s entkommt %2$s von %1$s.",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%4$s entkommt %2$s.",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%1$s wirkt %2$s auf %4$s und verfehlt.",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s.",
ACTION_SPELL_MISSED_IMMUNE = "Immun",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%2$s von %1$s schlägt fehl. %4$s ist immun.",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s schlägt fehl. %4$s ist immun.",
ACTION_SPELL_MISSED_MISFIRE = "Verfehlt",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%1$s wirkt %2$s auf %4$s und verfehlt.",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s.",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "Verfehlt",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%1$s wirkt %2$s auf %4$s und verfehlt.",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s.",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "Pariert",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%4$s pariert %2$s von %1$s.",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s pariert %2$s.",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "Reflektiert",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%2$s von %1$s wird durch %4$s reflektiert.",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%2$s wird durch %4$s reflektiert.",
ACTION_SPELL_MISSED_RESIST = "Widerstanden",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%4$s widersteht %2$s von %1$s vollständig.%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s widersteht %2$s vollständig.%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "verletzt",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s erleidet durch %2$s von %1$s %5$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s erleidet durch %2$s %5$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "entzieht",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%1$s entzieht durch %2$s %9$s %8$s von %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s entzieht %4$s %9$s %8$s.",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "aufgeladen",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s gewinnt durch %2$s von %1$s %9$s %8$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gewinnt durch %2$s %9$s %8$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "$extraAmount %8$s gewonnen.",
ACTION_SPELL_PERIODIC_HEAL = "heilt",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s gewinnt durch %2$s von %1$s %9$s Gesundheit.%6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s gewinnt durch %2$s %9$s Gesundheit.%6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "entzieht",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%1$s entzieht durch %2$s %9$s %8$s von %4$s. %1$s gewinnt %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s entzieht %9$s %8$s von %4$s. %1$s gewinnt %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(%10$s %8$s gewonnen)",
ACTION_SPELL_PERIODIC_MISSED = "verfehlt",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s absorbiert)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%2$s von %1$s wurde durch %4$s absorbiert.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s wurde durch %4$s absorbiert.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "(Tick geblockt)",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%4$s blockt %2$s von %1$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s blockt %2$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(Tick abgewehrt)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%4$s wehrt %2$s von %1$s für einen Moment ab.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%4$s wehrt %2$s für einen Moment ab.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "(Tick ausgewichen)",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%4$s weicht %2$s von %1$s für einen Moment aus.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s weicht %2$s für einen Moment aus.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(Tick entkommen)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%4$s entkommt %2$s von %1$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%4$s entkommt %2$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%2$s von %1$s verfehlt %4$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "(Immun)",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s ist gegen %2$s von %1$s immun.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s ist gegen %2$s immun.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "(Tick verfehlt)",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "%2$s von %1$s verfehlt %4$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s verfehlt %4$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "(Tick pariert)",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%4$s pariert %2$s von %1$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s pariert %2$s für einen Moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "(Tick widerstanden)",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%4$s wird nicht vom Effekt %2$s von %1$s betroffen. %4$s hat widerstanden.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s wird nicht vom Effekt %2$s betroffen. %4$s hat widerstanden.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "wiederbelebt",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%2$s von %1$s belebt %4$s wieder.%6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s belebt %4$s wieder.%6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "stiehlt",
ACTION_SPELL_STOLEN_BUFF = "stiehlt",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%2$s von %1$s stiehlt %5$s auf %4$s.",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s stiehlt %5$s auf %4$s.",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "stiehlt",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%1$s überträgt durch %2$s den auf %4$s wirkenden Zauber $extraSpell zu %1$s.",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s überträgt $extraSpell von %4$s.",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%2$s von %1$s stiehlt %5$s auf %4$s.",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s stiehlt %5$s auf %4$s.",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "beschwört",
ACTION_SPELL_SUMMON_FULL_TEXT = "%1$s ruft durch %2$s %4$s herbei.%6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s ruft %4$s herbei.%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "Schlag",
ACTION_SWING_DAMAGE = "trifft",
ACTION_SWING_DAMAGE_FULL_TEXT = "%1$s schlägt %4$s im Nahkampf, verursacht %5$s.%6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "Ein Nahkampfschlag trifft %4$s, verursacht %5$s.%6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "verfehlt",
ACTION_SWING_MISSED_ABSORB = "(Absorbiert)",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%4$s absorbiert den Angriff von %1$s.%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "(Geblockt)",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%4$s blockt den Angriff von %1$s.%6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(Abgewehrt)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%4$s wehrt den Angriff von %1$s ab.",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "(Ausgewichen)",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%4$s weicht dem Angriff von %1$s aus.",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(Entkommen)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "%4$s entkommt dem Angriff von %1$s.",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "%1$s greift %4$s an und verfehlt.",
ACTION_SWING_MISSED_IMMUNE = "(Immun)",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "Der Angriff von %1$s schlägt fehl. %4$s ist immun.",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(Verfehlt)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "Der Angriff von %1$s verfehlt %4$s.",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(Verfehlt)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "%1$s greift %4$s an und verfehlt.",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "(Pariert)",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%4$s pariert den Angriff von %1$s.",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "(Widerstanden)",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%4$s widersteht dem Angriff von %1$s vollständig.%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "bricht zusammen",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s bricht zusammen.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "zerstört",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s wird zerstört.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "stirbt",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s stirbt.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "schwindet",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s schwindet.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "Hinzufügen",
ADDITIONAL_FILTERS = "Zusätzliche Filter",
ADD_FILTER = "Filter hinz.",
AURAS = "Auren",
AURAS_COMBATLOG_TOOLTIP = "Zeigt Nachrichten über vorteilhafte und schädliche Statuseffekte an.",
BENEFICIAL = "Vorteilhaft",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "Anzeigen, wenn Ihr eine vorteilhafte Aura erhaltet oder verliert.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "Alles anzeigen, das %s betrifft?",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "Alles anzeigen",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "Was ist mit %s geschehen?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "Anzeigen, was %s tat?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "Was hat %s mit mir getan?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "Rücksetzen",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "Als neuen Filter speichern",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "Nachrichten wie diese ausblenden.",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "%s zum Chat verlinken.",
BY_SOURCE = "Nach Quelle",
BY_SOURCE_COMBATLOG_TOOLTIP = "Zeilenfarbe basierend auf dem Zaubernden.",
BY_TARGET = "Nach Ziel",
BY_TARGET_COMBATLOG_TOOLTIP = "Zeilenfarbe basierend auf dem Ziel.",
COLORIZE = "Einfärben:",
COLORS = "Farben",
COLOR_BY_SCHOOL = "Farbe nach Art",
COMBATLOG_DEFAULTS = "Kampflog: Standard",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "Benutzerdefinierte Einheit",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "Freundliche Einheiten",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "Gegnerische Spieler",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "Feindliche Einheiten",
COMBATLOG_FILTER_STRING_ME = "Spieler",
COMBATLOG_FILTER_STRING_MY_PET = "Begleiter",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "Neutrale Einheiten",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "Unbekannt",
COMBATLOG_HIGHLIGHT_ABILITY = "Fähigkeit",
COMBATLOG_HIGHLIGHT_DAMAGE = "Schaden",
COMBATLOG_HIGHLIGHT_KILL = "Sieg",
COMBATLOG_HIGHLIGHT_SCHOOL = "Magieart",
COMBATLOG_UNKNOWN_UNIT = "Etwas",
COMBAT_FACTION_CHANGE = "Ruf",
COMBAT_HONOR_GAIN = "Ehre",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "Versch. Infos",
COMBAT_XP_GAIN = "Erfahrung",
CONFIRM_COMBAT_FILTER_DEFAULTS = "Wollt Ihr Eure Filter wirklich auf die Standardeinstellungen zurücksetzen?",
CONFIRM_COMBAT_FILTER_DELETE = "Wollt Ihr diesen Filter wirklich löschen?",
COPY_FILTER = "Filter kop.",
DAMAGE_NUMBER = "Schadenszahl",
DAMAGE_SCHOOL_TEXT = "Schadensart",
DAMAGE_SHIELD = "Schadensschilde",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit als Reaktion auf einen Nahkampfangriff Schaden verursacht, z.B. Dornen.",
DEATHS_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn etwas stirbt.",
DEFAULT_COMBATLOG_FILTER_NAME = "Filter %d",
DISPELS = "Bannungen",
DISPEL_AURA_COMBATLOG_TOOLTIP = "Anzeigen, wenn eine Aura entfernt, unterbrochen oder gestohlen wird.",
DONE_BY = "Aktion von:",
DONE_TO = "Aktion auf:",
DRAINS = "Entzüge",
ENTER_FILTER_NAME = "Filternamen eingeben:",
ENTIRE_LINE = "Gesamte Zeile",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "Die gesamte Zeile basierend auf der unteren Auswahl einfärben.",
ENVIRONMENTAL_DAMAGE = "Umgebungsschaden",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn jemand Schaden durch Stürze, durch Ertrinken oder das Schwimmen in Lava erhält.",
EXAMPLE_SPELL_FIREBALL = "Feuerball",
EXAMPLE_SPELL_FROSTBOLT = "Frostblitz",
EXAMPLE_TARGET_MONSTER = "Monster",
EXAMPLE_TEXT = "Beispieltext:",
EXTRA_ATTACKS = "Zusatzangriffe",
FAILURES = "Fehlschläge",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "Aktionen, die von feindlichen Kreaturen und Begleitern durchgeführt werden.",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "Aktionen, die von freundlichen Spielern, Begleitern und Kreaturen durchgeführt werden.",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Aktionen, die von feindlichen Spielern durchgeführt werden.",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "Aktionen, die von Euch, Euren Fallen und Euren Zaubern durchgeführt werden.",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "Aktionen, die von neutralen Kreaturen durchgeführt werden.",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "Aktionen, die von Euren Begleitern, beschworenen Wächtern oder von Euch bezauberten Spielern durchgeführt werden.",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "Aktionen, die von unbestimmten Quellen durchgeführt werden, so wie Sturz, Säure oder Lava.",
FILTER_NAME = "Filtername",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "Aktionen, die auf freundliche Spieler, Begleiter und Kreaturen durchgeführt werden.",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "Aktionen, die auf feindliche Begleiter und Kreaturen durchgeführt werden.",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Aktionen, die auf gegnerische Spieler durchgeführt werden.",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "Aktionen, die auf Euch durchgeführt werden.",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "Aktionen, die auf neutrale Kreaturen durchgeführt werden.",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "Aktionen, die auf Eure Begleiter, beschworene Wächter oder von Euch bezauberte Spieler durchgeführt werden.",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "Aktionen, die auf unsichtbare Ziele durchgeführt werden.",
FORMATTING = "Format",
FULL_TEXT_COMBATLOG_TOOLTIP = "Kampflogeinträge als vollständige Sätze anzeigen.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "Anzeigen, wenn Ihr eine schädliche Aura erhaltet oder verliert.",
HEALS = "Heilungen",
HIGHLIGHTING = "Hervorhebung:",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "Hebt in den Kampfnachrichten die Namen von Fähigkeiten hervor.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "Hebt in den Kampfnachrichten die Schadenszahlen hervor.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "Hebt die gesamte Zeile hervor, wenn Ihr oder ein Mitglied Eurer Gruppe einen Feind besiegt.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "Hebt in den Kampfnachrichten die Zauberarten hervor.",
HOSTILE = "Feindlich",
INTERRUPTS = "Unterbrechungen",
ITEM_NAMES = "Gegenstandsnamen",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Klammern um Namen von Gegenständen anzeigen.",
KILLS_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Mitglied Eurer Gruppe etwas tötet.",
MELEE = "Nahkampf",
MELEE_COMBATLOG_TOOLTIP = "Zeigt gewöhnliche Nahkampfangriffe an.",
MESSAGE_SOURCES = "Nachrichtenquellen",
MISSES = "Verfehlen",
MOVE_FILTER_DOWN = "Filter nach unten",
MOVE_FILTER_UP = "Filter nach oben",
OTHER = "Anderes",
PERIODIC = "Regelmäßig",
POWER_GAINS = "Machtgewinn",
POWER_GAINS_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit Mana, Energie, Wut, Fokus, Chi, heilige Kraft oder Schattenkugeln wiederherstellt.",
QUICKBUTTON_NAME_EVERYTHING = "Alles",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "Alle Kampfnachrichten anzeigen.",
QUICKBUTTON_NAME_KILLS = "Todesstöße",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "Alle Tode und Todesstöße anzeigen.",
QUICKBUTTON_NAME_ME = "Was ist mit mir geschehen?",
QUICKBUTTON_NAME_ME_TOOLTIP = "Alles mir Zugefügte anzeigen.",
QUICKBUTTON_NAME_SELF = "Selbst",
QUICKBUTTON_NAME_SELF_TOOLTIP = "Zeigt Nachrichten für von Euch und an Euch ausgeführte Aktionen.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "Platziert im Chatfenster eine Verknüpfung zu diesem Filter.",
RANGED = "Distanz",
RANGED_COMBATLOG_TOOLTIP = "Zeigt Angriffe mit Bögen, Schusswaffen, Wurfwaffen und Zauberstäben an.",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "Zeigt Distanzangriffe an, die den vollen oder teilweisen Schaden verursachen.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "Zeigt fehlgeschlagene Distanzangriffe an, die keinen Schaden verursachen.",
RESURRECT = "Wiederbelebung",
SETTINGS = "Optionen",
SHOW_BRACES = "Klammern anzeigen",
SHOW_BRACES_COMBATLOG_TOOLTIP = "Klammern um Hyperlinks im Kampflog anzeigen.",
SHOW_QUICK_BUTTON = "Schnelltaste anzeigen",
SHOW_TIMESTAMP = "Zeitstempel anzeigen",
SOURCE = "Quelle",
SPECIAL = "Spezial",
SPELLS_COMBATLOG_TOOLTIP = "Zeigt Nachrichten über Zauber und Spezialfähigkeiten an.",
SPELL_CASTING = "Zauberwirken",
SPELL_CASTING_COMBATLOG_TOOLTIP = "Nachrichten über das Wirken von Zaubern anzeigen.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber nicht gewirkt werden kann oder nicht abgeschlossen wird.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "Nachricht anzeigen, wenn das Wirken eines Zaubers begonnen wird.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber erfolgreich abgeschlossen wird.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "Zauber basierend auf der Art einfärben.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit Schaden verursacht.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "Färbt die Schadenszahl von Schwüngen, die nicht im Nahkampf stattfinden.",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "Den Namen der Schadensart einfärben. (z.B. Schatten)",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit Mana, Energie, Wut oder Fokus verringert.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit zusätzliche Angriffe gewährt.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit Schaden heilt.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "Nachrichten über spezielle Zauberarten anzeigen, die beispielsweise Haltbarkeitsverlust verursachen oder Schaden mit einem Begleiter teilen.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit einen anderen Zauber unterbricht.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit keinen Schaden verursachen kann. Das schließt Ausweichen, Parieren, Blocken, Abwehren, Immunität, Absorbieren und Entkommen ein.",
SPELL_NAMES = "Zaubernamen",
SPELL_NAMES_COMBATLOG_TOOLTIP = "Namen von Zaubern einfärben.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Klammern um Namen von Zaubern anzeigen.",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "Zauber anzeigen, die einen regelmäßigen Effekt ausführen.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit regelmäßigen Schaden verursacht, z.B. Schattenwort: Schmerz oder Verderbnis.",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit regelmäßig Schaden heilt, z.B. Erneuerung oder Verjüngung.",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn der regelmäßige Schaden eines Zaubers oder einer Fähigkeit versagt. Das schließt Immunität, Absorbieren und Entkommen ein.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit regelmäßig einen Effekt ausführt, z.B. das Wiederherstellen oder Entziehen von Mana.",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "Nachrichten anzeigen, wenn ein Zauber oder eine Fähigkeit einen Spieler oder eine Kreatur wiedererweckt.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "Nachricht anzeigen, wenn ein Zauber oder eine Fähigkeit eine Kreatur beschwört oder ein Objekt erschafft.",
START = "Start",
STRING_SCHOOL_UNKNOWN = "Unbekannt",
SUCCESS = "Erfolg",
SUMMONS = "Herbeiruf.",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "Zeigt Nahkampfangriffe an, die den vollen oder teilweise Schaden verursachen.",
SWING_MISSED_COMBATLOG_TOOLTIP = "Zeigt fehlgeschlagene Nahkampfangriffe an, die keinen Schaden verursachen.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %3$s %2$s %4$s %5$s. %6$s",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(%s verbleiben)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s absorbiert)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s geblockt)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(Kritisch)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(Kritisch)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(Schmetternd)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount $resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(Gestreift)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(Mehrfachschlag)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s Überaufladung)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(%s Überheilung)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(%s Schaden über Tod)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d pariert)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "Reflektiert",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s widerstanden)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s Verletzlichkeitsschaden)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s %s",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "Den Zeitstempel für Nachrichten im Kampflog anzeigen.",
UNIT_COLORS = "Einheitenfarben:",
UNIT_NAMES = "Einheitennamen",
UNIT_NAMES_COMBATLOG_TOOLTIP = "Namen von Einheiten einfärben.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Klammern um Namen von Einheiten anzeigen.",
UNIT_YOU = "Ihr",
UNIT_YOU_DEST = "Euch",
UNIT_YOU_DEST_POSSESSIVE = "Euer",
UNIT_YOU_SOURCE = "Euer Charakter",
UNIT_YOU_SOURCE_POSSESSIVE = "Euer",
USE_FULL_TEXT_MODE = "Volltextmodus verwenden",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (GB) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["enUS"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "damages",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%1$s %2$s reflects %9$s %7$s damage to %4$s.%6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s reflects %9$s %7$s damage to %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED = "missed",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "(Blocked)",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%1$s %2$s was blocked by %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s was blocked by %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(Deflected)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%1$s %2$s was deflected by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s was deflected by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "(Dodged)",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%1$s %2$s was dodged by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s was dodged by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(Evaded)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%1$s %2$s was evaded by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s was evaded by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%1$s %2$s missed %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s missed %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "(Immune)",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%1$s %2$s failed. %4$s was immune.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s failed. %4$s was immune.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(Missed)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%1$s %2$s misses %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s misses %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "(Parried)",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%1$s %2$s was parried by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s was parried by %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "(Resisted)",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%1$s %2$s was fully resisted by %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s was fully resisted by %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "shared damage",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%1$s's %2$s damage was absorbed by %4$s %6$s.",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%1$s %2$s causes %9$s damage to %4$s.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%1$s's %2$s causes %9$s damage to %4$s %6$s.",
ACTION_ENCHANT_APPLIED = "enchanted",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s cast %2$s on %4$s %5$s.",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "enchant faded",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%2$s fades from %4$s %5$s.",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "damaged",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "Drowning",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s is drowning and loses %9$s health.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "Falling",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s falls and loses %9$s health.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "Fatigue",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s is exhausted and loses %9$s health.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "Fire",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s suffers %9$s fire damage.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s loses %9$s health from environmental damage.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "Lava",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s loses %9$s health from swimming in lava. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "Slime",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s loses %9$s health for swimming in slime. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "killed",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s has slain %4$s!",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "knocked out",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "%1$s has knocked out %4$s!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "Shot",
ACTION_RANGE_DAMAGE = "hit",
ACTION_RANGE_DAMAGE_FULL_TEXT = "%1$s ranged shot hit %4$s for %5$s.%6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "A ranged shot hit %4$s for %5$s.%6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "missed",
ACTION_RANGE_MISSED_ABSORB = "(Absorbed)",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%1$s shot was absorbed by %4$s.%6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "(Blocked)",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%1$s shot was blocked by %4$s.%6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(Deflected)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%1$s shot was deflected by %4$s.",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "(Dodged)",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%1$s shot was dodged by %4$s.",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(Evaded)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "%1$s shot was evaded by %4$s.",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "%1$s shot misses %4$s.",
ACTION_RANGE_MISSED_IMMUNE = "(Immune)",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "%1$s shot failed. %4$s was immune.",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(Misfired)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "%1$s shot misfired on %4$s.",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(Missed)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "%1$s shot misses %4$s.",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "(Parried)",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%1$s shot was parried by %4$s.",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "(Resisted)",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%1$s shot was fully resisted by %4$s.%6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "applied",
ACTION_SPELL_AURA_APPLIED_BUFF = "applied",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s gains %1$s %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gains %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s gains %1$s %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s gains %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "afflicted",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s is afflicted by %1$s %2$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s is afflicted by %2$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s is afflicted by %1$s %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s is afflicted by %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "stacked",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "stacked",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s gains %1$s %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gains %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "afflicted",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s is afflicted by %1$s %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s is afflicted by %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "broke",
ACTION_SPELL_AURA_BROKEN_BUFF = "broke",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%1$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "%1$s %2$s was broken by someone.",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "broke",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%1$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%1$s %2$s was broken by someone.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "broke",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s %5$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "broke",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s %5$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s broke %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "refreshed",
ACTION_SPELL_AURA_REFRESH_BUFF = "refreshed",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "%1$s %2$s is refreshed on %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "%2$s is refreshed on %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s is refreshed on %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s is refreshed on %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "refreshed",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "%1$s %2$s is refreshed on %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s is refreshed on %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s is refreshed on %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s is refreshed on %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "removed",
ACTION_SPELL_AURA_REMOVED_BUFF = "faded",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "%1$s %2$s fades from %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "%2$s fades from %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s fades from %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s fades from %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "dissipated",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "%1$s %2$s dissipates from %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s dissipates from %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s dissipates from %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s dissipates from %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "reduced",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "reduced",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%1$s %2$s (%9$s) diminishes.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) diminishes.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "diminished",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%1$s %2$s (%9$s) subsides.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) subsides.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "%1$s %2$s was removed from %4$s.",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "%1$s %2$s was removed from %4$s.",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "strikes",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%1$s %2$s strikes %4$s for %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s strike %4$s for %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "repaired",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%1$s %2$s repairs %4$s for %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s repairs %4$s for %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "failed",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%1$s %2$s failed.%6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "began to cast",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s begins casting %2$s at %4$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s begins casting %2$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "Something begins casting %2$s at %4$s.",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "cast",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s casts %2$s at %4$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s casts %2$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "Something cast %2$s at %4$s.",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "created",
ACTION_SPELL_CREATE_FULL_TEXT = "%1$s %2$s creates a %4$s.%6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%2$s creates a %4$s.%6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "hit",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%1$s %2$s hits %4$s for %5$s.%6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s hits %4$s for %5$s.%6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "dispelled",
ACTION_SPELL_DISPEL_BUFF = "dispelled",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%4$s %5$s is dispelled by %1$s %2$s.",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%4$s %5$s is dispelled by %2$s.",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "cleansed",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%4$s %5$s is cleansed by %1$s %2$s.",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s %5$s cleansed by %2$s.",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "dispel failed",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%1$s %2$s fails to dispel %4$s %5$s.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s fails to dispel %4$s %5$s.",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "drained",
ACTION_SPELL_DRAIN_FULL_TEXT = "%1$s %2$s drains %9$s %8$s from %4$s.",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = " %2$s drains %9$s %8$s from %4$s.",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "durability loss",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "full durability loss",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%1$s %2$s damages %4$s: all items damaged.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%1$s %2$s damages %4$s: %5$s damaged.",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "energized",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s gains %9$s %8$s from %1$s %2$s.",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gains %9$s %8$s from %2$s.",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "%9$s %8$s Gained",
ACTION_SPELL_EXTRA_ATTACKS = "granted extra attacks",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s gains %9$s extra attacks through %2$s.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "%9$s extra attacks granted by %2$s.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "healed",
ACTION_SPELL_HEAL_FULL_TEXT = "%1$s %2$s heals %4$s for %9$s.%6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s heals %4$s for %9$s.%6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "killed",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%1$s %2$s instantly kills %4$s.",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s instantly kills %4$s.",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "knocked out",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s knocks out %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s knocks out %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "interrupted",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%1$s %2$s interrupts %4$s %5$s.",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s interrupts %4$s %5$s.",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "drained",
ACTION_SPELL_LEECH_FULL_TEXT = "%1$s %2$s drains %9$s %8$s from %4$s. %1$s gains %10$s %8$s.",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s drains %9$s %8$s from %4$s.",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "%10$s %8$s Gained",
ACTION_SPELL_MISSED = "missed",
ACTION_SPELL_MISSED_ABSORB = "Absorbed",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%1$s %2$s was absorbed by %4$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s was absorbed by %4$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "Blocked",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%1$s %2$s was blocked by %4$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s was blocked by %4$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "Deflected",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%1$s %2$s was deflected by %4$s.",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s was deflected by %4$s.",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "Dodged",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%1$s %2$s was dodged by %4$s.",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s was dodged by %4$s.",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "Evaded",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%1$s %2$s was evaded by %4$s.",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%2$s was evaded by %4$s.",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%1$s %2$s missed %4$s.",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s missed %4$s.",
ACTION_SPELL_MISSED_IMMUNE = "Immune",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%1$s %2$s failed. %4$s was immune.",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s failed. %4$s was immune.",
ACTION_SPELL_MISSED_MISFIRE = "Misfired",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%1$s %2$s misfired on %4$s.",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s misfired on %4$s.",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "Missed",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%1$s %2$s misses %4$s.",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s misses %4$s.",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "Parried",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%1$s %2$s was parried by %4$s.",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s was parried by %4$s.",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "reflected",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%1$s %2$s was reflected by %4$s.",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%2$s was reflected by %4$s.",
ACTION_SPELL_MISSED_RESIST = "resisted",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%1$s %2$s was fully resisted by %4$s.%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s was fully resisted by %4$s.%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "damaged",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s suffers %5$s damage from %1$s %2$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s suffers %5$s damage from %2$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "drained",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%1$s %2$s drains %9$s %8$s from %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s drains %9$s %8$s from %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "energized",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s gains %9$s %8$s from %1$s %2$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gains %9$s %8$s from %2$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "$extraAmount %8$s Gained",
ACTION_SPELL_PERIODIC_HEAL = "healed",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s gains %9$s Health from %1$s %2$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s gains %9$s health from %2$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "drained",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%1$s %2$s drains %9$s %8$s from %4$s. %1$s gains %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s drains %9$s %8$s from %4$s. %1$s gains %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(%10$s %8$s Gained)",
ACTION_SPELL_PERIODIC_MISSED = "missed",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s Absorbed)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%1$s %2$s was absorbed by %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s was absorbed by %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "(Tick Blocked)",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%1$s %2$s was blocked by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s was blocked by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(Tick Deflected)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%1$s %2$s was deflected by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%2$s was deflected by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "(Tick Dodged)",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%1$s %2$s was dodged by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s was dodged by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(Tick Evaded)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%1$s %2$s was evaded by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s was evaded by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%1$s %2$s does not affect %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s does not affect %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "(Immune)",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s was immune to %1$s %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s was immune to %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "(Tick Missed)",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "%1$s %2$s missed %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s missed %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "(Tick Parried)",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%1$s %2$s was parried by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s was parried by %4$s for a moment.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "(Tick Resisted)",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%1$s %2$s does not affect %4$s. %4$s resisted.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s does not affect %4$s. %4$s resisted.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "resurrected",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%1$s %2$s resurrects %4$s.%6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s resurrects %4$s.%6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "stole",
ACTION_SPELL_STOLEN_BUFF = "stole",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%1$s %2$s steals %4$s %5$s.",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s steals %4$s %5$s.",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "stole",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%1$s %2$s transfers %4$s $extraSpell to %1$s.",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s transfers %4$s $extraSpell.",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%1$s %2$s steals %4$s %5$s.",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s steals %4$s %5$s.",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "summoned",
ACTION_SPELL_SUMMON_FULL_TEXT = "%1$s %2$s summons %4$s.%6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s summons %4$s.%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "Melee",
ACTION_SWING_DAMAGE = "hit",
ACTION_SWING_DAMAGE_FULL_TEXT = "%1$s melee swing hits %4$s for %5$s.%6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "A melee swing hit %4$s for %5$s.%6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "missed",
ACTION_SWING_MISSED_ABSORB = "(Absorbed)",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%1$s attack was absorbed by %4$s.%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "(Blocked)",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%1$s attack was blocked by %4$s.%6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(Deflected)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%1$s attack was deflected by %4$s.",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "(Dodged)",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%1$s attack was dodged by %4$s.",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(Evaded)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "%1$s attack was evaded by %4$s.",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "%1$s attack misses %4$s.",
ACTION_SWING_MISSED_IMMUNE = "(Immune)",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "%1$s attack failed. %4$s was immune.",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(Misfired)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "%1$s attack misfired on %4$s.",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(Missed)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "%1$s attack misses %4$s.",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "(Parried)",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%1$s attack was parried by %4$s.",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "(Resisted)",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%1$s attack was fully resisted by %4$s.%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "collapses",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s collapses.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "destroyed",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s was destroyed.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "died",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s died.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "dissipates",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s dissipates.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "Add",
ADDITIONAL_FILTERS = "Additional Filters",
ADD_FILTER = "Add Filter",
AURAS = "Auras",
AURAS_COMBATLOG_TOOLTIP = "Shows message about beneficial and harmful state effects.",
BENEFICIAL = "Beneficial",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "Show when you gain or lose a beneficial aura.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "Show everything involving %s?",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "Show everything",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "What happened to %s?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "What did %s do?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "What did %s do to you?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "Reset",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "Save as a new filter",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "Hide messages like this one.",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "Link %s to chat.",
BY_SOURCE = "By Source",
BY_SOURCE_COMBATLOG_TOOLTIP = "Line color based on caster.",
BY_TARGET = "By Target",
BY_TARGET_COMBATLOG_TOOLTIP = "Line color based on target.",
COLORIZE = "Colorize:",
COLORS = "Colors",
COLOR_BY_SCHOOL = "Color-by-School",
COMBATLOG_DEFAULTS = "Combat Log Defaults",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "Custom Unit",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "Friends",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "Enemy Players",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "Enemy Units",
COMBATLOG_FILTER_STRING_ME = "Me",
COMBATLOG_FILTER_STRING_MY_PET = "Pet",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "Neutral",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "Unknown",
COMBATLOG_HIGHLIGHT_ABILITY = "Ability",
COMBATLOG_HIGHLIGHT_DAMAGE = "Damage",
COMBATLOG_HIGHLIGHT_KILL = "Kill",
COMBATLOG_HIGHLIGHT_SCHOOL = "School",
COMBATLOG_UNKNOWN_UNIT = "Something",
COMBAT_FACTION_CHANGE = "Reputation",
COMBAT_HONOR_GAIN = "Honor",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "Misc Info",
COMBAT_XP_GAIN = "Experience",
CONFIRM_COMBAT_FILTER_DEFAULTS = "Do you really want to reset your filters to their default values?",
CONFIRM_COMBAT_FILTER_DELETE = "Do you really want to delete this filter?",
COPY_FILTER = "Copy Filter",
DAMAGE_NUMBER = "Damage Number",
DAMAGE_SCHOOL_TEXT = "Damage School",
DAMAGE_SHIELD = "Damage Shields",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "Show messages when a spell or ability deals damage in reaction to a melee swing, such as Thorns.",
DEATHS_COMBATLOG_TOOLTIP = "Show messages when something dies.",
DEFAULT_COMBATLOG_FILTER_NAME = "Filter %d",
DISPELS = "Dispels",
DISPEL_AURA_COMBATLOG_TOOLTIP = "Show when an aura is removed, broken, or stolen.",
DONE_BY = "Done By:",
DONE_TO = "Done To:",
DRAINS = "Drains",
ENTER_FILTER_NAME = "Enter filter name:",
ENTIRE_LINE = "Entire Line",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "Color the entire line based on the selection below.",
ENVIRONMENTAL_DAMAGE = "Environmental Damage",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "Show messages when someone takes damage from falling, drowning or swimming in lava.",
EXAMPLE_SPELL_FIREBALL = "Fireball",
EXAMPLE_SPELL_FROSTBOLT = "Frostbolt",
EXAMPLE_TARGET_MONSTER = "Monster",
EXAMPLE_TEXT = "Example Text:",
EXTRA_ATTACKS = "Extra Attacks",
FAILURES = "Failures",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "Actions performed by hostile creatures and pets.",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "Actions performed by friendly players, pets, and creatures.",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Actions performed by hostile players.",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "Actions performed by you, your traps, and your spells.",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "Actions performed by neutral creatures.",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "Actions performed by your pets, summoned guardians, and charmed players.",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "Actions performed by undefined sources such as falling, acid, or lava.",
FILTER_NAME = "Filter Name",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "Actions performed on friendly players, pets, and creatures.",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "Actions performed on hostile pets and creatures.",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Actions performed on hostile players.",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "Actions performed on you.",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "Actions performed on neutral creatures.",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "Actions performed on your pets, summoned guardians, and charmed players.",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "Actions performed on invisible targets.",
FORMATTING = "Formatting",
FULL_TEXT_COMBATLOG_TOOLTIP = "Show combat log entries as full sentences.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "Show when you gain or lose a harmful aura.",
HEALS = "Heals",
HIGHLIGHTING = "Highlighting:",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "Highlight ability names in combat messages.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "Highlight damage numbers in combat messages.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "Highlights the entire line when you or a party member makes a kill.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "Highlight the school of a spell in combat messages.",
HOSTILE = "Hostile",
INTERRUPTS = "Interrupts",
ITEM_NAMES = "Item Names",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Show braces around item names.",
KILLS_COMBATLOG_TOOLTIP = "Show messages when a member of your party kills something.",
MELEE = "Melee",
MELEE_COMBATLOG_TOOLTIP = "Shows natural melee swings.",
MESSAGE_SOURCES = "Message Sources",
MISSES = "Misses",
MOVE_FILTER_DOWN = "Move Filter Down",
MOVE_FILTER_UP = "Move Filter Up",
OTHER = "Other",
PERIODIC = "Periodic",
POWER_GAINS = "Power Gains",
POWER_GAINS_COMBATLOG_TOOLTIP = "Show messages when a spell or ability restores mana, energy, rage, focus, chi, holy power, or shadow orbs.",
QUICKBUTTON_NAME_EVERYTHING = "Everything",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "Show all combat messages.",
QUICKBUTTON_NAME_KILLS = "Kills",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "Show all deaths and kills.",
QUICKBUTTON_NAME_ME = "What happened to me?",
QUICKBUTTON_NAME_ME_TOOLTIP = "Show everything done to me.",
QUICKBUTTON_NAME_SELF = "Self",
QUICKBUTTON_NAME_SELF_TOOLTIP = "Show messages of actions done by you and done to you.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "Places a shortcut to this filter on the chat window.",
RANGED = "Ranged",
RANGED_COMBATLOG_TOOLTIP = "Shows attacks from bows, guns, thrown weapons, and wands.",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "Show ranged shots that deal full or partial damage.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "Show ranged shots that fail to deal damage.",
RESURRECT = "Resurrections",
SETTINGS = "Settings",
SHOW_BRACES = "Show Braces",
SHOW_BRACES_COMBATLOG_TOOLTIP = "Display braces around hyperlinks in combat log messages.",
SHOW_QUICK_BUTTON = "Show Quick Button",
SHOW_TIMESTAMP = "Show Timestamp",
SOURCE = "Source:",
SPECIAL = "Special",
SPELLS_COMBATLOG_TOOLTIP = "Shows messages about spells and special abilities.",
SPELL_CASTING = "Spell Casting",
SPELL_CASTING_COMBATLOG_TOOLTIP = "Show messages about spell casting.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "Show messages when a spell cannot be cast or fails to cast.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "Show messages when a spell begins casting.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "Show messages when a spell successfully completes.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "Color spell names by school.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "Show messages when a spell or ability deals damage.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "Colorizes the damage number on non-melee swings.",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "Color the damage school name. (e.g. shadow)",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "Show messages when a spell or ability reduces mana, energy, rage, or focus.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "Show messages when a spell or ability grants additional attacks.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "Show messages when a spell or ability heals damage.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "Show messages about special spell types, such as those that inflict durability loss or share damage with a pet.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "Show messages when a spell or ability interrupts another spell.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "Show messages when a spell or ability fails to deal damage. This includes dodges, parries, blocks, deflections, immunes, absorbs and evades.",
SPELL_NAMES = "Spell Names",
SPELL_NAMES_COMBATLOG_TOOLTIP = "Color spell names.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Show braces around spell names.",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "Show spells that perform an effect incrementally.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "Show messages when a spell or ability periodically deals damage, such as Shadow Word: Pain or Corruption.",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "Show messages when a spell or ability periodically heals damage, such as Renew or Rejuvenation.",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "Show messages when a spell or ability fails to periodically deal damage. This includes immunes, absorbs and evades.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "Show messages when a spell or ability periodically performs any other effect, such as restoring or draining mana.",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "Show messages when a spell or ability resurrects another player or creature.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "Show messages when a spell or ability summons a creature or creates an object.",
START = "Start",
STRING_SCHOOL_UNKNOWN = "Unknown",
SUCCESS = "Success",
SUMMONS = "Summons",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "Shows melee swings that deal full or partial damage.",
SWING_MISSED_COMBATLOG_TOOLTIP = "Show melee swings that do not deal damage.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %3$s %2$s %4$s %5$s. %6$s",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s's",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(%s Remaining)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s Absorbed)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s Blocked)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(Critical)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(Critical)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(Crushing)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount $resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(Glancing)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(Multistrike)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s Overenergized)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(%s Overhealed)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(%s Overkill)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d Parried)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "Reflected",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s Resisted)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s Vulnerability Damage)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s %s",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "Display the timestamp for combat log messages.",
UNIT_COLORS = "Unit Colors:",
UNIT_NAMES = "Unit Names",
UNIT_NAMES_COMBATLOG_TOOLTIP = "Color unit names.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Show braces around unit names.",
UNIT_YOU = "You",
UNIT_YOU_DEST = "You",
UNIT_YOU_DEST_POSSESSIVE = "Your",
UNIT_YOU_SOURCE = "You",
UNIT_YOU_SOURCE_POSSESSIVE = "Your",
USE_FULL_TEXT_MODE = "Use Verbose Mode",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (ES) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["esES"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "daña",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%2$s de %1$s refleja %9$s daño %7$s a %4$s.%6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s refleja %9$s daño %7$s a %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED = "fallado",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "(Bloqueado)",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%4$s bloqueó %2$s de %1$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s bloqueó %2$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(Desviado)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%4$s desvió %2$s de %1$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s desvió %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "(Esquivado)",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%4$s esquivó %2$s de %1$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s esquivó %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(Evadido)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%4$s evadió %2$s de %1$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%4$s evadió %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%2$s de %1$s no alcanzó a %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s no alcanzó a %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "(Inmune)",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%2$s de %1$s falló. %4$s era inmune.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s falló. %4$s era inmune.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(Fallado)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%2$s de %1$s no alcanza a %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s no alcanza a %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "(Parado)",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%4$s paró %2$s de %1$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s paró %2$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "(Resistido)",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%4$s resistió por completo %2$s de %1$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s resistió por completo %2$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "daño transferido",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%4$s absorbió el daño de %2$s de %1$s. %6$s.",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%2$s de %1$s inflige %9$s de daño a %4$s.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%2$s de %1$s inflige %9$s de daño a %4$s. %6$s.",
ACTION_ENCHANT_APPLIED = "aplicado a",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s lanza %2$s a %5$s de %4$s.",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "eliminado de",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%2$s se desvanece de %5$s de %4$s.",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "dañó",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "Ahogamiento",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s se está ahogando y pierde %9$s salud.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "Caída",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s cae y pierde %9$s salud.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "Fatiga",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s sufre agotamiento y pierde %9$s salud.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "Fuego",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s sufre %9$s daño de Fuego.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s pierde %9$s salud por daño recibido del entorno.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "Lava",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s pierde %9$s salud por nadar en lava. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "Cieno",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s pierde %9$s salud por nadar en el cieno. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "mató",
ACTION_PARTY_KILL_FULL_TEXT = "¡%1$s mató a %4$s!",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "está fuera de combate",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "¡%1$s ha dejado fuera de combate a %4$s!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "disparo",
ACTION_RANGE_DAMAGE = "alcanzó",
ACTION_RANGE_DAMAGE_FULL_TEXT = "%1$s da a %4$s un golpe a distancia y le inflige %5$s.%6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "Un golpe a distancia alcanza a %4$s y le inflige %5$s.%6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "falló",
ACTION_RANGE_MISSED_ABSORB = "(Absorbido)",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%4$s absorbió el golpe de %1$s.%6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "(Bloqueado)",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%4$s bloqueó el golpe de %1$s.%6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(Desviado)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%4$s desvió el golpe de %1$s.",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "(Esquivado)",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%4$s esquivó el golpe de %1$s.",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(Evadido)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "%4$s evadió el golpe de %1$s.",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "El golpe de %1$s no alcanza a %4$s.",
ACTION_RANGE_MISSED_IMMUNE = "(Inmune)",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "El golpe de %1$s falló. %4$s era inmune.",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(Lanzamiento fallado)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "El golpe de %1$s ha fallado al lanzarse hacia %4$s.",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(Fallado)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "El golpe de %1$s no alcanza a %4$s.",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "(Parado)",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%4$s paró el golpe de %1$s.",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "(Resistido)",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%4$s resistió por completo el golpe de %1$s.%6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "aplicó",
ACTION_SPELL_AURA_APPLIED_BUFF = "aplicó",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s gana %2$s de %1$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gana %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s gana %1$s de %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s gana %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "afectó",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "A %4$s le afecta %2$s de %1$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "A %4$s le afecta %2$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "A %4$s le afecta %1$s de %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "A %4$s le afecta %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "acumuló",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "acumuló",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s gana %2$s de %1$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gana %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "afectó",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "A %4$s le afecta %2$s de %1$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "A %4$s le afecta %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "rompió",
ACTION_SPELL_AURA_BROKEN_BUFF = "rompió",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%1$s rompió %2$s de %4$s.",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "Alguien ha roto %2$s de %1$s.",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "rompió",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%1$s rompió %2$s de %4$s.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "Alguien ha roto %2$s de %1$s.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "rompió",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s %5$s rompió %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s rompió %2$s de %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "rompió",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s %5$s rompió %4$s %2$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s rompió %2$s de %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "restableció",
ACTION_SPELL_AURA_REFRESH_BUFF = "restableció",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "%2$s de %1$s restablecido en %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "%2$s se restablece en %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s restablecido en %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s se restablece en %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "restableció",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "%2$s de %1$s restablecido en %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s se restablece en %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s restablecido en %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s se restablece en %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "eliminó",
ACTION_SPELL_AURA_REMOVED_BUFF = "perdió",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "%2$s de %1$s se desvanece de %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "%2$s se desvanece de %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s se desvanece de %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s se desvanece de %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "disipó",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "%2$s de %1$s se disipa de %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s se disipa de %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s se disipa de %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s se disipa de %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "redujo",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "redujo",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%2$s de %1$s (%9$s) disminuye.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) disminuye.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "disminuyó",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%2$s de %1$s (%9$s) decrece.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) decrece.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "%2$s de %1$s se eliminó de %4$s.",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "%2$s de %1$s se eliminó de %4$s.",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "golpea",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%1$s %2$s golpea a %4$s por %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s golpea a %4$s por %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "reparado",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%1$s %2$s repairs %4$s durante %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s repara %4$s durante %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "falló",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%2$s de %1$s falló.%6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "comenzó a lanzar",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s comienza a lanzar %2$s a %4$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s comienza a lanzar %2$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "Algo comienza a lanzar %2$s a %4$s.",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "lanzó",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s lanza %2$s a %4$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s lanza %2$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "Algo lanza %2$s a %4$s.",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "creó",
ACTION_SPELL_CREATE_FULL_TEXT = "%2$s de %1$s crea %4$s.%6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%2$s crea %4$s.%6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "alcanzó",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%2$s de %1$s golpea a %4$s y le inflige %5$s.%6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s golpea a %4$s y le inflige %5$s.%6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "disipó",
ACTION_SPELL_DISPEL_BUFF = "disipó",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%2$s de %1$s disipa %4$s de %5$s.",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%2$s disipa %4$s de %5$s.",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "limpió",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%2$s de %1$s limpia %5$s de %4$s.",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s limpia %5$s de %4$s.",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "error al disipar",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%2$s de %1$s no logra disipar %4$s de %5$s.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s no logró disipar %4$s %5$s.",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "drenó",
ACTION_SPELL_DRAIN_FULL_TEXT = "%2$s de %1$s drena %9$s %8$s de %4$s.",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s drena %9$s p. de %8$s de %4$s.",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "pérdida de durabilidad",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "pérdida total de durabilidad",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%2$s de %1$s daña %4$s: todos los objetos dañados.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%2$s de %1$s daña %4$s: %5$s dañado.",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "energizó",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s gana %9$s de %8$s gracias a %2$s de %1$s.",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gana %9$s de %8$s gracias a %2$s.",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "%9$s %8$s ganado",
ACTION_SPELL_EXTRA_ATTACKS = "otorgó ataques extra",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s gana %9$s ataques extra con %2$s.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "%2$s otorga %9$s ataques extra.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "sanó",
ACTION_SPELL_HEAL_FULL_TEXT = "%2$s de %1$s sana %9$s a %4$s.%6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s sana %9$s a %4$s.%6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "mató",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%2$s de %1$s mata al instante a %4$s.",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s mata a %4$s al instante.",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "está fuera de combate",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s deja fuera de combate a %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s deja fuera de combate a %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "interrumpió",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%2$s de %1$s interrumpe %5$s de %4$s.",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s interrumpe %5$s de %4$s.",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "drenó",
ACTION_SPELL_LEECH_FULL_TEXT = "%1$s %2$s drena %9$s %8$s de %4$s. %1$s gana %10$s %8$s.",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s drena %9$s %8$s de %4$s.",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "%10$s %8$s ganado",
ACTION_SPELL_MISSED = "fallado",
ACTION_SPELL_MISSED_ABSORB = "Absorbido",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%4$s absorbió %2$s de %1$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%4$s absorbió %2$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "Bloqueado",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%4$s bloqueó %2$s de %1$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s bloqueó %2$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "Desviado",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%4$s desvió %2$s de %1$s.",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s desvió %2$s.",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "Esquivado",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%4$s esquivó %2$s de %1$s.",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s esquivó %2$s.",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "Evadido",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%4$s evadió %2$s de %1$s.",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%4$s evadió %2$s.",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%2$s de %1$s no alcanzó a %4$s.",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s no alcanzó a %4$s.",
ACTION_SPELL_MISSED_IMMUNE = "Inmune",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%2$s de %1$s falló. %4$s era inmune.",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s falló. %4$s era inmune.",
ACTION_SPELL_MISSED_MISFIRE = "Lanzamiento fallado",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%2$s de %1$s ha fallado al lanzarse hacia %4$s.",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s ha fallado al lanzarse hacia %4$s.",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "Fallado",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%2$s de %1$s no alcanza a %4$s.",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s no alcanza a %4$s.",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "Parado",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%4$s paró %2$s de %1$s.",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s paró %2$s.",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "reflejado",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%4$s reflejó %2$s de %1$s.",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%4$s reflejó %2$s.",
ACTION_SPELL_MISSED_RESIST = "resistido",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%4$s resistió por completo %2$s de %1$s.%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s resistió por completo %2$s.%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "dañó",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s sufre %5$s daño de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s sufre %5$s daño de %2$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "drenó",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%2$s de %1$s drena %9$s %8$s de %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s drena %9$s %8$s de %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "energizó",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s gana %9$s de %8$s gracias a %2$s de %1$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gana %9$s de %8$s gracias a %2$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "$extraAmount %8$s ganado",
ACTION_SPELL_PERIODIC_HEAL = "sanó",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s gana %9$s salud gracias a %1$s %2$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s gana %9$s salud gracias a %2$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "drenó",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%1$s %2$s drena %9$s %8$s de %4$s. %1$s gana %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s drena %9$s %8$s de %4$s. %1$s gana %10$s %8$s.",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(%10$s %8$s ganado)",
ACTION_SPELL_PERIODIC_MISSED = "falla tic",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s Absorbido)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%4$s absorbió %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%4$s absorbió %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "(Bloqueado)",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%4$s bloqueó el efecto periódico de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s bloqueó el efecto periódico de %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(Desviado)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%4$s desvió el efecto periódico de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%4$s desvió el efecto periódico de %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "(Esquivado)",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%4$s esquivó el efecto periódico de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s esquivó el efecto periódico de %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(Evadido)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%4$s evadió el efecto periódico de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%4$s evadió el efecto periódico de %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%2$s de %1$s no tiene efecto periódico sobre %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s no tiene efecto periódico sobre %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "(Inmune)",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s era inmune a %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s era inmune a %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "(Fallado)",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "El efecto periódico de %2$s de %1$s no alcanzó a %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "El efecto periódico de %2$s no alcanzó a %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "(Parado)",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%4$s paró el efecto periódico de %2$s de %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s paró el efecto periódico de %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "(Resistido)",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%2$s de %1$s no afecta a %4$s. %4$s resistió.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s no afecta a %4$s. %4$s resistió.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "resucitado",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%1$s %2$s resucita a %4$s.%6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s resucita a %4$s.%6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "robó",
ACTION_SPELL_STOLEN_BUFF = "robó",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%2$s de %1$s roba %5$s de %4$s.",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s roba %5$s de %4$s.",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "robó",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%2$s de %1$s transfiere $extraSpell de %4$s a %1$s.",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s transfiere $extraSpell de %4$s.",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%2$s de %1$s roba %5$s de %4$s.",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s roba %5$s de %4$s.",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "invocó",
ACTION_SPELL_SUMMON_FULL_TEXT = "%2$s de %1$s invoca a %4$s.%6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s invoca a %4$s.%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "Golpe",
ACTION_SWING_DAMAGE = "alcanzó",
ACTION_SWING_DAMAGE_FULL_TEXT = "%1$s da a %4$s un golpe cuerpo a cuerpo y le inflige %5$s.%6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "Un golpe cuerpo a cuerpo alcanza a %4$s y le inflige %5$s.%6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "falló",
ACTION_SWING_MISSED_ABSORB = "(Absorbido)",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%4$s absorbió el ataque de %1$s.%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "(Bloqueado)",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%4$s bloqueó el ataque de %1$s.%6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(Desviado)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%4$s desvió el ataque de %1$s.",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "(Esquivado)",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%4$s esquivó el ataque de %1$s.",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(Evadido)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "%4$s evadió el ataque de %1$s.",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "El ataque de %1$s no alcanza a %4$s.",
ACTION_SWING_MISSED_IMMUNE = "(Inmune)",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "El ataque de %1$s ha fallado. %4$s era inmune.",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(Lanzamiento fallado)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "El ataque de %1$s ha fallado al lanzarse hacia %4$s.",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(Fallado)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "El ataque de %1$s no alcanza a %4$s.",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "(Parado)",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%4$s paró el ataque de %1$s.",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "(Resistido)",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%4$s resistió por completo el ataque de %1$s.%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "se desmaya",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s se desmaya.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "destruyó",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s ha sido destruido.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "murió",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s ha muerto.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "se disipa",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s se disipa.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "Añadir",
ADDITIONAL_FILTERS = "Filtros adicionales",
ADD_FILTER = "Añadir",
AURAS = "Auras",
AURAS_COMBATLOG_TOOLTIP = "Mostrar mensajes sobre efectos de estados beneficiosos y dañinos.",
BENEFICIAL = "Beneficioso",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "Mostrar cuando ganas o pierdes un aura beneficiosa.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "¿Mostrar todo lo referente a %s?",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "Mostrar todo",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "¿Qué le pasó a %s?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "¿Qué hizo %s?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "¿Qué te hizo %s?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "Restablecer",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "Guardar como nuevo filtro",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "Ocultar los mensajes como este.",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "Vincular %s a chat.",
BY_SOURCE = "Por origen",
BY_SOURCE_COMBATLOG_TOOLTIP = "Color de línea según taumaturgo.",
BY_TARGET = "Por objetivo",
BY_TARGET_COMBATLOG_TOOLTIP = "Color de línea según objetivo.",
COLORIZE = "Colorear:",
COLORS = "Colores",
COLOR_BY_SCHOOL = "Colorear según escuela",
COMBATLOG_DEFAULTS = "Restablecer reg. combate",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "Unidad personalizada",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "Amigos",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "Jugadores enemigos",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "Unidades enemigas",
COMBATLOG_FILTER_STRING_ME = "Yo",
COMBATLOG_FILTER_STRING_MY_PET = "Mascota",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "Neutral",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "Desconocido",
COMBATLOG_HIGHLIGHT_ABILITY = "Facultad",
COMBATLOG_HIGHLIGHT_DAMAGE = "Daño",
COMBATLOG_HIGHLIGHT_KILL = "Muerte",
COMBATLOG_HIGHLIGHT_SCHOOL = "Escuela",
COMBATLOG_UNKNOWN_UNIT = "Algo",
COMBAT_FACTION_CHANGE = "Reputación",
COMBAT_HONOR_GAIN = "Honor",
COMBAT_LOG_UNIT_YOU_ENABLED = "0",
COMBAT_MISC_INFO = "Info. misc.",
COMBAT_XP_GAIN = "Experiencia",
CONFIRM_COMBAT_FILTER_DEFAULTS = "¿De verdad quieres restablecer la configuración inicial?",
CONFIRM_COMBAT_FILTER_DELETE = "¿Realmente quieres borrar este filtro?",
COPY_FILTER = "Copiar",
DAMAGE_NUMBER = "Cifra de daño",
DAMAGE_SCHOOL_TEXT = "Escuela de daño",
DAMAGE_SHIELD = "Escudos de daño",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad hace daño en reacción a un golpe cuerpo a cuerpo, como Espinas.",
DEATHS_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando haya una muerte.",
DEFAULT_COMBATLOG_FILTER_NAME = "Filtro %d",
DISPELS = "Disipación",
DISPEL_AURA_COMBATLOG_TOOLTIP = "Mostrar cuando se elimina, rompe o roba un aura.",
DONE_BY = "Hecho por:",
DONE_TO = "Hecho a:",
DRAINS = "drena",
ENTER_FILTER_NAME = "Escribe el nombre del filtro:",
ENTIRE_LINE = "Toda la línea",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "Colorear toda la línea según la siguiente opción.",
ENVIRONMENTAL_DAMAGE = "Daño del entorno",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando alguien sufra daño al caer, ahogarse o nadar en lava.",
EXAMPLE_SPELL_FIREBALL = "Bola de Fuego",
EXAMPLE_SPELL_FROSTBOLT = "Descarga de Escarcha",
EXAMPLE_TARGET_MONSTER = "Monstruo",
EXAMPLE_TEXT = "Texto de muestra:",
EXTRA_ATTACKS = "Ataques extra",
FAILURES = "Fallos",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por criaturas y mascotas hostiles.",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por jugadores, mascotas y criaturas aliados.",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por jugadores hostiles.",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por ti, tus trampas y tus hechizos.",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por criaturas neutrales.",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "Acciones llevadas a cabo por tus mascotas, guardianes invocados y jugadores embelesados.",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "Acciones de origen sin especificar como caídas, ácido o lava.",
FILTER_NAME = "Nombre del filtro",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "Acciones realizadas a jugadores, mascotas y criaturas aliados.",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "Acciones realizadas a mascotas y criaturas hostiles.",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Acciones realizadas a jugadores hostiles.",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "Acciones realizadas a ti.",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "Acciones realizadas a criaturas neutrales.",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "Acciones realizadas a tus mascotas, guardianes invocados y jugadores embelesados.",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "Acciones realizadas a objetivos invisibles.",
FORMATTING = "Formato",
FULL_TEXT_COMBATLOG_TOOLTIP = "Mostrar las entradas del registro de combate como frases completas.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "Mostrar cuando ganas o pierdes un aura dañina.",
HEALS = "Sanaciones",
HIGHLIGHTING = "Resaltar:",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "Resaltar nombres de facultades en mensajes de combate.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "Resaltar cifras de daño en mensajes de combate.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "Resaltar toda la línea cuando matas o lo hace un miembro de tu grupo.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "Resaltar la escuela del hechizo en el mensaje de combate.",
HOSTILE = "Hostil",
INTERRUPTS = "interrumpe",
ITEM_NAMES = "Nombres de objetos",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mostrar nombres de objetos entre corchetes.",
KILLS_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un miembro de tu grupo mata.",
MELEE = "Cuerpo a cuerpo",
MELEE_COMBATLOG_TOOLTIP = "Mostrar golpes cuerpo a cuerpo naturales.",
MESSAGE_SOURCES = "Origen mensaje",
MISSES = "Fallos",
MOVE_FILTER_DOWN = "Mover filtro abajo",
MOVE_FILTER_UP = "Mover filtro arriba",
OTHER = "Otros",
PERIODIC = "Periódico",
POWER_GAINS = "Ganancia de poder",
POWER_GAINS_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad restaure maná, energía, ira, enfoque, chi, Poder Sagrado u orbes de las Sombras.",
QUICKBUTTON_NAME_EVERYTHING = "Todo",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "Mostrar todos los mensajes de combate.",
QUICKBUTTON_NAME_KILLS = "Muertes",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "Mostrar todas las muertes aliadas y enemigas.",
QUICKBUTTON_NAME_ME = "Me afecta",
QUICKBUTTON_NAME_ME_TOOLTIP = "Mostrar todo lo que me afecta.",
QUICKBUTTON_NAME_SELF = "Yo mismo",
QUICKBUTTON_NAME_SELF_TOOLTIP = "Mostrar mensajes de tus acciones y de las que te afectan.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "Coloca un acceso rápido a este filtro en la ventana de chat.",
RANGED = "A distancia",
RANGED_COMBATLOG_TOOLTIP = "Mostrar ataques con arcos, armas de fuego, armas arrojadizas y varitas.",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "Mostrar los golpes a distancia que infligen daño total o parcial.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "Mostrar los golpes a distancia que no logran infligir daño.",
RESURRECT = "Resurrecciones",
SETTINGS = "Configuración",
SHOW_BRACES = "Mostrar corchetes",
SHOW_BRACES_COMBATLOG_TOOLTIP = "Mostrar los hipervínculos entre corchetes en los mensajes del registro de combate.",
SHOW_QUICK_BUTTON = "Mostrar botón de acceso rápido",
SHOW_TIMESTAMP = "Mostrar tiempo",
SOURCE = "Fuente:",
SPECIAL = "Especial",
SPELLS_COMBATLOG_TOOLTIP = "Mostrar mensajes sobre hechizos y facultades especiales.",
SPELL_CASTING = "Hechizos lanzados",
SPELL_CASTING_COMBATLOG_TOOLTIP = "Mostrar mensajes de los hechizos lanzados.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando no se puede lanzar un hechizo o cuando no se logra lanzar.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando se comienza a lanzar un hechizo.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo se lance correctamente.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "Colorear los nombres de hechizos según la escuela.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad inflige daño.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "Colorear la cifra del daño de golpes otros que cuerpo a cuerpo.",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "Colorear el nombre de escuela del daño (p. ej., Sombras).",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad reduzca el maná, la energía, la ira o el enfoque.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad otorgue ataques adicionales.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad sana daño.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "Mostrar mensajes sobre tipos de hechizos especiales, como los que infligen pérdida de durabilidad o comparten daño con una mascota.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad interrumpe otro hechizo.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad no logra infligir daño. Incluye cuando el objetivo es inmune o lo esquiva, para, bloquea, desvía, absorbe o evade.",
SPELL_NAMES = "Nombres de hechizos",
SPELL_NAMES_COMBATLOG_TOOLTIP = "Colorear los nombres de hechizos.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mostrar nombres de hechizos entre corchetes.",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "Mostrar los hechizos que tienen un efecto gradual.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad inflige daño periódico, como Palabra de las Sombras: Dolor o Corrupción.",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad sana daño periódicamente, como Renovar o Rejuvenecimiento.",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad no logra infligir daño periódico. Incluye cuando el objetivo es inmune, lo absorbe o lo evade.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad inflige cualquier otro efecto periódicamente, como restaurar o drenar maná.",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo o facultad resucite a otro jugador o criatura.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "Mostrar mensajes cuando un hechizo invoque a una criatura o cree un objeto.",
START = "Inicio",
STRING_SCHOOL_UNKNOWN = "Desconocido",
SUCCESS = "Éxito",
SUMMONS = "Invocación",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "Mostrar golpes cuerpo a cuerpo que infligen daño total o parcial.",
SWING_MISSED_COMBATLOG_TOOLTIP = "Mostrar golpes cuerpo a cuerpo que no infligen daño.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %3$s %2$s %4$s %5$s. %6$s",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(%s restante)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s absorbido)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s bloqueado)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(Crítico)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(Crítico)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(Aplastamiento)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount $resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(Refilón)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(Multigolpe)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s sobreenergizado)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(%s de exceso de sanación)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(%s excedente)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d Parado)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "Reflejado",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s resistido)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s de daño de vulnerabilidad)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s %s",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "Mostrar el tiempo en los mensajes del registro de combate.",
UNIT_COLORS = "Colores de unidades:",
UNIT_NAMES = "Nombres de unidades",
UNIT_NAMES_COMBATLOG_TOOLTIP = "Colorear el nombre de unidades.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mostrar nombres de unidades entre corchetes.",
UNIT_YOU = "Tú",
UNIT_YOU_DEST = "Tú",
UNIT_YOU_DEST_POSSESSIVE = "Tu",
UNIT_YOU_SOURCE = "Tú",
UNIT_YOU_SOURCE_POSSESSIVE = "Tu",
USE_FULL_TEXT_MODE = "Mostrar texto completo",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (FR) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["frFR"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "inflige des dégâts",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%2$s %1$s renvoie %9$s de dégâts |2 %7$s à %4$s.%6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s renvoie %9$s de dégâts |2 %7$s à %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED = "rate",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "(Bloque)",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%2$s %1$s est bloqué par %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s est bloqué par %4$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(Dévie)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%2$s %1$s est dévié par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s est dévié par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "(Esquive)",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%2$s %1$s est esquivé par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s est esquivé par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(Évite)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%2$s %1$s est évité par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s est évité par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%2$s %1$s rate %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s rate %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "(Insensible)",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%2$s %1$s a échoué. %4$s est insensible.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s a échoué. %4$s est insensible.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(Rate)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%2$s %1$s rate %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s rate %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "(Pare)",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%2$s %1$s est paré par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s est paré par %4$s.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "(Résiste)",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%4$s résiste entièrement à %2$s %1$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s résiste entièrement à %2$s.%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "partage les dégâts",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "Les dégâts |2 %2$s |2 %1$s sont absorbés par %4$s %6$s.",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%2$s %1$s inflige %9$s points de dégâts à %4$s.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%2$s |2 %1$s inflige %9$s points de dégâts à %4$s %6$s.",
ACTION_ENCHANT_APPLIED = "enchante",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s lance %2$s sur %5$s %4$s.",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "lève l'enchantement",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%2$s s'efface |2 %5$s %4$s.",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "inflige des dégâts",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "Noyade",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s se noie et perd %9$s points de vie.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "Chute",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s tombe et perd %9$s points de vie.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "Fatigue",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s s'épuise et perd %9$s points de vie.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "Feu",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s subit %9$s points de dégâts de Feu.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s perd %9$s points de vie par dégâts de l'environnement.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "Lave",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s perd %9$s points de vie en nageant dans la lave. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "Gelée",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s perd %9$s points de vie en nageant dans la gelée. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "tue",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s a tué %4$s !",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "assommé",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "%1$s a assommé %4$s !",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "Tir",
ACTION_RANGE_DAMAGE = "touche",
ACTION_RANGE_DAMAGE_FULL_TEXT = "Le tir %1$s touche %4$s pour %5$s.%6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "Un tir touche %4$s pour %5$s.%6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "rate",
ACTION_RANGE_MISSED_ABSORB = "(Absorbe)",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "Le tir %1$s est absorbé par %4$s.%6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "(Bloque)",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "Le tir %1$s est bloqué par %4$s.%6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(Dévie)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "Le tir %1$s est dévié par %4$s.",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "(Esquive)",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "Le tir %1$s est esquivé par %4$s.",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(Évite)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "Le tir %1$s est évité par %4$s.",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "Le tir %1$s rate %4$s.",
ACTION_RANGE_MISSED_IMMUNE = "(Insensible)",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "Le tir %1$s a échoué. %4$s est insensible.",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(Tir accidentel)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "Le tir %1$s a touché %4$s par accident.",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(Raté)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "Le tir %1$s rate %4$s.",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "(Pare)",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "Le tir %1$s est paré par %4$s.",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "(Résiste)",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "Le tir %1$s a échoué, %4$s résiste entièrement.%6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "applique",
ACTION_SPELL_AURA_APPLIED_BUFF = "applique",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s gagne %2$s %1$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gagne %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s gagne %2$s %1$s. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s gagne %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "afflige",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s souffre |2 %2$s %1$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s souffre |2 %2$s.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s souffre |2 %2$s %1$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s souffre |2 %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "cumule",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "cumule",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s gagne %2$s %1$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s gagne %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "afflige",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s souffre |2 %2$s %1$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s souffre |2 %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "brise",
ACTION_SPELL_AURA_BROKEN_BUFF = "brise",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%1$s brise %2$s %4$s.",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s %1$s a été brisé par quelqu'un.",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "brise",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%1$s brise %2$s %4$s.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s %1$s a été brisé par quelqu'un.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "brise",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s brise %2$s %4$s avec %5$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s a brisé %2$s %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "brise",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s brise %2$s %4$s avec %5$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s brise %2$s %4$s.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "rafraîchit",
ACTION_SPELL_AURA_REFRESH_BUFF = "rafraîchit",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "%2$s %1$s est rafraîchi sur %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "%2$s est rafraîchi sur %4$s.",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "%2$s %1$s est rafraîchi sur %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s est rafraîchi sur %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "rafraîchit",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "%2$s %1$s est rafraîchi sur %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s est rafraîchi sur %4$s.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "%2$s %1$s est rafraîchi sur %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s est rafraîchi sur %4$s. %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "enlève",
ACTION_SPELL_AURA_REMOVED_BUFF = "efface",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "%2$s %1$s s'efface |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "%2$s s'efface |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "%2$s %1$s s'efface |2 %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s s'efface |2 %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "disparaît",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "%2$s %1$s disparaît |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s se dissipe |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "%2$s %1$s disparaît |2 %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s se dissipe |2 %4$s. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "réduit",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "réduit",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%2$s %1$s (%9$s) se réduit.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) se réduit.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "diminue",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%2$s %1$s (%9$s) diminue.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s (%9$s) diminue.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "%2$s %1$s est enlevé |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "%2$s %1$s est enlevé |2 %4$s.",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "frappe",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%2$s %1$s frappe %4$s pour %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s frappe %4$s pour %5$s.%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "répare",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%2$s %1$s répare %4$s pour %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s répare %4$s pour %9$s.%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "échoue",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%2$s %1$s échoue.%6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "commence à lancer",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s commence à lancer %2$s sur %4$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s commence à lancer %2$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "Quelqu'un commence à lancer %2$s sur %4$s.",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "lance",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s lance %2$s sur %4$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s lance %2$s.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "Quelque chose lance %2$s sur %4$s.",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "Crée",
ACTION_SPELL_CREATE_FULL_TEXT = "%2$s %1$s crée %4$s.%6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%2$s crée %4$s.%6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "touche",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%2$s %1$s touche %4$s pour %5$s.%6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s touche %4$s pour %5$s.%6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "dissipe",
ACTION_SPELL_DISPEL_BUFF = "dissipe",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%5$s %4$s est dissipé par %2$s %1$s.",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s %4$s est dissipé par %2$s.",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "purifie",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%5$s %4$s est purifié par %2$s %1$s.",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s %4$s purifié par %2$s.",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "échec de dissipation",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%2$s %1$s n'arrive pas à dissiper %5$s %4$s.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s n'arrive pas à dissiper %5$s %4$s.",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "draine",
ACTION_SPELL_DRAIN_FULL_TEXT = "%2$s %1$s draine %9$s points |2 %8$s |2 %4$s.",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s draine %9$s %8$s |2 %4$s.",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "perte de durabilité",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "perte de durabilité complète",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%2$s %1$s endommage %4$s : tous les objets sont abîmés.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%2$s %1$s endommage %4$s : %5$s abîmé(e).",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "dynamise",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s gagne %9$s points |2 %8$s |2 %2$s %1$s.",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gagne %9$s points |2 %8$s |2 %2$s.",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "%9$s %8$s gagné",
ACTION_SPELL_EXTRA_ATTACKS = "confère des attaques supplémentaires",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s gagne %9$s attaques supplémentaires grâce à %2$s.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "%9$s attaques supplémentaires conférées par %2$s.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "soigne",
ACTION_SPELL_HEAL_FULL_TEXT = "%2$s %1$s soigne %4$s pour %9$s points.%6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s soigne %4$s pour %9$s points.%6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "tue",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%2$s %1$s tue instantanément %4$s.",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s tue instantanément %4$s.",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "assommé",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%2$s %1$s assomme %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s assomme %4$s.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "interrompt",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%2$s %1$s interrompt %5$s %4$s.",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s interrompt %5$s %4$s.",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "draine",
ACTION_SPELL_LEECH_FULL_TEXT = "%2$s %1$s draine %9$s points |2 %8$s |2 %4$s. %1$s gagne %10$s points |2 %8$s.",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s draine %9$s points |2 %8$s |2 %4$s.",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "%10$s points |2 %8$s gagnés",
ACTION_SPELL_MISSED = "rate",
ACTION_SPELL_MISSED_ABSORB = "Absorbé",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%2$s %1$s est absorbé par %4$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s est absorbé par %4$s.%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "Bloqué",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%2$s %1$s est bloqué par %4$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s est bloqué par %4$s.%6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "Dévie",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%2$s %1$s est dévié par %4$s.",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s est dévié par %4$s.",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "Esquive",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%2$s %1$s est esquivé par %4$s.",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s est esquivé par %4$s.",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "Évite",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%2$s %1$s est évité par %4$s.",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%2$s est évité par %4$s.",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%2$s %1$s rate %4$s.",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s rate %4$s.",
ACTION_SPELL_MISSED_IMMUNE = "Insensible",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%2$s %1$s a échoué. %4$s est insensible.",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s a échoué. %4$s est insensible.",
ACTION_SPELL_MISSED_MISFIRE = "Tir accidentel",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%2$s %1$s a touché %4$s par accident.",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s a touché %4$s par accident.",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "Raté",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%2$s %1$s rate %4$s.",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s rate %4$s.",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "Pare",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%2$s %1$s est paré par %4$s.",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s est paré par %4$s.",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "renvoyé",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%2$s %1$s est renvoyé par %4$s.",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%2$s est renvoyé par %4$s.",
ACTION_SPELL_MISSED_RESIST = "résiste",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%2$s %1$s a échoué, %4$s résiste entièrement.%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s a échoué, %4$s résiste entièrement.%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "inflige des dégâts",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s reçoit %5$s de dégâts |2 %2$s %1$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s reçoit %5$s de dégâts |2 %2$s.%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "draine",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%2$s %1$s draine %9$s %8$s |2 %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s draine %9$s points |2 %8$s |2 %4$s.",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "dynamise",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s gagne %9$s %8$s |2 %2$s %1$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s gagne %9$s points |2 %8$s |2 %2$s.",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "$extraAmount %8$s gagné",
ACTION_SPELL_PERIODIC_HEAL = "soigne",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s gagne %9$s points de vie |2 %2$s %1$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s gagne %9$s points de vie |2 %2$s.%6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "draine",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%2$s %1$s draine %9$s points |2 %8$s |2 %4$s. %1$s gagne %10$s points |2 %8$s.",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s draine %9$s points |2 %8$s |2 %4$s. %1$s gagne %10$s points |2 %8$s.",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(%10$s points |2 %8$s gagnés)",
ACTION_SPELL_PERIODIC_MISSED = "rate",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s absorbée)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%2$s %1$s est absorbé par %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s est absorbé par %4$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "(Itération bloquée)",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%2$s %1$s a été bloqué par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s a été bloqué par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(Itération déviée)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%2$s %1$s a été dévié par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%2$s a été dévié par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "(Itération esquivée)",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%2$s %1$s a été esquivé par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s a été esquivé par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(Itération évitée)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%2$s %1$s a été évité par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s a été évité par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%2$s %1$s n'affecte pas %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s n'affecte pas %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "(Insensible)",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s était insensible à %2$s %1$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s était insensible à %2$s.%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "(Itération échouée)",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "%2$s %1$s a raté %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s a raté %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "(Itération parée)",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%2$s %1$s a été paré par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s a été paré par %4$s pour un temps.%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "(Itération résistée)",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%2$s %1$s n'affecte pas %4$s. %4$s résiste.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s n'affecte pas %4$s. %4$s résiste.%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "Ressuscite",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%2$s %1$s ressuscite %4$s.%6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s ressuscite %4$s.%6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "vole",
ACTION_SPELL_STOLEN_BUFF = "vole",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%2$s %1$s vole %5$s %4$s.",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s vole %5$s %4$s.",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "vole",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%2$s %1$s transfère $extraSpell %4$s à %1$s.",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s transfère $extraSpell %4$s.",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%2$s %1$s vole %5$s %4$s.",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s vole %5$s %4$s.",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "invoque",
ACTION_SPELL_SUMMON_FULL_TEXT = "%2$s %1$s invoque %4$s.%6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s invoque %4$s.%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "Coup",
ACTION_SWING_DAMAGE = "touche",
ACTION_SWING_DAMAGE_FULL_TEXT = "Le coup %1$s touche %4$s pour %5$s.%6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "Un coup touche %4$s pour %5$s.%6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "rate",
ACTION_SWING_MISSED_ABSORB = "(Absorbe)",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "L'attaque %1$s est absorbée par %4$s.%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "(Bloque)",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "L'attaque %1$s est bloquée par %4$s.%6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(Dévie)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "L'attaque %1$s est déviée par %4$s.",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "(Esquive)",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "L'attaque %1$s est esquivée par %4$s.",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(Évite)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "L'attaque %1$s est évitée par %4$s.",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "L'attaque %1$s rate %4$s.",
ACTION_SWING_MISSED_IMMUNE = "(Insensible)",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "L'attaque %1$s a échoué, %4$s est insensible.",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(Tir accidentel)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "L'attaque %1$s a touché %4$s par accident.",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(Raté)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "L'attaque %1$s rate %4$s.",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "(Parade)",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "L'attaque %1$s est parée par %4$s.",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "(Résistance)",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "L'attaque %1$s a échoué, %4$s résiste entièrement.%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "s'évanouit",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s s'évanouit.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "détruit",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s a été détruit.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "meurt",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s meurt.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "se dissipe",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s se dissipe.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "Ajouter",
ADDITIONAL_FILTERS = "Filtres supplémentaires",
ADD_FILTER = "Aj. filtre",
AURAS = "Auras",
AURAS_COMBATLOG_TOOLTIP = "Montre les messages liés aux états bénéfiques ou néfastes.",
BENEFICIAL = "Bénéfique",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "Montre quand vous gagnez ou perdez une aura bénéfique.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "Afficher tout ce qui concerne %s.",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "Afficher tout",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "Qu'est-il arrivé à %s ?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "Qu'a fait %s ?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "Qu'est-ce que %s vous a fait ?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "Réinitialiser",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "Enregistrer comme nouveau filtre",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "Cacher les messages comme celui-ci.",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "Lier %s dans la discussion.",
BY_SOURCE = "Par source",
BY_SOURCE_COMBATLOG_TOOLTIP = "Colorer en fonction du lanceur.",
BY_TARGET = "Par cible",
BY_TARGET_COMBATLOG_TOOLTIP = "Colorer en fonction de la cible.",
COLORIZE = "Coloriser :",
COLORS = "Couleurs",
COLOR_BY_SCHOOL = "Couleur par type",
COMBATLOG_DEFAULTS = "Journal par défaut",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "Unité personnalisée",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "Amis",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "Joueurs ennemis",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "Ennemis",
COMBATLOG_FILTER_STRING_ME = "Moi",
COMBATLOG_FILTER_STRING_MY_PET = "Familier",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "Neutre",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "Inconnu",
COMBATLOG_HIGHLIGHT_ABILITY = "Technique",
COMBATLOG_HIGHLIGHT_DAMAGE = "Dégâts",
COMBATLOG_HIGHLIGHT_KILL = "Mort",
COMBATLOG_HIGHLIGHT_SCHOOL = "Type",
COMBATLOG_UNKNOWN_UNIT = "Quelque chose",
COMBAT_FACTION_CHANGE = "Réputation",
COMBAT_HONOR_GAIN = "Honneur",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "Infos div.",
COMBAT_XP_GAIN = "Expérience",
CONFIRM_COMBAT_FILTER_DEFAULTS = "Voulez-vous revenir aux valeurs par défaut des filtres ?",
CONFIRM_COMBAT_FILTER_DELETE = "Voulez-vous vraiment effacer ce filtre ?",
COPY_FILTER = "Copier filtre",
DAMAGE_NUMBER = "Valeurs de dégâts",
DAMAGE_SCHOOL_TEXT = "Type de dégâts",
DAMAGE_SHIELD = "Boucliers de dégâts",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique inflige des dégâts en réaction à une attaque de mêlée, comme Epines.",
DEATHS_COMBATLOG_TOOLTIP = "Montre un message quand quelqu'un meurt.",
DEFAULT_COMBATLOG_FILTER_NAME = "Filtre %d",
DISPELS = "Dissipations",
DISPEL_AURA_COMBATLOG_TOOLTIP = "Montre quand une aura est retirée, détruite ou volée.",
DONE_BY = "Fait par :",
DONE_TO = "Fait à :",
DRAINS = "Drains",
ENTER_FILTER_NAME = "Indiquez le nom du filtre :",
ENTIRE_LINE = "Ligne entière",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "Colorer toute la ligne selon la sélection ci-dessous.",
ENVIRONMENTAL_DAMAGE = "Dégâts de l'environnement",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "Montre un message quand quelqu'un subit des dégâts dus à une chute, une noyade ou le fait de nager dans la lave.",
EXAMPLE_SPELL_FIREBALL = "Boule de feu",
EXAMPLE_SPELL_FROSTBOLT = "Eclair de givre",
EXAMPLE_TARGET_MONSTER = "Monstre",
EXAMPLE_TEXT = "Texte d'exemple",
EXTRA_ATTACKS = "Attaques suppl.",
FAILURES = "Échecs",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "Les actions effectuées par les créatures et familiers hostiles.",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "Les actions effectuées par les personnages, familiers et créatures amicaux.",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Les actions effectuées par des joueurs hostiles.",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "Les actions effectuées par vous-même, vos pièges et vos sorts.",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "Les actions effectuées par les créatures neutres.",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "Les actions effectuées par vos familiers, gardiens invoqués ou personnages charmés.",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "Les actions effectuées par des sources indéfinies, telles que les chutes, l'acide ou la lave.",
FILTER_NAME = "Nom du filtre :",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "Les actions effectuées sur les personnages, familiers et créatures amicaux.",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "Les actions effectuées sur les familiers et créatures hostiles.",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Les actions effectuées contre des joueurs hostiles.",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "Les actions effectuées sur vous.",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "Les actions effectuées sur les créatures neutres.",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "Les actions effectuées sur vos familiers, gardiens invoqués ou personnages charmés.",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "Les actions effectuées sur des cibles invisibles.",
FORMATTING = "Mise en forme",
FULL_TEXT_COMBATLOG_TOOLTIP = "Montre les évènements du journal de combat sous forme de phrases.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "Montre quand vous gagnez ou perdez une aura néfaste.",
HEALS = "Soins",
HIGHLIGHTING = "Surlignage :",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "Surligne les noms des techniques dans les messages de combat.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "Surligne les montants de dégâts dans les messages de combat.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "Surligne toute la ligne lorsque vous-même ou un membre de votre groupe tuez un adversaire.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "Surligne les types de sort dans les messages de combat.",
HOSTILE = "Hostile",
INTERRUPTS = "Interruptions",
ITEM_NAMES = "Noms des objets",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mettre des liens autour des noms d'objets.",
KILLS_COMBATLOG_TOOLTIP = "Montre un message quand un membre de votre groupe tue quelqu'un.",
MELEE = "Mêlée",
MELEE_COMBATLOG_TOOLTIP = "Montre les attaques de mêlée naturelles.",
MESSAGE_SOURCES = "Sources",
MISSES = "Ratés",
MOVE_FILTER_DOWN = "Descendre le filtre",
MOVE_FILTER_UP = "Remonter le filtre",
OTHER = "Autre",
PERIODIC = "Périodique",
POWER_GAINS = "Gains de puissance",
POWER_GAINS_COMBATLOG_TOOLTIP = "Affiche un message quand un sort ou une technique rend des points de mana, d’énergie, de rage, de focalisation, de chi ou de puissance sacrée ou des orbes d’ombre.",
QUICKBUTTON_NAME_EVERYTHING = "Tout",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "Montrer tous les messages de combat.",
QUICKBUTTON_NAME_KILLS = "Tués",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "Montrer tous les tués.",
QUICKBUTTON_NAME_ME = "Qu'est-ce qui m'est arrivé ?",
QUICKBUTTON_NAME_ME_TOOLTIP = "Montrer tout ce qu'on m'a fait.",
QUICKBUTTON_NAME_SELF = "Soi-même",
QUICKBUTTON_NAME_SELF_TOOLTIP = "Montre des messages pour les actions effectuées par vous et sur vous.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "Pose un raccourci vers ce filtre dans la fenêtre de discussion.",
RANGED = "Distance",
RANGED_COMBATLOG_TOOLTIP = "Montre les attaques des arcs, arbalètes, fusils, armes de jet et baguettes.",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "Montre les attaques à distance qui infligent des dégâts complets ou partiels.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "Montre les attaques à distance qui n'infligent pas de dégâts.",
RESURRECT = "Résurrections",
SETTINGS = "Réglages",
SHOW_BRACES = "Afficher les crochets",
SHOW_BRACES_COMBATLOG_TOOLTIP = "Afficher des crochets autour des liens dans les messages du journal de combat.",
SHOW_QUICK_BUTTON = "Montrer accès rapide",
SHOW_TIMESTAMP = "Afficher l'heure",
SOURCE = "Source :",
SPECIAL = "Spécial",
SPELLS_COMBATLOG_TOOLTIP = "Montre les messages liés aux sorts et aux techniques spéciales.",
SPELL_CASTING = "Incantations",
SPELL_CASTING_COMBATLOG_TOOLTIP = "Montre les messages concernant l'incantation des sorts.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "Montre les messages indiquant qu'un sort ne peut être lancé ou que l'incantation a échoué.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "Montre les messages indiquant le début de l'incantation d'un sort.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "Montre les messages indiquant la réussite de l'incantation d'un sort.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "Colorer les noms des sorts par type.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "Montre quand un sort ou une technique inflige des dégâts.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "Colorer les valeurs de dégâts pour les attaques hors-mêlée.",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "Colorer les noms des types de dégâts (par ex. Ombre).",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "Affiche un message quand un sort ou une technique enlève des points de mana, d’énergie, de rage ou de focalisation.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "Affiche un message quand un sort ou une technique octroie des attaques supplémentaires.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique soigne des dégâts.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "Montre les messages des sorts d'une catégorie spéciale, comme ceux qui infligent une perte de durabilité ou qui partagent les dégâts avec un familier.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique interrompt un autre sort.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique ne parvient pas à infliger des dégâts. Que ce soit dû à une esquive, une parade, un blocage, une déviation, une immunité, une absorption ou un évitement.",
SPELL_NAMES = "Noms des sorts",
SPELL_NAMES_COMBATLOG_TOOLTIP = "Colorer les noms de sorts.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mettre des liens autour des noms de sorts.",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "Montre les sorts qui ont un effet incrémentiel.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique inflige des dégâts de façon périodique, comme Mot de l'ombre : Douleur ou Corruption.",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique soigne de façon périodique, comme Rénovation ou Récupération.",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique ne parvient pas à infliger des dégâts périodiques. Cela peut être dû à une immunité, une absorption ou un évitement.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique déclenche un autre type d'effet de façon périodique, comme de rendre ou de prendre des points de mana.",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique ressuscite une créature ou un autre personnage.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "Montre un message quand un sort ou une technique invoque une créature ou crée un objet.",
START = "Démarrage",
STRING_SCHOOL_UNKNOWN = "(Inconnu)",
SUCCESS = "Réussites",
SUMMONS = "Invocations",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "Montre les attaques de mêlée qui infligent des dégâts complets ou partiels.",
SWING_MISSED_COMBATLOG_TOOLTIP = "Montre les attaques de mêlée qui n'infligent pas de dégâts.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %3$s %2$s %4$s %5$s. %6$s",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "|2 %s",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(%s restant)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s absorbé)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s bloqué)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(Critique)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(Critique)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(Écrasement)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultType : $resultAmount",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(Éraflure)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(Frappe multiple)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(Excès d'énergie %s)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(Excès de soins %s)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(Excès de dégâts %s)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d paré)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "Renvoyé",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s résisté)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s de dégâts de vulnérabilité)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s %s",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "Afficher l'heure des messages du journal de combat.",
UNIT_COLORS = "Couleurs d'unités :",
UNIT_NAMES = "Noms des unités",
UNIT_NAMES_COMBATLOG_TOOLTIP = "Colorer les noms des unités.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Mettre des liens autour des noms d'unités.",
UNIT_YOU = "Vous",
UNIT_YOU_DEST = "Vous",
UNIT_YOU_DEST_POSSESSIVE = "votre personnage",
UNIT_YOU_SOURCE = "Vous",
UNIT_YOU_SOURCE_POSSESSIVE = "votre",
USE_FULL_TEXT_MODE = "Mode prolixe",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (KR) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["koKR"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "피해",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; 공격했지만 %4$s|1이;가; %9$s의 %7$s 피해를 반사했습니다. %6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; 공격했지만 %4$s|1이;가; %9$s의 %7$s 피해를 반사했습니다. %6$s",
ACTION_DAMAGE_SHIELD_MISSED = "적중하지 않음",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "방어함",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 방어했습니다. %6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 방어했습니다. %6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(튕김)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 튕겨냈습니다.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 튕겨냈습니다.",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "피함",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 교묘히 피했습니다.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 교묘히 피했습니다.",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(벗어남)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 벗어났습니다.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 벗어났습니다.",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "면역",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%1$s의 %2$s|1이;가; 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(빗나감)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "막음",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 막았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 막았습니다.",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "저항함",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 모두 저항했습니다. %6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 모두 저항했습니다. %6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "피해 분배",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%1$s의 %2$s|1으로;로; 인한 피해가 %4$s에게 흡수되었습니다. %6$s",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s에게 %9$s의 피해를 입혔습니다.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%1$s의 %2$s|1이;가; %4$s에게 %9$s의 피해를 입혔습니다. %6$s",
ACTION_ENCHANT_APPLIED = "마법부여 사용",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s|1이;가; %4$s의 %5$s에 %2$s|1을;를; 사용합니다.",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "마법부여 사라짐",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%4$s의 %5$s에서 %2$s 효과가 사라집니다.",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "피해",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "호흡 불가",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s|1이;가; 숨을 쉴 수 없어 %9$s의 피해를 입었습니다.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "낙하 충격",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s|1이;가; 낙하할 때의 충격으로 %9$s의 피해를 입었습니다.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "피로",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s|1이;가; 피로로 %9$s의 피해를 입었습니다.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "화염",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s|1이;가; %9$s의 화염 피해를 입었습니다.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s|1이;가; 환경에 의해 %9$s의 피해를 입었습니다.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "용암",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s|1이;가; 용암의 열기로 인해 %9$s의 피해를 입었습니다. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "독성",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s|1이;가; 독성으로 인해 %9$s의 피해를 입었습니다. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "죽임",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 죽였습니다.",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "기절",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 기절시켰습니다!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "원거리 공격",
ACTION_RANGE_DAMAGE = "피해",
ACTION_RANGE_DAMAGE_FULL_TEXT = "%1$s|1이;가; 원거리 공격으로 %4$s에게 %5$s의 피해를 입혔습니다. %6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "원거리 공격으로 %4$s|1이;가; %5$s의 피해를 입었습니다. %6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "적중하지 않음",
ACTION_RANGE_MISSED_ABSORB = "흡수됨",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격했지만 피해가 흡수되었습니다. %6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "방어함",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%4$s|1이;가; %1$s의 원거리 공격을 방어했습니다. %6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(튕김)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격했지만 튕겨냈습니다.",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "피함",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%1$s|1이;가; 원거리로 공격했지만 %4$s|1이;가; 교묘히 피했습니다.",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(벗어남)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격했지만 빗나갔습니다.",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격했지만 적중하지 않았습니다.",
ACTION_RANGE_MISSED_IMMUNE = "면역",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "%1$s의 원거리 공격이 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(공격 실패)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격하려 했지만 실패했습니다.",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(빗나감)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 원거리로 공격했지만 적중하지 않았습니다.",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "막음",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%1$s|1이;가; 원거리로 공격했지만 %4$s|1이;가; 막았습니다.",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "저항함",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%4$s|1이;가; %1$s의 원거리 공격을 모두 저항했습니다. %6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "효과 적용",
ACTION_SPELL_AURA_APPLIED_BUFF = "사용",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s 효과를 얻었습니다.",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s 효과를 얻었습니다.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s 효과를 얻었습니다. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s 효과를 얻었습니다. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "걸림",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s에 걸렸습니다.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s에 걸렸습니다.",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s에 걸렸습니다. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s에 걸렸습니다. %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "겹쳐짐",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "겹쳐짐",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s 효과를 얻었습니다. (%9$s)",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s 효과를 얻었습니다. (%9$s)",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "걸림",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s에 걸렸습니다. (%9$s)",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s에 걸렸습니다. (%9$s)",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "파괴",
ACTION_SPELL_AURA_BROKEN_BUFF = "파괴",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s|1을;를; 해제했습니다.",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "%1$s의 %2$s|1이;가; 해제되었습니다.",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "파괴",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s|1을;를; 해제했습니다.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%1$s의 %2$s|1이;가; 해제되었습니다.",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "파괴",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s|1이;가; %5$s|1으로;로; %4$s의 %2$s|1을;를; 해제했습니다.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s|1으로;로; %4$s의 %2$s|1이;가; 해제되었습니다.",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "파괴",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s|1이;가; %5$s|1으로;로; %4$s의 %2$s|1을;를; 해제했습니다.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s|1으로;로; %4$s의 %2$s|1이;가; 해제되었습니다.",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "지속시간 초기화",
ACTION_SPELL_AURA_REFRESH_BUFF = "지속시간 초기화",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s 효과를 초기화합니다.",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "%4$s의 %2$s 주문 지속시간이 초기화됩니다.",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s 효과를 초기화합니다. %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s의 %2$s 주문 지속시간이 초기화됩니다. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "지속시간 초기화",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s 효과를 초기화합니다.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s의 %2$s 주문 지속시간이 초기화됩니다.",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s|1이;가; %4$s의 %2$s 효과를 초기화합니다. %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s의 %2$s 주문 지속시간이 초기화됩니다. %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "제거",
ACTION_SPELL_AURA_REMOVED_BUFF = "효과 사라짐",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "%4$s에게서 %1$s의 %2$s 효과가 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s에게서 %2$s 효과가 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s에게서 %1$s의 %2$s 효과가 사라졌습니다. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s에게서 %2$s 효과가 사라졌습니다. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "사라짐",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "%1$s의 %2$s|1이;가; %4$s에게서 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s에게서 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s의 %2$s|1이;가; %4$s에게서 사라졌습니다. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s에게서 사라졌습니다. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "감소",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "감소",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%1$s의 %2$s(%9$s) 효과가 감소했습니다.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s(%9$s) 효과가 감소했습니다.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "감소",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%2$s(%9$s)|1이;가; %1$s에게서 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s(%9$s)|1이;가; 사라졌습니다.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "%1$s의 %2$s|1이;가; %4$s에게서 제거되었습니다.",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "%1$s의 %2$s|1이;가; %4$s에게서 제거되었습니다.",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "손상",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격하여 %5$s의 피해를 입혔습니다. %6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격하여 %5$s의 피해를 입혔습니다. %6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "수리",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 체력이 %9$s만큼 복구되었습니다. %6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 체력이 %9$s만큼 복구되었습니다. %6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "사용 실패",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%1$s|1이;가; %2$s 시전에 실패했습니다. %6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "시전 시작",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s|1이;가; %4$s에게 %2$s 시전을 시작합니다.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s|1이;가; %2$s 시전을 시작합니다.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "무엇인가가 %4$s에게 %2$s 시전을 시작합니다.",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "시전",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s|1이;가; %4$s에게 %2$s|1을;를; 시전합니다.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s|1이;가; %2$s|1을;를; 시전합니다.",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "무엇인가가 %4$s에게 %2$s 시전을 시작합니다.",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "만듦",
ACTION_SPELL_CREATE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 만들었습니다. %6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 만들었습니다. %6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "피해",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s에게 %5$s의 피해를 입혔습니다. %6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1이;가; %5$s의 피해를 입었습니다. %6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "무효화",
ACTION_SPELL_DISPEL_BUFF = "무효화",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%4$s의 %5$s|1이;가; %1$s의 %2$s|1으로;로; 무효화되었습니다.",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%4$s의 %5$s|1이;가; %2$s|1으로;로; 무효화되었습니다.",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "해제",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%4$s의 %5$s|1이;가; %1$s의 %2$s|1으로;로; 해제되었습니다.",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s의 %5$s|1이;가; %2$s|1으로;로; 해제되었습니다.",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "무효화 실패",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s에게 걸려 있는 %5$s|1을;를; 무효화하지 못했습니다.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s에게 걸려 있는 %5$s|1을;를; 무효화하지 못했습니다.",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "소진",
ACTION_SPELL_DRAIN_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s의 %8$s|1을;를; %9$s만큼 소진시켰습니다.",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s의 %8$s|1을;를; %9$s만큼 소진시켰습니다.",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "내구도 감소",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "전체 내구도 감소",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s에게 피해를 입혔습니다: 모든 아이템의 내구도가 감소했습니다.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s에게 피해를 입혔습니다: %5$s|1이;가; 손상되었습니다.",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "얻음",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1으로;로; %9$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1으로;로; %9$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "%9$s %8$s 얻음",
ACTION_SPELL_EXTRA_ATTACKS = "추가 공격",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %9$s회의 추가 공격 기회를 얻었습니다.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %9$s회의 추가 공격 기회를 얻었습니다.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "생명력 회복",
ACTION_SPELL_HEAL_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 생명력이 %9$s만큼 회복되었습니다. %6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 생명력이 %9$s만큼 회복되었습니다. %6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "죽임",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; 즉시 %4$s|1을;를; 죽였습니다.",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; 즉시 %4$s|1을;를; 죽였습니다.",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "기절",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s|1이;가; %4$s|1을;를; 기절시킵니다.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s|1을;를; 기절시킵니다.",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "차단",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s의 %5$s|1을;를; 차단했습니다.",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %5$s|1을;를; 차단했습니다.",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "소진",
ACTION_SPELL_LEECH_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 %8$s|1이;가; %9$s만큼 소진되었습니다. %1$s|1이;가; %10$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %8$s|1이;가; %9$s만큼 소진되었습니다.",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "%10$s %8$s 얻음",
ACTION_SPELL_MISSED = "적중하지 않음",
ACTION_SPELL_MISSED_ABSORB = "흡수됨",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 피해가 흡수되었습니다. %6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 피해가 흡수되었습니다. %6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "방어함",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 방어했습니다. %6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 방어했습니다. %6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "튕김",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 튕겨냈습니다.",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 튕겨냈습니다.",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "피함",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 교묘히 피했습니다.",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 교묘히 피했습니다.",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "벗어남",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 빗나갔습니다.",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 벗어났습니다.",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s에게 적중하지 않았습니다.",
ACTION_SPELL_MISSED_IMMUNE = "면역",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%1$s의 %2$s|1이;가; 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_SPELL_MISSED_MISFIRE = "공격 실패",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격하려 했지만 실패했습니다.",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격하는 데 실패했습니다.",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "빗나감",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s에게 적중하지 않았습니다.",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "막음",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 공격했지만 막았습니다.",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 공격했지만 막았습니다.",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "반사함",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 반사했습니다.",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 반사했습니다.",
ACTION_SPELL_MISSED_RESIST = "저항함",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1을;를; 모두 저항했습니다. %6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1을;를; 모두 저항했습니다. %6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "피해",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1으로;로; %5$s의 피해를 입었습니다. %6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1으로;로; %5$s의 피해를 입었습니다. %6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "소진",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s의 %8$s|1을;를; %9$s만큼 소진시켰습니다.",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %8$s|1이;가; %9$s만큼 소진되었습니다.",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "얻음",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s|1으로;로; %9$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s|1으로;로; %9$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "$extraAmount %8$s 얻음",
ACTION_SPELL_PERIODIC_HEAL = "생명력 회복",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 생명력이 %9$s만큼 회복되었습니다. %6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 생명력이 %9$s만큼 회복되었습니다. %6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "소진",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 %8$s|1이;가; %9$s만큼 소진되었습니다. %1$s|1이;가; %10$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %8$s|1이;가; %9$s만큼 소진되었습니다. %1$s|1이;가; %10$s의 %8$s|1을;를; 얻었습니다.",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(%10$s %8$s 얻음)",
ACTION_SPELL_PERIODIC_MISSED = "적중하지 않음",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s 흡수됨)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%1$s의 %2$s|1이;가; 흡수되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 흡수되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "일시적으로 방어함",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 방어되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 방어되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(일시적으로 튕김)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 튕겨 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 튕겨 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "일시적으로 피함",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 회피되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 회피되어 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(일시적으로 벗어남)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 벗어나 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 벗어나 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "면역",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s|1이;가; %1$s의 %2$s에 면역입니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s|1이;가; %2$s에 면역입니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "일시적으로 적중하지 않음",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 적중하지 않아 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 적중하지 않아 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "일시적으로 막음",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%1$s의 %2$s|1이;가; 일시적으로 막혀 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; 일시적으로 막혀 %4$s에게 피해를 주지 못했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "일시적으로 저항함",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%1$s의 %2$s|1이;가; %4$s에게 피해를 주지 못했습니다. %4$s|1이;가; 저항했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s|1이;가; %4$s에게 피해를 주지 못했습니다. %4$s|1이;가; 저항했습니다. %6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "부활함",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 부활시켰습니다. %6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 부활시켰습니다. %6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "훔침",
ACTION_SPELL_STOLEN_BUFF = "훔침",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s의 %5$s|1을;를; 훔쳤습니다.",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %5$s|1을;를; 훔쳤습니다.",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "훔침",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%1$s의 %2$s|1으로;로; %4$s의 $extraSpell|1이;가; %1$s에게 이전되었습니다.",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 $extraSpell|1이;가; 이전되었습니다.",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s의 %5$s|1을;를; 훔쳤습니다.",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s의 %5$s|1을;를; 훔쳤습니다.",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "소환",
ACTION_SPELL_SUMMON_FULL_TEXT = "%1$s|1이;가; %2$s|1으로;로; %4$s|1을;를; 소환했습니다. %6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s|1으로;로; %4$s|1을;를; 소환했습니다. %6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "근접 공격",
ACTION_SWING_DAMAGE = "피해",
ACTION_SWING_DAMAGE_FULL_TEXT = "%1$s|1이;가; 근접 공격으로 %4$s에게 %5$s의 피해를 입혔습니다. %6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "근접 공격으로 %4$s|1이;가; %5$s의 피해를 입었습니다. %6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "적중하지 않음",
ACTION_SWING_MISSED_ABSORB = "흡수됨",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격했지만 피해가 흡수되었습니다. %6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "방어함",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%1$s|1이;가; %4$s의 공격을 방어했습니다. %6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(튕김)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격했지만 튕겨냈습니다.",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "피함",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%4$s|1이;가; %1$s의 공격을 교묘히 피했습니다.",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(벗어남)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격했지만 벗어났습니다.",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_SWING_MISSED_IMMUNE = "면역",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "%1$s의 공격이 실패했습니다. %4$s|1은;는; 면역입니다.",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(공격 실패)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격하려 했지만 실패했습니다.",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(빗나감)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "%1$s|1이;가; %4$s|1을;를; 공격했지만 적중하지 않았습니다.",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "막음",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%4$s|1이;가; %1$s의 공격을 막았습니다.",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "저항함",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%4$s|1이;가; %1$s의 공격을 모두 저항했습니다. %6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "쓰러짐",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s|1이;가; 쓰러집니다.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "파괴됨",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s|1이;가; 파괴되었습니다.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "죽음",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s|1이;가; 죽었습니다.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "사라짐",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s|1이;가; 사라집니다.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "추가",
ADDITIONAL_FILTERS = "추가 필터",
ADD_FILTER = "필터 추가",
AURAS = "오라",
AURAS_COMBATLOG_TOOLTIP = "이로운 효과나 해로운 효과에 대한 메시지를 표시합니다.",
BENEFICIAL = "이로운 효과",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "강화 효과를 얻거나 잃었을 때 메시지를 표시합니다.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "%s|1과;와; 관련된 기록을 모두 보여주십시오.",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "모두",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "%s에게 무슨 일이 일어났습니까?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "%s|1이;가; 무엇을 했습니까?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "%s|1이;가; 당신에게 무엇을 했습니까?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "원래대로",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "새 필터로 저장",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "같은 종류의 메시지 숨기기",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "%s|1을;를; 대화창으로 링크",
BY_SOURCE = "행위자",
BY_SOURCE_COMBATLOG_TOOLTIP = "행위자를 기준으로 문장에 색을 입힙니다.",
BY_TARGET = "대상",
BY_TARGET_COMBATLOG_TOOLTIP = "대상을 기준으로 문장에 색을 입힙니다.",
COLORIZE = "색 지정",
COLORS = "색상",
COLOR_BY_SCHOOL = "마법 계열별 색 설정",
COMBATLOG_DEFAULTS = "원래대로",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "사용자 개체",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "친구",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "적대적인 플레이어",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "적대적 대상",
COMBATLOG_FILTER_STRING_ME = "자신",
COMBATLOG_FILTER_STRING_MY_PET = "소환수",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "중립적 대상",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "알 수 없음",
COMBATLOG_HIGHLIGHT_ABILITY = "주문 및 기술",
COMBATLOG_HIGHLIGHT_DAMAGE = "피해",
COMBATLOG_HIGHLIGHT_KILL = "처치",
COMBATLOG_HIGHLIGHT_SCHOOL = "마법 계열",
COMBATLOG_UNKNOWN_UNIT = "무엇인가",
COMBAT_FACTION_CHANGE = "평판",
COMBAT_HONOR_GAIN = "명예",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "기타 정보",
COMBAT_XP_GAIN = "경험치",
CONFIRM_COMBAT_FILTER_DEFAULTS = "정말 필터를 초기화하시겠습니까?",
CONFIRM_COMBAT_FILTER_DELETE = "정말 이 필터를 삭제하시겠습니까?",
COPY_FILTER = "필터 복사",
DAMAGE_NUMBER = "피해 수치",
DAMAGE_SCHOOL_TEXT = "마법 계열",
DAMAGE_SHIELD = "피해 보호막",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "근접 공격자에게 피해를 입히는 주문이나 능력으로 인한 피해 메시지를 표시합니다. 예: 가시 등",
DEATHS_COMBATLOG_TOOLTIP = "무엇인가가 죽었을 때 메시지를 표시합니다.",
DEFAULT_COMBATLOG_FILTER_NAME = "필터: %d",
DISPELS = "무효화",
DISPEL_AURA_COMBATLOG_TOOLTIP = "효과가 제거되거나, 파괴되거나, 훔쳐졌을 때 메시지를 표시합니다.",
DONE_BY = "행위자",
DONE_TO = "대상",
DRAINS = "소진",
ENTER_FILTER_NAME = "필터 이름을 입력하십시오.",
ENTIRE_LINE = "전체 문장",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "아래 선택에 따라 전체 문장에 색을 입힙니다.",
ENVIRONMENTAL_DAMAGE = "환경 피해",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "낙하, 익사, 용암에 의한 피해를 입었을 때 메시지를 표시합니다.",
EXAMPLE_SPELL_FIREBALL = "화염구",
EXAMPLE_SPELL_FROSTBOLT = "얼음 화살",
EXAMPLE_TARGET_MONSTER = "몬스터",
EXAMPLE_TEXT = "예시 문구",
EXTRA_ATTACKS = "추가 공격",
FAILURES = "실패",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "적대적인 NPC, 소환수의 동작",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "아군 플레이어, 소환수, NPC의 동작",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "적대적인 플레이어의 동작",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "자신, 자신의 덫, 자신의 주문에 의한 동작",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "중립적 NPC의 동작",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "자신의 소환수, 소환된 수호물, 자신이 현혹한 플레이어의 동작",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "낙하 피해, 독, 용암 등에 의한 동작",
FILTER_NAME = "필터 이름",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "아군 플레이어, 소환수, NPC에게 행해진 동작",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "적대적인 소환수, NPC에게 행해진 동작",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "적대적인 플레이어에게 행해진 동작",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "자신에게 행해진 동작",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "중립적 NPC에게 행해진 동작",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "자신의 소환수, 소환된 수호물, 자신이 현혹한 플레이어에게 행해진 동작",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "보이지 않는 대상에게 행해진 동작",
FORMATTING = "형식",
FULL_TEXT_COMBATLOG_TOOLTIP = "전투 메시지를 전체 문장으로 표시합니다.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "약화 효과를 얻거나 잃었을 때 메시지를 표시합니다.",
HEALS = "치유",
HIGHLIGHTING = "강조",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "전투 메시지 상에서 능력의 이름을 강조합니다.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "전투 메시지 상에서 피해의 수치를 강조합니다.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "자신이나 파티원이 대상을 처치했을 때 메시지를 강조합니다.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "전투 메시지 상에서 주문의 마법 계열을 강조합니다.",
HOSTILE = "해로운 효과",
INTERRUPTS = "차단",
ITEM_NAMES = "아이템 이름",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "아이템에 괄호 표시",
KILLS_COMBATLOG_TOOLTIP = "파티원이 어떤 대상을 처치했을 때 메시지를 표시합니다.",
MELEE = "근접 공격",
MELEE_COMBATLOG_TOOLTIP = "근접 공격에 관련된 메시지를 표시합니다.",
MESSAGE_SOURCES = "메시지 출처",
MISSES = "적중하지 않음",
MOVE_FILTER_DOWN = "필터를 아래로 이동",
MOVE_FILTER_UP = "필터를 위로 이동",
OTHER = "기타",
PERIODIC = "주기적인 효과",
POWER_GAINS = "얻은 자원",
POWER_GAINS_COMBATLOG_TOOLTIP = "주문이나 능력으로 마나, 기력, 분노, 집중, 기, 신성한 힘, 암흑 구슬이 회복될 때 메시지를 표시합니다.",
QUICKBUTTON_NAME_EVERYTHING = "모두",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "모든 전투 메시지를 표시합니다.",
QUICKBUTTON_NAME_KILLS = "처치",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "처치 및 죽음에 대한 메시지를 표시합니다.",
QUICKBUTTON_NAME_ME = "자신(대상)",
QUICKBUTTON_NAME_ME_TOOLTIP = "자신에게 행해진 모든 내용을 표시합니다.",
QUICKBUTTON_NAME_SELF = "자신",
QUICKBUTTON_NAME_SELF_TOOLTIP = "자신의 행위와 자신에게 행해진 행위에 대한 메시지를 표시합니다.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "대화창에 필터를 추가합니다.",
RANGED = "원거리 공격",
RANGED_COMBATLOG_TOOLTIP = "활, 총, 투척 무기, 마법봉 공격 메시지를 표시합니다.",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "원거리 공격으로 입힌 전체 피해나 부분적인 피해를 표시합니다.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "피해를 입히지 못한 원거리 공격에 대한 메시지를 표시합니다.",
RESURRECT = "부활",
SETTINGS = "설정",
SHOW_BRACES = "괄호 표시",
SHOW_BRACES_COMBATLOG_TOOLTIP = "전투 메시지에서 링크 정보가 있는 단어를 괄호로 묶습니다.",
SHOW_QUICK_BUTTON = "빠른 버튼 표시하기",
SHOW_TIMESTAMP = "시간 표시",
SOURCE = "획득 방법:",
SPECIAL = "특수 주문",
SPELLS_COMBATLOG_TOOLTIP = "주문과 특수 능력에 관한 메시지를 표시합니다.",
SPELL_CASTING = "주문 시전",
SPELL_CASTING_COMBATLOG_TOOLTIP = "주문 시전에 관련된 메시지를 표시합니다.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "주문을 시전하지 못하거나 시전에 실패했을 때 메시지를 표시합니다.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "주문 시전을 시작할 때 메시지를 표시합니다.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "성공적으로 주문을 시전했을 때 메시지를 표시합니다.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "주문의 마법 계열에 색을 입힙니다.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "주문이나 능력으로 피해를 입혔을 때 메시지를 표시합니다.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "근접 공격을 제외한 공격 피해에 색을 입힙니다.",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "공격 마법 계열에 색을 입힙니다. (예: 암흑)",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "주문이나 능력으로 마나, 기력, 분노, 집중이 감소할 때 메시지를 표시합니다.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "주문이나 능력으로 추가 공격 기회를 얻었을 때 메시지를 표시합니다.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "주문이나 능력으로 피해가 치유될 때 메시지를 표시합니다.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "내구도 감소나 소환수에게 분배되는 피해 등 특별한 형태의 메시지를 표시합니다.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "주문이나 능력으로 다른 주문이 취소될 때 메시지를 표시합니다.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "주문이나 능력으로 피해를 입히지 못했을 때 메시지를 표시합니다. 피함, 막음, 방어함, 튕김, 면역, 흡수, 벗어남이 포함됩니다.",
SPELL_NAMES = "주문 이름",
SPELL_NAMES_COMBATLOG_TOOLTIP = "주문의 이름에 색을 입힙니다.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "주문이나 기술에 괄호 표시",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "효과가 증가하는 주문을 표시합니다.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "주문이나 능력으로 주기적인 피해를 입힐 때 메시지를 표시합니다. 예: 어둠의 권능: 고통, 부패 등",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "주문이나 능력으로 주기적인 치유가 이루어질 때 메시지를 표시합니다. 예: 소생, 회복 등",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "주문이나 능력으로 인한 주기적인 피해가 실패했을 때 메시지를 표시합니다. 면역, 흡수, 벗어남 등이 포함됩니다.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "주문이나 능력으로 주기적인 효과가 발생할 때 메시지를 표시합니다. 예: 마나 회복, 마나 흡수 등",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "다른 플레이어나 NPC를 부활시키는 주문에 대한 메시지를 표시합니다.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "몬스터나 NPC를 소환하거나 물건을 창조할 때 메시지를 표시합니다.",
START = "시작",
STRING_SCHOOL_UNKNOWN = "알 수 없음",
SUCCESS = "성공",
SUMMONS = "소환",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "근접 공격으로 입힌 전체 피해나 부분적인 피해를 표시합니다.",
SWING_MISSED_COMBATLOG_TOOLTIP = "피해를 입히지 못한 근접 공격에 대한 메시지를 표시합니다.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%1$s %2$s %4$s %5$s %3$s %6$s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %2$s %4$s %5$s %3$s %6$s",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(%s 남음)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s 흡수됨)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s 피해 방어)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(치명상)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(극대화)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(강타당함)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount $resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(비껴맞음)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(연속타격)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s 과충전)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(%s 초과 치유)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(%s 초과 피해)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d 막음)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "반사함",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s 저항함)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s 약점 피해)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "(%s %s)",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "전투 메시지에 시간을 표시합니다.",
UNIT_COLORS = "대상 색:",
UNIT_NAMES = "플레이어, NPC, 몬스터 이름",
UNIT_NAMES_COMBATLOG_TOOLTIP = "플레이어, NPC, 몬스터 이름에 색을 입힙니다.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "이름에 괄호 표시",
UNIT_YOU = "당신",
UNIT_YOU_DEST = "당신",
UNIT_YOU_DEST_POSSESSIVE = "당신",
UNIT_YOU_SOURCE = "당신",
UNIT_YOU_SOURCE_POSSESSIVE = "당신",
USE_FULL_TEXT_MODE = "전체 문장으로 보기",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (RU) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["ruRU"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "Урон",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "\"%2$s\" |3-1(%1$s) отражает %9$s |4единицу:единицы:единиц; %7$s на |3-3(%4$s)%6$s.",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "\"%2$s\" отражает %9$s |4единицу:единицы:единиц; %7$s на |3-3(%4$s)%6$s.",
ACTION_DAMAGE_SHIELD_MISSED = "Промах",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = ": выстрел блокирован",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%4$s блокирует заклинание \"%2$s\" |3-1(%1$s)%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s блокирует заклинание \"%2$s\"%6$s.",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = ": выстрел отклонен",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%4$s отклоняет заклинание \"%2$s\" |3-1(%1$s).",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s отклоняет заклинание \"%2$s\".",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = ": уклонение",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%4$s уклоняется от заклинания \"%2$s\" |3-1(%1$s).",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s уклоняется от заклинания \"%2$s\".",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = ": атака не достигла цели",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "Заклинание \"%2$s\" |3-1(%1$s) не достигает |3-1(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "Заклинание \"%2$s\" не достигает |3-1(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "\"%2$s\" |3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "\"%2$s\" не попадает по |3-2(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = ": цель невосприимчива",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%4$s обладает невосприимчивостью к заклинанию \"%2$s\" |3-1(%1$s).",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s обладает невосприимчивостью к заклинанию \"%2$s\".",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = ": промах",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "\"%2$s\" |3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "\"%2$s\" не попадает по |3-2(%4$s).",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = ": выстрел парирован",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%4$s парирует способность \"%2$s\" |3-1(%1$s).",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s парирует способность \"%2$s\".",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = ": сопротивление",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%4$s полностью сопротивляется заклинанию \"%2$s\" |3-1(%1$s)%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s полностью сопротивляется заклинанию \"%2$s\"%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "Разделение урона",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%4$s поглощает урон от заклинания \"%2$s\" |3-1(%1$s) %6$s",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит |3-2(%4$s) %9$s |4единицу:единицы:единиц; урона.",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит %9$s ед. урона |3-2(%4$s) %6$s",
ACTION_ENCHANT_APPLIED = "зачаровано",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s накладывает чары \"%2$s\" на предмет \"%5$s\" |3-1(%4$s).",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "чары развеялись",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "Эффект \"%2$s\" перестает действовать на предмете |3-1(%4$s) \"%5$s\".",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "Урон",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "Утопление",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s тонет и теряет %9$s |4единицу:единицы:единиц; здоровья.",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "Падение",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s падает и теряет %9$s |4единицу:единицы:единиц; здоровья.",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "Усталость",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s от усталости теряет %9$s |4единицу:единицы:единиц; здоровья.",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "Огонь",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s получает %9$s |4единицу:единицы:единиц; урона от огня.",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s теряет %9$s |4единицу:единицы:единиц; здоровья из-за опасностей окружающего мира.",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "Лава",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s погружается в лаву и теряет %9$s |4единицу:единицы:единиц; здоровья. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "Слизь",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s погружается в слизь и теряет %9$s |4единицу:единицы:единиц; здоровья. %6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "Убийство",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s убивает |3-3(%4$s)!",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "нейтрализован",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "Игрок %1$s нейтрализовал |3-3(%4$s)!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "Дальний бой",
ACTION_RANGE_DAMAGE = "Попадание",
ACTION_RANGE_DAMAGE_FULL_TEXT = "Атака дальнего боя |3-1(%1$s) бьет по |3-2(%4$s) на %5$s%6$s.",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "Атака дальнего боя бьет по |3-2(%4$s) на %5$s%6$s.",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "Промах",
ACTION_RANGE_MISSED_ABSORB = ": поглощение",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%4$s поглощает выстрел |3-1(%1$s)%6$s.",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = ": выстрел блокирован",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%1$s блокирует выстрел |3-1(%4$s)%6$s.",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = ": выстрел отклонен",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%4$s отклоняет выстрел |3-1(%1$s).",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = ": уклонение",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%4$s уклоняется от выстрела |3-1(%1$s).",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = ": атака не достигла цели",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "Выстрел |3-1(%1$s) не достигает |3-1(%4$s).",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "%1$s не попадает по |3-2(%4$s).",
ACTION_RANGE_MISSED_IMMUNE = ": цель невосприимчива",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "%4$s обладает невосприимчивостью к выстрелу |3-1(%1$s).",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "Промах.",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "Выстрел 3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = ": промах",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "%1$s не попадает по |3-2(%4$s).",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = ": выстрел парирован",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%4$s парирует выстрел |3-1(%1$s).",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = ": сопротивление",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%4$s полностью сопротивляется выстрелу |3-1(%1$s)%6$s.",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "накладывается",
ACTION_SPELL_AURA_APPLIED_BUFF = "накладывается",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "На |3-3(%4$s) накладывается эффект \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s обретает %2$s.",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "На |3-3(%4$s) накладывается эффект \"%2$s\" |3-1(%1$s). %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "На |3-3(%4$s) накладывается эффект \"%2$s\". %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "Негативный эффект",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s находится под воздействием эффекта \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s находится под воздействием эффекта \"%2$s\".",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s находится под воздействием эффекта \"%2$s\" |3-1(%1$s). %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s находится под воздействием эффекта \"%2$s\". %11$s",
ACTION_SPELL_AURA_APPLIED_DOSE = "Суммирование",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "Суммирование",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "На |3-3(%4$s) накладывается эффект \"%2$s\" |3-1(%1$s) (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s получает %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "Негативный эффект",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s находится под воздействием эффекта \"%2$s\" |3-1(%1$s) (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s находится под воздействием %2$s (%9$s).",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "прервано",
ACTION_SPELL_AURA_BROKEN_BUFF = "прервано",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "\"%4$s\" |3-1(%2$s) снято |3-4(%1$s).",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "Кто-то прервал действие заклинания \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "прервано",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "\"%4$s\" |3-1(%2$s) снято |3-4(%1$s).",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "Кто-то прервал действие заклинания \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "прервано",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%5$s |3-1(%1$s) прекращает действие эффекта \"%2$s\" на |3-3(%4$s).",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s прерывает действие \"%2$s\" |3-1(%4$s).",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "прервано",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%5$s |3-1(%1$s) прекращает действие эффекта \"%2$s\" на |3-3(%4$s).",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s прерывает действие \"%2$s\" |3-1(%4$s).",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "обновлено",
ACTION_SPELL_AURA_REFRESH_BUFF = "обновлено",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s) обновлен на |3-5(%4$s).",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "Эффект \"%2$s\" обновлен на |3-5(%4$s).",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s) обновлен на |3-5(%4$s). %11$s",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Эффект \"%2$s\" обновлен на |3-5(%4$s). %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "обновлено",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s) обновлен на |3-5(%4$s).",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "Эффект \"%2$s\" обновлен на |3-5(%4$s).",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s) обновлен на |3-5(%4$s). %11$s",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Эффект \"%2$s\" обновлен на |3-5(%4$s). %11$s",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "Снятие",
ACTION_SPELL_AURA_REMOVED_BUFF = "Окончание действия",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "Действие эффекта \"%2$s\", наложенного |3-4(%1$s) на |3-3(%4$s), заканчивается.",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "Действие эффекта \"%2$s\" на |3-2(%4$s) заканчивается.",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "Действие эффекта \"%2$s\", наложенного |3-4(%1$s) на |3-3(%4$s), заканчивается. %11$s",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Действие эффекта \"%2$s\", наложенного на |3-3(%4$s), заканчивается. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "Прекращение действия",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s), наложенный на |3-3(%4$s), рассеивается.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s рассеивается на %4$s.",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "Эффект \"%2$s\" |3-1(%1$s), наложенный на |3-3(%4$s), рассеивается. %11$s",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "Эффект \"%2$s\", наложенный на |3-3(%4$s), рассеивается. %11$s",
ACTION_SPELL_AURA_REMOVED_DOSE = "Сокращение",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "Сокращение",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "Действие эффекта |3-1(%1$s) \"%2$s\" (%9$s) проходит.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "Действие эффекта \"%2$s\" (%9$s) ослабляется.",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "Уменьшение",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "Действие эффекта \"%2$s\" |3-1(%1$s) (%9$s) заканчивается.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "\"%2$s\" (%9$s) прекращает свое действие.",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "С |3-1(%4$s) снято заклинание \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "С |3-1(%4$s) снято заклинание \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "бьет",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%2$s |3-1(%1$s) наносит |3-2(%4$s) %5$s%6$s.",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s наносит |3-2(%4$s) %5$s%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "отремонтировано",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%2$s |3-1(%1$s) ремонтирует %4$s на %9$s ед.%6$s.",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s ремонтирует |3-3(%4$s) на %9$s ед.%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "Неудача.",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "Заклинание \"%2$s\" |3-1(%1$s) не сработало. %6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "Начало применения",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s начинает применять способность %2$s к |3-2(%4$s).",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s начинает применять способность %2$s.",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "Что-то начинает применять способность %2$s к |3-2(%4$s).",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "Применение",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s применяет заклинание \"%2$s\" на |3-3(%4$s).",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s применяет заклинание \"%2$s\".",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "На |3-3(%4$s) накладывается эффект \"%2$s\".",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "создает",
ACTION_SPELL_CREATE_FULL_TEXT = "\"%2$s\" |3-1(%1$s) создает предмет \"%4$s\"%6$s.",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "\"%2$s\" создает \"%4$s\"%6$s.",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "Попадание",
ACTION_SPELL_DAMAGE_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит |3-2(%4$s) %5$s%6$s.",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "\"%2$s\" наносит |3-2(%4$s) урон: %5$s. %6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "Развеивание",
ACTION_SPELL_DISPEL_BUFF = "Развеивание",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%5$s |3-1(%4$s) рассеивается заклинанием \"%2$s\" |3-1(%1$s).\"",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "\"%2$s\" рассеивает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "Очищение",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "\"%2$s\" |3-1(%1$s) очищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "\"%2$s\" очищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "Не удалось развеять.",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "Заклинанию |3-1(%1$s) \"%2$s\" не удалось развеять заклинание |3-1(%4$s) \"%5$s\".",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "Заклинанию \"%2$s\" не удается развеять заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "Похищение",
ACTION_SPELL_DRAIN_FULL_TEXT = "\"%1$s\" |3-1(%2$s) отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) у |3-1(%4$s).",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = " %2$s отнимает у |3-1(%4$s) %9$s |4единицу:единицы:единиц; |3-1(%8$s ).",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "Повреждение предмета",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "Повреждение всех предметов",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит урон |3-2(%4$s): повреждаются все предметы.",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит урон |3-2(%4$s). Поврежден предмет: %5$s.",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "Энергия",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s получает %9$s |4единицу:единицы:единиц; |3-1(%8$s) от заклинания \"%2$s\" |3-1(%1$s).\"",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s получает %9$s |4единицу:единицы:единиц; |3-1(%8$s) благодаря заклинанию \"%2$s\".",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "Получено %9$s |4единица:единицы:единиц; %8$s",
ACTION_SPELL_EXTRA_ATTACKS = "Дополнительные атаки",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "\"%2$s\" дает |3-2(\"%1$s) %9$s |4дополнительную атаку:дополнительных атаки:дополнительных атак;.",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "\"%2$s\" дает %9$s |4дополнительную атаку:дополнительных атаки:дополнительных атак;.",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "Лечение",
ACTION_SPELL_HEAL_FULL_TEXT = "\"%2$s\" |3-1(%1$s) исцеляет |3-3(%4$s) на %9$s |4единицу:единицы:единиц; здоровья%6$s.",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "\"%2$s\" исцеляет |3-3(%4$s) на %9$s |4единицу:единицы:единиц; %6$s.",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "Убийство",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "\"%2$s\" |3-1(%1$s) мгновенно убивает |3-3(%4$s).",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "\"%2$s\" мгновенно убивает |3-3(%4$s).",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "нейтрализован",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s нейтрализует |3-3(%4$s).",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s нейтрализует |3-3(%4$s).",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "прерывание",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "\"%2$s\" |3-1(%1$s) прерывает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "\"%2$s\" прерывает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "Похищение",
ACTION_SPELL_LEECH_FULL_TEXT = "\"%2$s\" |3-1(%1$s) отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) из |3-1(%4$s). %1$s получает %10$s |4единицу:единицы:единиц; |3-1(%8$s).",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "\"%2$s\" отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) у |3-1(%4$s).",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "Получено %10$s |4единица:единицы:единиц; |3-1(%8$s)",
ACTION_SPELL_MISSED = "Промах",
ACTION_SPELL_MISSED_ABSORB = "Поглощение",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "\"%2$s\" |3-1(%1$s) поглощается |3-4(%4$s)%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%4$s поглощает заклинание \"%2$s\"%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "Блок",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%4$s блокирует заклинание \"%2$s\" |3-1(%1$s)%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s блокирует заклинание \"%2$s\"%6$s.",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "Отклонение",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%4$s отклоняет заклинание \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%4$s отклоняет заклинание \"%2$s\".",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "Уклонение",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%4$s уклоняется от заклинания \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s уклоняется от заклинания \"%2$s\".",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "Атака не достигла цели",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "Заклинание \"%2$s\" |3-1(%1$s) не достигает |3-1(%4$s).",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "Заклинание \"%2$s\" не достигает |3-1(%4$s).",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "\"%2$s\" |3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "\"%2$s\" не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_IMMUNE = "Невосприимчивость",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%4$s обладает невосприимчивостью к заклинанию \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s обладает невосприимчивостью к заклинанию \"%2$s\".",
ACTION_SPELL_MISSED_MISFIRE = "Промах",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "\"%1$s\" |3-1(%2$s) не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "\"%2$s\" не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "Промах",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "\"%2$s\" |3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "\"%2$s\" не попадает по |3-2(%4$s).",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "Парирование",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%4$s парирует способность \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s парирует способность \"%2$s\".",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "отражение",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%4$s отражает заклинание \"%2$s\" |3-1(%1$s).",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%4$s отражает заклинание \"%2$s\".",
ACTION_SPELL_MISSED_RESIST = "сопротивление",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%4$s полностью сопротивляется заклинанию \"%2$s\" |3-1(%1$s)%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%4$s полностью сопротивляется заклинанию \"%2$s\"%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "Урон",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "\"%2$s\" |3-1(%1$s) наносит |3-2(%4$s) %5$s%6$s.",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s получает %5$s от заклинания \"%2$s\"%6$s.",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "Похищение",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "\"%1$s\" |3-1(%2$s) отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) у |3-1(%4$s).",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "\"%2$s\" отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) у |3-1(%4$s).",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "Энергия",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s получает %9$s |4единицу:единицы:единиц; |3-1(%8$s) от заклинания \"%2$s\" |3-1(%1$s).\"",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s получает %9$s |4единицу:единицы:единиц; |3-1(%8$s) благодаря заклинанию \"%2$s\".",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "%8$s: +$extraAmount",
ACTION_SPELL_PERIODIC_HEAL = "Лечение",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s получает %9$s |4единицу:единицы:единиц; здоровья от заклинания \"%2$s\" |3-1(%1$s)%6$s.",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s получает %9$s |4единицу:единицы:единиц; здоровья от заклинания \"%2$s\". %6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "Похищение",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "\"%2$s\" |3-1(%1$s) отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) из |3-1(%4$s). %1$s получает %10$s |4единицу:единицы:единиц; |3-1(%8$s).",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "\"%2$s\" отнимает %9$s |4единицу:единицы:единиц; |3-1(%8$s) у |3-1(%4$s). %1$s получает %10$s |4единицу:единицы:единиц; |3-1(%8$s).",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = " (Получено %10$s |4единица:единицы:единиц; |3-1(%8$s))",
ACTION_SPELL_PERIODIC_MISSED = "Промах",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = " (поглощение: %1$s)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "\"%2$s\" |3-1(%1$s) поглощается |3-4(%4$s)%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%4$s поглощает заклинание \"%2$s\"%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = ": заклинание однократно блокировано",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%4$s временно блокирует заклинание \"%2$s\" |3-1(%1$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%4$s на мгновение блокирует заклинание \"%2$s\"%6$s.",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = ": однократное отклонение",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%4$s на мгновение отклоняет заклинание \"%2$s\" |3-1(%1$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%4$s на мгновение отклоняет заклинание \"%2$s\"%6$s.",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = ": однократное уклонение",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%4$s на мгновение уклоняется от заклинания \"%2$s\" |3-1(%1$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%4$s на мгновение уклоняется от заклинания \"%2$s\"%6$s.",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = ": временно не достигает цели",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "Заклинание \"%2$s\" |3-1(%1$s) на мгновение не достигает |3-1(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "Заклинание \"%2$s\" на мгновение не достигает |3-1(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "\"%2$s\" |3-1(%1$s) временно не действует на |3-3(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "\"%2$s\" временно не действует на |3-3(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = ": цель невосприимчива",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "На |3-3(%4$s) не подействовало заклинание |3-1(%1$s) \"%2$s\". %6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "На |3-3(%4$s) не подействовало заклинание \"%2$s\". %6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = ": однократный промах",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "\"%2$s\" |3-1(%1$s) на мгновение перестает действовать на |3-1(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "\"%2$s\" на мгновение перестает действовать на |3-1(%4$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = ": однократное парирование",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%4$s на мгновение парирует заклинание \"%2$s\" |3-1(%1$s)%6$s.",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%4$s на мгновение парирует заклинание \"%2$s\"%6$s.",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = ": однократное сопротивление",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "\"%2$s\" |3-1(%1$s) не действует на |3-3(%4$s). %4$s сопротивляется заклинанию. %6$s.",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "\"%2$s\" не действует на |3-3(%4$s). %4$s сопротивляется заклинанию. %6$s.",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "воскрешено",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%1$s воскрешает |3-3(%4$s)%6$s с помощью заклинания \"%2$s\".",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s воскрешает %4$s%6$s.",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "Похищение",
ACTION_SPELL_STOLEN_BUFF = "Похищение",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "\"%2$s\" |3-1(%1$s) похищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "\"%2$s\" похищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "Похищение",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "\"%2$s\" |3-1(%1$s) передает заклинание |3-1(%4$s) \"$extraSpell\" |3-2(%1$s).",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "\"%2$s\" передает |3-2(%4$s) заклинание \"$extraSpell\".",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "\"%2$s\" |3-1(%1$s) похищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "\"%2$s\" похищает заклинание \"%5$s\" |3-1(%4$s).",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "призывает",
ACTION_SPELL_SUMMON_FULL_TEXT = "\"%2$s\" |3-1(%1$s) призывает |3-3(%4$s)%6$s.",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s призывает |3-3(%4$s)%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "Ближний бой",
ACTION_SWING_DAMAGE = "Попадание",
ACTION_SWING_DAMAGE_FULL_TEXT = "Атака ближнего боя |3-1(%1$s) наносит |3-2(%4$s) %5$s%6$s.",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "Атака ближнего боя бьет по |3-2(%4$s) на %5$s%6$s.",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "Промах",
ACTION_SWING_MISSED_ABSORB = ": поглощение",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%4$s поглощает атаку |3-1(%1$s)%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = ": выстрел блокирован",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%4$s%6$s блокирует атаку |3-1(%1$s).",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = ": выстрел отклонен",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%4$s отклоняет атаку |3-1(%1$s).",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = ": уклонение",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%4$s уклоняется от атаки |3-1(%1$s).",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = ": атака не достигла цели",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "Атака |3-1(%1$s) не достигает |3-1(%4$s).",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "%1$s не попадает по |3-2(%4$s).",
ACTION_SWING_MISSED_IMMUNE = ": цель невосприимчива",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "%4$s обладает невосприимчивостью к атаке |3-1(%1$s).",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "Промах.",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "Атака |3-1(%1$s) не попадает по |3-2(%4$s).",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = ": промах",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "%1$s не попадает по |3-2(%4$s).",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = ": выстрел парирован",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%4$s парирует атаку |3-1(%1$s).",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = ": сопротивление",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%4$s полностью сопротивляется атаке |3-1(%1$s)%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "падает",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s падает.",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "Уничтожение",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s умирает.",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "умерли",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s погибает.",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "рассеивается",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s рассеивается.",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "Добавить",
ADDITIONAL_FILTERS = "Дополнительные фильтры",
ADD_FILTER = "Добавить",
AURAS = "Ауры",
AURAS_COMBATLOG_TOOLTIP = "Отображение сообщений о благотворных и вредоносных состояниях.",
BENEFICIAL = "Защитные",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "Отображение сообщений о приобретении или потере благотворной ауры вашим персонажем.",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "Все действия, касающиеся |3-1(%s)",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "Показывать все",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "Действия по отношению к |3-2(%s)?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "Действия |3-1(%s)",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "Действия |3-1(%s) по отношению к вам",
BLIZZARD_COMBAT_LOG_MENU_RESET = "Сброс",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "Сохранить как новый фильтр",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "Скрывать подобные сообщения.",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "Отправить ссылку на \"%s\" в чат.",
BY_SOURCE = "Источник",
BY_SOURCE_COMBATLOG_TOOLTIP = "Цвет строки зависит от источника.",
BY_TARGET = "Цель",
BY_TARGET_COMBATLOG_TOOLTIP = "Цвет строки зависит от цели.",
COLORIZE = "Цвета:",
COLORS = "Цвета",
COLOR_BY_SCHOOL = "Цвета школ",
COMBATLOG_DEFAULTS = "По умолчанию",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "По выбору",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "Друзья",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "Враждебные игроки",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "Индикаторы противников",
COMBATLOG_FILTER_STRING_ME = "Я",
COMBATLOG_FILTER_STRING_MY_PET = "Питомец",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "Нейтральный",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "Неизвестно",
COMBATLOG_HIGHLIGHT_ABILITY = "Способность",
COMBATLOG_HIGHLIGHT_DAMAGE = "Урон",
COMBATLOG_HIGHLIGHT_KILL = "Убийства",
COMBATLOG_HIGHLIGHT_SCHOOL = "Школы магии",
COMBATLOG_UNKNOWN_UNIT = "Что-то",
COMBAT_FACTION_CHANGE = "Репутация",
COMBAT_HONOR_GAIN = "Честь",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "Разное",
COMBAT_XP_GAIN = "Опыт",
CONFIRM_COMBAT_FILTER_DEFAULTS = "Вы действительно хотите сбросить настройки фильтров?",
CONFIRM_COMBAT_FILTER_DELETE = "Удалить этот фильтр?",
COPY_FILTER = "Копировать",
DAMAGE_NUMBER = "Величина урона",
DAMAGE_SCHOOL_TEXT = "Школа магии",
DAMAGE_SHIELD = "Ответные повреждения",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "Отображение сообщений об уроне, наносимом заклинаниями или способностями в ответ на атаки в ближнем бою (\"Шипы\" и т. п.).",
DEATHS_COMBATLOG_TOOLTIP = "Отображение сообщений о смерти различных существ.",
DEFAULT_COMBATLOG_FILTER_NAME = "Фильтр %d",
DISPELS = "Развеивание",
DISPEL_AURA_COMBATLOG_TOOLTIP = "Отображение сообщений об исчезновении, разрушении или похищении аур.",
DONE_BY = "Источник:",
DONE_TO = "Цель:",
DRAINS = "Похищение",
ENTER_FILTER_NAME = "Введите название фильтра:",
ENTIRE_LINE = "Вся строка",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "Цветовое выделение всей строки в соответствии с параметрами, указанными ниже.",
ENVIRONMENTAL_DAMAGE = "Урон от окружающего мира",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "Отображение сообщений о получении разными персонажами урона от падения, утопления или погружения в лаву.",
EXAMPLE_SPELL_FIREBALL = "Огненный шар",
EXAMPLE_SPELL_FROSTBOLT = "Ледяная стрела",
EXAMPLE_TARGET_MONSTER = "Монстр",
EXAMPLE_TEXT = "Пример текста:",
EXTRA_ATTACKS = "Дополнит. атаки",
FAILURES = "Неудачное",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "Действия враждебных игроков, питомцев и существ.",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "Действия дружественных игроков, питомцев и существ.",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Действия враждебных игроков.",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "Действия вашего персонажа, а также его ловушек и заклинаний.",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "Действия нейтральных существ.",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "Действия ваших питомцев, вызванных существ и подчиненных персонажей.",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "Действия окружающего мира: падение, кислота, лава и т.п.",
FILTER_NAME = "Название фильтра",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "Действия в отношении дружественных игроков, питомцев и существ.",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "Действия в отношении враждебных питомцев и существ.",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "Действия в отношении враждебных игроков.",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "Действия в отношении вашего персонажа.",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "Действия в отношении нейтральных существ.",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "Действия в отношении ваших питомцев, вызванных существ и подчиненных персонажей.",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "Действия в отношении невидимых целей.",
FORMATTING = "Формат",
FULL_TEXT_COMBATLOG_TOOLTIP = "Показывать записи журнала боя в полном виде.",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "Отображение сообщений о приобретении или потере губительной ауры вашим персонажем.",
HEALS = "Лечение",
HIGHLIGHTING = "Подсветка:",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "Подсветка названий способностей в боевых сообщениях.",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "Подсветка величины урона в боевых сообщениях.",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "Подсветка всей строки при убийстве противника вами или другим членом вашей группы.",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "Подсветка названий школ магии в боевых сообщениях.",
HOSTILE = "Губительные",
INTERRUPTS = "Прерывание",
ITEM_NAMES = "Названия предметов",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Заключение в скобки названий предметов.",
KILLS_COMBATLOG_TOOLTIP = "Отображение сообщений об убийстве противников членами вашей группы.",
MELEE = "Ближний бой",
MELEE_COMBATLOG_TOOLTIP = "Отображение информации об ударах ближнего боя.",
MESSAGE_SOURCES = "Источники сообщений",
MISSES = "Промах",
MOVE_FILTER_DOWN = "Переместить ниже",
MOVE_FILTER_UP = "Переместить выше",
OTHER = "Другое",
PERIODIC = "Периодические эффекты",
POWER_GAINS = "Получение энергии",
POWER_GAINS_COMBATLOG_TOOLTIP = "Отображение сообщений о восполнении маны, энергии, ярости, концентрации, энергии ци, энергии Света или сфер Тьмы с помощью заклинаний или способностей.",
QUICKBUTTON_NAME_EVERYTHING = "Все",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "Отображение всех сообщений о бое.",
QUICKBUTTON_NAME_KILLS = "Убийства",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "Показ всех смертей и убийств.",
QUICKBUTTON_NAME_ME = "Что случилось с персонажем?",
QUICKBUTTON_NAME_ME_TOOLTIP = "Отображение всех действий в отношении вашего персонажа.",
QUICKBUTTON_NAME_SELF = "Персонаж",
QUICKBUTTON_NAME_SELF_TOOLTIP = "Отображение сообщений о действиях вашего персонажа и в отношении него.",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "Помещение ссылки на фильтр в окно чата.",
RANGED = "Дальний бой",
RANGED_COMBATLOG_TOOLTIP = "Природа",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "Отображение информации об атаках дальнего боя, наносящих полный или частичный урон.",
RANGE_MISSED_COMBATLOG_TOOLTIP = "Отображение информации об атаках дальнего боя, не наносящих урона.",
RESURRECT = "Воскрешений",
SETTINGS = "Параметры",
SHOW_BRACES = "Выделять скобками",
SHOW_BRACES_COMBATLOG_TOOLTIP = "Выделение ссылок в сообщениях журнала боя.",
SHOW_QUICK_BUTTON = "Быстрый вызов",
SHOW_TIMESTAMP = "Отображать время",
SOURCE = "Источник:",
SPECIAL = "Особые",
SPELLS_COMBATLOG_TOOLTIP = "Отображение сообщений о заклинаниях и особых способностях.",
SPELL_CASTING = "Применение заклинаний",
SPELL_CASTING_COMBATLOG_TOOLTIP = "Отображение сообщений о применении заклинаний.",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "Отображение сообщений о невозможности применения заклинаний.",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "Отображение сообщений о начале применения заклинаний.",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "Отображение сообщений об успешном завершении заклинаний.",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "Цветовое выделение названий заклинаний в соответствии с школами магии.",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "Отображение сообщений о нанесении урона заклинаниями или способностями.",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "Цветовое выделение величины урона (кроме ближнего боя).",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "Цветовое выделение школ урона (\"Темной магии\" и т.п.)",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "Отображение сообщений о снижении объема маны, энергии, ярости и концентрации под влиянием заклинаний или способностей.",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "Отображение сообщений о дополнительных атаках, вызванных заклинаниями или способностями.",
SPELL_HEAL_COMBATLOG_TOOLTIP = "Отображение сообщений об исцеляющих заклинаниях и способностях.",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "Отображение сообщений об особых заклинаниях: например, повреждающих экипировку или наносящих урон питомцам.",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "Отображение сообщений о прерывании заклинаниями или способностями действия других заклинаний.",
SPELL_MISSED_COMBATLOG_TOOLTIP = "Отображение сообщений о неудачном применении боевых заклинаний и способностей, в т.ч., связанном с уклонением, парированием, блоком, отражением, невосприимчивостью, поглощением и уверткой.",
SPELL_NAMES = "Названия заклинаний",
SPELL_NAMES_COMBATLOG_TOOLTIP = "Цветовое выделение названий заклинаний.",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Заключение в скобки названий заклинаний.",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "Отображение информации о заклинаниях постепенного действия.",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "Отображение сообщений о периодическом уроне от заклинаний или способностей (\"Слово Тьмы: Боль\", \"Порча\" и т. п.).",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "Отображение сообщений о периодическом исцелении от заклинаний или способностей (\"Обновление\", \"Омоложение\" и т. п.).",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "Отображение сообщений о частично неудачном применении боевых заклинаний и способностей, в т.ч., связанных с невосприимчивостью, поглощением и уверткой.",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "Отображение сообщений о других видах периодических эффектов заклинаний и способностей, например, восполнении или похищении маны.",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "Показывать сообщения о воскрешении игрока или существа с помощью заклинания или способности.",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "Показывать сообщения, когда с помощью заклинания призывается существо.",
START = "Начало",
STRING_SCHOOL_UNKNOWN = "Неизвестно",
SUCCESS = "Успешное",
SUMMONS = "Призывов",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "Отображение информации об ударах в ближнем бою, наносящих полный или частичный урон.",
SWING_MISSED_COMBATLOG_TOOLTIP = "Отображение атак в ближнем бою, не наносящих урона.",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%2$s |3-1(%1$s) - %3$s - %4$s - %5$s%6$s.",
TEXT_MODE_A_STRING_3 = "%1$s %5$s %3$s %4$s %2$s. %6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s",
TEXT_MODE_A_STRING_REMAINING_POINTS = "Осталось: %s",
TEXT_MODE_A_STRING_RESULT_ABSORB = "Поглощено: %s ед. урона.",
TEXT_MODE_A_STRING_RESULT_BLOCK = "Заблокировано: %s ед. урона.",
TEXT_MODE_A_STRING_RESULT_CRITICAL = ": критический эффект",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = ": критический эффект",
TEXT_MODE_A_STRING_RESULT_CRUSHING = ": сокрушительный удар",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount $resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = ": удар пришелся вскользь",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "Многократная атака.",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s: перенасыщение энергией)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "Избыточное лечение: %s.",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = " (избыточный урон: %s)",
TEXT_MODE_A_STRING_RESULT_PARRY = "Парировано: %d.",
TEXT_MODE_A_STRING_RESULT_REFLECT = "Атака отражена",
TEXT_MODE_A_STRING_RESULT_RESIST = " (сопротивление %s |4единице:единицам:единицам; урона)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = " (%s |4единица:единицы:единиц; урона за счет уязвимости)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s (%s)",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s (%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "Отображение даты и времени в сообщениях журнала боя.",
UNIT_COLORS = "Цвета объектов:",
UNIT_NAMES = "Объект действия",
UNIT_NAMES_COMBATLOG_TOOLTIP = "Цветовое выделение названий объектов.",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "Заключение в скобки названий объектов.",
UNIT_YOU = "Вы",
UNIT_YOU_DEST = "Вы",
UNIT_YOU_DEST_POSSESSIVE = "Ваш",
UNIT_YOU_SOURCE = "Вы",
UNIT_YOU_SOURCE_POSSESSIVE = "Ваше",
USE_FULL_TEXT_MODE = "Использовать полный режим",
}
+677
View File
@@ -0,0 +1,677 @@
-- Classic Era GlobalStrings (CN) that the combat log reads
-- and the 1.12 client lacks. Generated; do not edit by hand.
pfUI_locale["zhCN"]["combatlog"] = {
ACTION_DAMAGE_SHIELD = "伤害",
ACTION_DAMAGE_SHIELD_FULL_TEXT = "%1$s%2$s将%9$s点%7$s伤害反射给%4$s。%6$s",
ACTION_DAMAGE_SHIELD_FULL_TEXT_NO_SOURCE = "%2$s将%9$s点%7$s伤害反射给%4$s。%6$s",
ACTION_DAMAGE_SHIELD_MISSED = "未命中",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK = "(格挡)",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT = "%1$s%2$s被%4$s格挡了。%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s被%4$s格挡了。%6$s",
ACTION_DAMAGE_SHIELD_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT = "(偏转)",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT = "%1$s%2$s被%4$s偏转了。",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s被%4$s偏转了。",
ACTION_DAMAGE_SHIELD_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_DODGE = "(躲闪)",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT = "%1$s%2$s被%4$s躲闪了。",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s被%4$s躲闪了。",
ACTION_DAMAGE_SHIELD_MISSED_DODGE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_EVADED = "(闪避)",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT = "%1$s%2$s被%4$s闪避了。",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s被%4$s闪避了。",
ACTION_DAMAGE_SHIELD_MISSED_EVADED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT = "%1$s%2$s未命中%4$s。",
ACTION_DAMAGE_SHIELD_MISSED_FULL_TEXT_NO_SOURCE = "%2$s未命中%4$s。",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE = "(免疫)",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT = "%1$s%2$s失败。%4$s对此免疫。",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s失败。%4$s对此免疫。",
ACTION_DAMAGE_SHIELD_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_MISS = "(未命中)",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT = "%1$s%2$s未命中%4$s。",
ACTION_DAMAGE_SHIELD_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s未命中%4$s。",
ACTION_DAMAGE_SHIELD_MISSED_MISS_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_PARRY = "(招架)",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT = "%1$s%2$s被%4$s招架了。",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s被%4$s招架了。",
ACTION_DAMAGE_SHIELD_MISSED_PARRY_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_MISSED_RESIST = "(抵抗)",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT = "%1$s%2$s被%4$s完全抵抗了。%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s被%4$s完全抵抗了。%6$s",
ACTION_DAMAGE_SHIELD_MISSED_RESIST_POSSESSIVE = "1",
ACTION_DAMAGE_SHIELD_POSSESSIVE = "1",
ACTION_DAMAGE_SPLIT = "分担伤害",
ACTION_DAMAGE_SPLIT_ABSORBED_FULL_TEXT = "%4$s %6$s吸收了%1$s的%2$s点伤害。",
ACTION_DAMAGE_SPLIT_FULL_TEXT = "%1$s%2$s对%4$s$s造成%9$s点伤害。",
ACTION_DAMAGE_SPLIT_POSSESSIVE = "0",
ACTION_DAMAGE_SPLIT_RESULT_FULL_TEXT = "%1$s的%2$s对%4$s %6$s造成%9$s点伤害。",
ACTION_ENCHANT_APPLIED = "附魔",
ACTION_ENCHANT_APPLIED_FULL_TEXT = "%1$s在%4$s%5$s上施放了%2$s。",
ACTION_ENCHANT_APPLIED_POSSESSIVE = "0",
ACTION_ENCHANT_REMOVED = "附魔消失",
ACTION_ENCHANT_REMOVED_FULL_TEXT = "%2$s从%4$s%5$s上消失了。",
ACTION_ENCHANT_REMOVED_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE = "伤害",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING = "溺水",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_FULL_TEXT = "%4$s溺水,损失了%9$s点生命值。",
ACTION_ENVIRONMENTAL_DAMAGE_DROWNING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING = "掉落",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_FULL_TEXT = "%4$s受到%9$s点掉落伤害。",
ACTION_ENVIRONMENTAL_DAMAGE_FALLING_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE = "疲倦",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_FULL_TEXT = "%4$s筋疲力尽,损失了%9$s点生命值。",
ACTION_ENVIRONMENTAL_DAMAGE_FATIGUE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE = "火焰",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_FULL_TEXT = "%4$s受到了%9$s点火焰伤害。",
ACTION_ENVIRONMENTAL_DAMAGE_FIRE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_FULL_TEXT = "%4$s因环境伤害而损失了%9$s点生命值。",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA = "岩浆",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_FULL_TEXT = "%4$s在岩浆中,损失了%9$s点生命值。%6$s",
ACTION_ENVIRONMENTAL_DAMAGE_LAVA_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_POSSESSIVE = "0",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME = "淤泥",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_FULL_TEXT = "%4$s在淤泥中,损失了%9$s点生命值。%6$s",
ACTION_ENVIRONMENTAL_DAMAGE_SLIME_POSSESSIVE = "0",
ACTION_PARTY_KILL = "杀死了",
ACTION_PARTY_KILL_FULL_TEXT = "%1$s杀死了%4$s!",
ACTION_PARTY_KILL_POSSESSIVE = "0",
ACTION_PARTY_KILL_UNCONSCIOUS = "被击昏",
ACTION_PARTY_KILL_UNCONSCIOUS_FULL_TEXT = "%1$s击昏了%4$s!",
ACTION_PARTY_KILL_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_RANGED = "射击",
ACTION_RANGE_DAMAGE = "命中",
ACTION_RANGE_DAMAGE_FULL_TEXT = "%1$s远程射击命中%4$s造成了%5$s伤害。%6$s",
ACTION_RANGE_DAMAGE_FULL_TEXT_NO_SOURCE = "一次远程射击命中%4$s造成了%5$s伤害。%6$s",
ACTION_RANGE_DAMAGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED = "未命中",
ACTION_RANGE_MISSED_ABSORB = "(吸收)",
ACTION_RANGE_MISSED_ABSORB_FULL_TEXT = "%1$s射击被%4$s吸收了。%6$s",
ACTION_RANGE_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_RANGE_MISSED_BLOCK = "(格挡)",
ACTION_RANGE_MISSED_BLOCK_FULL_TEXT = "%1$s射击被%4$s格挡了。%6$s",
ACTION_RANGE_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DEFLECT = "(偏转)",
ACTION_RANGE_MISSED_DEFLECT_FULL_TEXT = "%1$s射击被%4$s偏转了。",
ACTION_RANGE_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_RANGE_MISSED_DODGE = "(躲闪)",
ACTION_RANGE_MISSED_DODGE_FULL_TEXT = "%1$s射击被%4$s躲闪了。",
ACTION_RANGE_MISSED_DODGE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_EVADE = "(闪避)",
ACTION_RANGE_MISSED_EVADE_FULL_TEXT = "%1$s射击被%4$s闪避了。",
ACTION_RANGE_MISSED_EVADE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_FULL_TEXT = "%1$s射击未命中%4$s。",
ACTION_RANGE_MISSED_IMMUNE = "(免疫)",
ACTION_RANGE_MISSED_IMMUNE_FULL_TEXT = "%1$s射击失败。%4$s对此免疫。",
ACTION_RANGE_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISFIRE = "(未命中)",
ACTION_RANGE_MISSED_MISFIRE_FULL_TEXT = "%1$s射击未命中%4$s。",
ACTION_RANGE_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_RANGE_MISSED_MISS = "(未命中)",
ACTION_RANGE_MISSED_MISS_FULL_TEXT = "%1$s射击未命中%4$s。",
ACTION_RANGE_MISSED_MISS_POSSESSIVE = "1",
ACTION_RANGE_MISSED_PARRY = "(招架)",
ACTION_RANGE_MISSED_PARRY_FULL_TEXT = "%1$s射击被%4$s招架了。",
ACTION_RANGE_MISSED_PARRY_POSSESSIVE = "1",
ACTION_RANGE_MISSED_POSSESSIVE = "1",
ACTION_RANGE_MISSED_RESIST = "(抵抗)",
ACTION_RANGE_MISSED_RESIST_FULL_TEXT = "%1$s射击被%4$s完全抵抗了。%6$s",
ACTION_RANGE_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED = "附加",
ACTION_SPELL_AURA_APPLIED_BUFF = "获得",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT = "%4$s获得了%1$s%2$s。",
ACTION_SPELL_AURA_APPLIED_BUFF_FULL_TEXT_NO_SOURCE = "%4$s获得了%2$s。",
ACTION_SPELL_AURA_APPLIED_BUFF_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT = "%4$s获得了%1$s %2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s获得了%2$s. %11$s",
ACTION_SPELL_AURA_APPLIED_DEBUFF = "影响",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT = "%4$s受到了%1$s%2$s的影响。",
ACTION_SPELL_AURA_APPLIED_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s受到了%2$s的影响。",
ACTION_SPELL_AURA_APPLIED_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT = "%4$s受到了%1$s %2$s. %11$s的影响",
ACTION_SPELL_AURA_APPLIED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%4$s受到了%2$s. %11$s的影响",
ACTION_SPELL_AURA_APPLIED_DOSE = "堆叠",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF = "堆叠",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT = "%4$s获得了%1$s%2$s(%9$s)。",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%4$s获得了%2$s(%9$s)。",
ACTION_SPELL_AURA_APPLIED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF = "影响",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT = "%4$s受到了%1$s%2$s的影响(%9$s)。",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s受到了%2$s的影响(%9$s)。",
ACTION_SPELL_AURA_APPLIED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_APPLIED_MASTER = "2",
ACTION_SPELL_AURA_APPLIED_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN = "打破",
ACTION_SPELL_AURA_BROKEN_BUFF = "打破",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT = "%1$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_BUFF_FULL_TEXT_NO_SOURCE = "%1$s%2$s被某目标打破了。",
ACTION_SPELL_AURA_BROKEN_BUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_DEBUFF = "打破",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT = "%1$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%1$s%2$s被某目标打破了。",
ACTION_SPELL_AURA_BROKEN_DEBUFF_POSSESSIVE = "0",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF = "打破",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT = "%1$s的%5$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_FULL_TEXT_NO_SOURCE = "%5$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_SPELL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF = "打破",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT = "%1$s的%5$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_FULL_TEXT_NO_SOURCE = "%5$s打破了%4$s%2$s。",
ACTION_SPELL_AURA_BROKEN_SPELL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH = "被刷新",
ACTION_SPELL_AURA_REFRESH_BUFF = "被刷新",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT = "%1$s%2$s在%4$s身上刷新了。",
ACTION_SPELL_AURA_REFRESH_BUFF_FULL_TEXT_NO_SOURCE = "%2$s在%4$s身上刷新了。",
ACTION_SPELL_AURA_REFRESH_BUFF_MASTER = "2",
ACTION_SPELL_AURA_REFRESH_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s在%4$s. %11$s身上刷新了",
ACTION_SPELL_AURA_REFRESH_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s在%4$s. %11$s的身上刷新了",
ACTION_SPELL_AURA_REFRESH_DEBUFF = "被刷新",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT = "%1$s%2$s在%4$s身上刷新了。",
ACTION_SPELL_AURA_REFRESH_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s在%4$s身上刷新了。",
ACTION_SPELL_AURA_REFRESH_DEBUFF_MASTER = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s在%4$s. %11$s身上刷新了",
ACTION_SPELL_AURA_REFRESH_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s在%4$s. %11$s的身上刷新了",
ACTION_SPELL_AURA_REFRESH_MASTER = "2",
ACTION_SPELL_AURA_REMOVED = "移除",
ACTION_SPELL_AURA_REMOVED_BUFF = "消失",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT = "%1$s%2$s从%4$s身上消失了。",
ACTION_SPELL_AURA_REMOVED_BUFF_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上消失了。",
ACTION_SPELL_AURA_REMOVED_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s从%4$s. %11$s身上消失了",
ACTION_SPELL_AURA_REMOVED_BUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s从%4$s. %11$s的身上消失了",
ACTION_SPELL_AURA_REMOVED_DEBUFF = "消散",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT = "%1$s%2$s从%4$s身上消散了。",
ACTION_SPELL_AURA_REMOVED_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上消散了。",
ACTION_SPELL_AURA_REMOVED_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT = "%1$s %2$s从%4$s. %11$s身上消散了",
ACTION_SPELL_AURA_REMOVED_DEBUFF_WITH_POINTS_FULL_TEXT_NO_SOURCE = "%2$s从%4$s. %11$s的身上消散了",
ACTION_SPELL_AURA_REMOVED_DOSE = "降低",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF = "降低",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT = "%1$s%2$s(%9$s)衰减了。",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_FULL_TEXT_NO_SOURCE = "%2$s(%9$s)衰减了。",
ACTION_SPELL_AURA_REMOVED_DOSE_BUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF = "衰减",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT = "%1$s%2$s(%9$s)消退了。",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s(%9$s)消退了。",
ACTION_SPELL_AURA_REMOVED_DOSE_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT = "%1$s%2$s被从%4$s身上移除了。",
ACTION_SPELL_AURA_REMOVED_FULL_TEXT_NO_SOURCE = "%1$s%2$s被从%4$s身上移除了。",
ACTION_SPELL_AURA_REMOVED_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_DAMAGE = "打击",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT = "%1$s%2$s打击%4$s造成了%5$s伤害。%6$s",
ACTION_SPELL_BUILDING_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s打击%4$s造成了%5$s伤害。%6$s",
ACTION_SPELL_BUILDING_DAMAGE_MASTER = "1",
ACTION_SPELL_BUILDING_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_BUILDING_HEAL = "修理",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT = "%1$s%2$s修理%4$s,恢复了%9$s点生命值。%6$s",
ACTION_SPELL_BUILDING_HEAL_FULL_TEXT_NO_SOURCE = "%2$s修理%4$s,恢复了%9$s点生命值。%6$s",
ACTION_SPELL_BUILDING_HEAL_POSSESSIVE = "1",
ACTION_SPELL_CAST_FAILED = "失败",
ACTION_SPELL_CAST_FAILED_FULL_TEXT = "%1$s%2$s未能施放。%6$s",
ACTION_SPELL_CAST_FAILED_MASTER = "1",
ACTION_SPELL_CAST_FAILED_POSSESSIVE = "1",
ACTION_SPELL_CAST_START = "开始施放",
ACTION_SPELL_CAST_START_FULL_TEXT = "%1$s开始向%4$s施放%2$s。",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_DEST = "%1$s开始施放%2$s。",
ACTION_SPELL_CAST_START_FULL_TEXT_NO_SOURCE = "某物体开始对%4$s施放%2$s。",
ACTION_SPELL_CAST_START_MASTER = "2",
ACTION_SPELL_CAST_START_POSSESSIVE = "0",
ACTION_SPELL_CAST_SUCCESS = "施放",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT = "%1$s向%4$s施放了%2$s。",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_DEST = "%1$s施放了%2$s。",
ACTION_SPELL_CAST_SUCCESS_FULL_TEXT_NO_SOURCE = "某目标对%4$s施放了%2$s。",
ACTION_SPELL_CAST_SUCCESS_MASTER = "2",
ACTION_SPELL_CAST_SUCCESS_POSSESSIVE = "0",
ACTION_SPELL_CREATE = "制造",
ACTION_SPELL_CREATE_FULL_TEXT = "%1$s%2$s制造了一个%4$s。%6$s",
ACTION_SPELL_CREATE_FULL_TEXT_NO_SOURCE = "%2$s制造了一个%4$s。%6$s",
ACTION_SPELL_CREATE_POSSESSIVE = "1",
ACTION_SPELL_DAMAGE = "命中",
ACTION_SPELL_DAMAGE_FULL_TEXT = "%1$s%2$s命中%4$s造成%5$s伤害。%6$s",
ACTION_SPELL_DAMAGE_FULL_TEXT_NO_SOURCE = "%2$s命中%4$s,造成%5$s点伤害。%6$s",
ACTION_SPELL_DAMAGE_MASTER = "1",
ACTION_SPELL_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_DISPEL = "驱散",
ACTION_SPELL_DISPEL_BUFF = "驱散",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT = "%4$s%5$s被%1$s%2$s驱散了。",
ACTION_SPELL_DISPEL_BUFF_FULL_TEXT_NO_SOURCE = "%4$s%5$s被%2$s驱散了。",
ACTION_SPELL_DISPEL_BUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_DEBUFF = "净化",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT = "%4$s%5$s被%1$s%2$s净化了。",
ACTION_SPELL_DISPEL_DEBUFF_FULL_TEXT_NO_SOURCE = "%4$s%5$s被%2$s净化了。",
ACTION_SPELL_DISPEL_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_FAILED = "驱散失败",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT = "%1$s%2$s未能驱散%4$s%5$s。",
ACTION_SPELL_DISPEL_FAILED_FULL_TEXT_NO_SOURCE = "%2$s未能驱散%4$s%5$s。",
ACTION_SPELL_DISPEL_FAILED_POSSESSIVE = "1",
ACTION_SPELL_DISPEL_POSSESSIVE = "1",
ACTION_SPELL_DRAIN = "吸取",
ACTION_SPELL_DRAIN_FULL_TEXT = "%1$s%2$s从%4$s身上吸取了%9$s点%8$s。",
ACTION_SPELL_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上吸取了%9$s点%8$s。",
ACTION_SPELL_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE = "耐久度下降",
ACTION_SPELL_DURABILITY_DAMAGE_ALL = "完全耐久度下降",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_FULL_TEXT = "%1$s%2$s对%4$s造成伤害:所有装备受损。",
ACTION_SPELL_DURABILITY_DAMAGE_ALL_POSSESSIVE = "1",
ACTION_SPELL_DURABILITY_DAMAGE_FULL_TEXT = "%1$s%2$s对%4$s造成伤害:%5$s受损。",
ACTION_SPELL_DURABILITY_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE = "补充",
ACTION_SPELL_ENERGIZE_FULL_TEXT = "%4$s因%1$s%2$s获得了%9$s点%8$s。",
ACTION_SPELL_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s因%2$s获得了%9$s点%8$s。",
ACTION_SPELL_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_ENERGIZE_RESULT = "获得%9$s点%8$s",
ACTION_SPELL_EXTRA_ATTACKS = "获得额外攻击",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT = "%1$s通过%2$s获得了%9$s次额外攻击。",
ACTION_SPELL_EXTRA_ATTACKS_FULL_TEXT_NO_SOURCE = "通过%2$s获得%9$s次额外攻击。",
ACTION_SPELL_EXTRA_ATTACKS_POSSESSIVE = "1",
ACTION_SPELL_HEAL = "治疗",
ACTION_SPELL_HEAL_FULL_TEXT = "%1$s%2$s为%4$s恢复了%9$s点生命值。%6$s",
ACTION_SPELL_HEAL_FULL_TEXT_NO_SOURCE = "%2$s为%4$s恢复了%9$s点生命值。%6$s",
ACTION_SPELL_HEAL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL = "杀死了",
ACTION_SPELL_INSTAKILL_FULL_TEXT = "%1$s%2$s杀死了%4$s。",
ACTION_SPELL_INSTAKILL_FULL_TEXT_NO_SOURCE = "%2$s杀死了%4$s。",
ACTION_SPELL_INSTAKILL_POSSESSIVE = "1",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS = "被击昏",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT = "%1$s %2$s击昏了%4$s。",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_FULL_TEXT_NO_SOURCE = "%2$s击昏了%4$s。",
ACTION_SPELL_INSTAKILL_UNCONSCIOUS_POSSESSIVE = "1",
ACTION_SPELL_INTERRUPT = "打断",
ACTION_SPELL_INTERRUPT_FULL_TEXT = "%1$s%2$s打断了%4$s%5$s。",
ACTION_SPELL_INTERRUPT_FULL_TEXT_NO_SOURCE = "%2$s打断了%4$s%5$s。",
ACTION_SPELL_INTERRUPT_POSSESSIVE = "1",
ACTION_SPELL_LEECH = "吸取",
ACTION_SPELL_LEECH_FULL_TEXT = "%1$s%2$s从%4$s身上吸取了%9$s点%8$s。%1$s获得了%10$s点%8$s。",
ACTION_SPELL_LEECH_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上吸取了%9$s点%8$s。",
ACTION_SPELL_LEECH_POSSESSIVE = "1",
ACTION_SPELL_LEECH_RESULT = "获得%10$s点%8$s",
ACTION_SPELL_MISSED = "未命中",
ACTION_SPELL_MISSED_ABSORB = "被吸收",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT = "%1$s%2$s被%4$s吸收了。%6$s",
ACTION_SPELL_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s被%4$s吸收了。%6$s",
ACTION_SPELL_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_MISSED_BLOCK = "被格挡",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT = "%1$s%2$s被%4$s格挡了。%6$s",
ACTION_SPELL_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s被%4$s格挡了。%6$s",
ACTION_SPELL_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DEFLECT = "偏转",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT = "%1$s%2$s被%4$s偏转了。",
ACTION_SPELL_MISSED_DEFLECT_FULL_TEXT_NO_SOURCE = "%2$s被%4$s偏转了。",
ACTION_SPELL_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SPELL_MISSED_DODGE = "被躲闪",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT = "%1$s%2$s被%4$s躲闪了。",
ACTION_SPELL_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s被%4$s躲闪了。",
ACTION_SPELL_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_EVADE = "被闪避",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT = "%1$s%2$s被%4$s闪避了。",
ACTION_SPELL_MISSED_EVADE_FULL_TEXT_NO_SOURCE = "%2$s被%4$s闪避了。",
ACTION_SPELL_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_FULL_TEXT = "%1$s%2$s未命中%4$s。",
ACTION_SPELL_MISSED_FULL_TEXT_NO_SOURCE = "%2$s未命中%4$s。",
ACTION_SPELL_MISSED_IMMUNE = "免疫",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT = "%1$s%2$s失败。%4$s对此免疫。",
ACTION_SPELL_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%2$s失败。%4$s对此免疫。",
ACTION_SPELL_MISSED_MISFIRE = "未命中",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT = "%1$s%2$s未命中%4$s。",
ACTION_SPELL_MISSED_MISFIRE_FULL_TEXT_NO_SOURCE = "%2$s未命中%4$s。",
ACTION_SPELL_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SPELL_MISSED_MISS = "未命中",
ACTION_SPELL_MISSED_MISS_FULL_TEXT = "%1$s%2$s未命中%4$s。",
ACTION_SPELL_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s未命中%4$s。",
ACTION_SPELL_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_MISSED_PARRY = "被招架",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT = "%1$s%2$s被%4$s招架了。",
ACTION_SPELL_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s被%4$s招架了。",
ACTION_SPELL_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_MISSED_POSSESSIVE = "1",
ACTION_SPELL_MISSED_REFLECT = "被反射",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT = "%1$s%2$s被%4$s反射了。",
ACTION_SPELL_MISSED_REFLECT_FULL_TEXT_NO_SOURCE = "%2$s被%4$s反射了。",
ACTION_SPELL_MISSED_RESIST = "被抵抗",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT = "%1$s%2$s被%4$s完全抵抗了。%6$s",
ACTION_SPELL_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s被%4$s完全抵抗了。%6$s",
ACTION_SPELL_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DAMAGE = "伤害",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT = "%4$s因%1$s%2$s受到了%5$s伤害。%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_FULL_TEXT_NO_SOURCE = "%4$s因%2$s受到了%5$s伤害。%6$s",
ACTION_SPELL_PERIODIC_DAMAGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_DRAIN = "吸取",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT = "%1$s%2$s从%4$s身上吸取了%9$s点%8$s。",
ACTION_SPELL_PERIODIC_DRAIN_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上吸取了%9$s点%8$s。",
ACTION_SPELL_PERIODIC_DRAIN_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE = "补充",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT = "%4$s因%1$s%2$s获得了%9$s点%8$s。",
ACTION_SPELL_PERIODIC_ENERGIZE_FULL_TEXT_NO_SOURCE = "%4$s因%2$s获得了%9$s点%8$s。",
ACTION_SPELL_PERIODIC_ENERGIZE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_ENERGIZE_RESULT = "获得$extraAmount点%8$s",
ACTION_SPELL_PERIODIC_HEAL = "治疗",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT = "%4$s因%1$s%2$s获得了%9$s点生命值。%6$s",
ACTION_SPELL_PERIODIC_HEAL_FULL_TEXT_NO_SOURCE = "%4$s因%2$s恢复了%9$s点生命值。%6$s",
ACTION_SPELL_PERIODIC_HEAL_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH = "吸取",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT = "%1$s%2$s从%4$s身上吸取了%9$s点%8$s。%1$s获得了%10$s点%8$s。",
ACTION_SPELL_PERIODIC_LEECH_FULL_TEXT_NO_SOURCE = "%2$s从%4$s身上吸取了%9$s点%8$s。%1$s获得了%10$s点%8$s。",
ACTION_SPELL_PERIODIC_LEECH_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_LEECH_RESULT = "(获得%10$s点%8$s)",
ACTION_SPELL_PERIODIC_MISSED = "未命中",
ACTION_SPELL_PERIODIC_MISSED_ABSORB = "(%1$s 吸收)",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT = "%1$s%2$s被%4$s吸收了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s吸收了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_BLOCK = "(周期伤害被格挡)",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT = "%1$s%2$s暂时被%4$s格挡了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s格挡了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED = "(周期伤害被偏转)",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT = "%1$s%2$s暂时被%4$s偏转了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s偏转了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_DEFLECTED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_DODGE = "(周期伤害被躲闪)",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT = "%1$s%2$s暂时被%4$s躲闪了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s躲闪了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_EVADED = "(周期伤害被闪避)",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT = "%1$s%2$s暂时被%4$s闪避了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s闪避了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_EVADED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT = "%1$s%2$s暂时未能对%4$s产生影响。%6$s",
ACTION_SPELL_PERIODIC_MISSED_FULL_TEXT_NO_SOURCE = "%2$s暂时未能影响%4$s。%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE = "(免疫)",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT = "%4$s对%1$s %2$s免疫。%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_FULL_TEXT_NO_SOURCE = "%4$s对%2$s免疫。%6$s",
ACTION_SPELL_PERIODIC_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_MISS = "(周期伤害未命中)",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT = "%1$s%2$s暂时未命中%4$s。%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_FULL_TEXT_NO_SOURCE = "%2$s暂时未命中%4$s。%6$s",
ACTION_SPELL_PERIODIC_MISSED_MISS_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_PARRY = "(周期伤害被招架)",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT = "%1$s%2$s暂时被%4$s招架了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_FULL_TEXT_NO_SOURCE = "%2$s暂时被%4$s招架了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_POSSESSIVE = "1",
ACTION_SPELL_PERIODIC_MISSED_RESIST = "(周期伤害被抵抗)",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT = "%1$s%2$s未能对%4$s产生影响。%4$s抵抗了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_FULL_TEXT_NO_SOURCE = "%2$s未能影响%4$s。%4$s抵抗了。%6$s",
ACTION_SPELL_PERIODIC_MISSED_RESIST_POSSESSIVE = "1",
ACTION_SPELL_RESURRECT = "复活",
ACTION_SPELL_RESURRECT_FULL_TEXT = "%1$s%2$s复活了%4$s。%6$s",
ACTION_SPELL_RESURRECT_FULL_TEXT_NO_SOURCE = "%2$s复活了%4$s。%6$s",
ACTION_SPELL_RESURRECT_POSSESSIVE = "1",
ACTION_SPELL_STOLEN = "偷取",
ACTION_SPELL_STOLEN_BUFF = "偷取",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT = "%1$s%2$s偷取了%4$s%5$s。",
ACTION_SPELL_STOLEN_BUFF_FULL_TEXT_NO_SOURCE = "%2$s偷取了%4$s%5$s。",
ACTION_SPELL_STOLEN_BUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_BUFF__POSSESSIVE = "1",
ACTION_SPELL_STOLEN_DEBUFF = "偷取",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT = "%1$s%2$s将%4$s$extraSpell转移给了%1$s。",
ACTION_SPELL_STOLEN_DEBUFF_FULL_TEXT_NO_SOURCE = "%2$s转移了%4$s$extraSpell。",
ACTION_SPELL_STOLEN_DEBUFF_POSSESSIVE = "1",
ACTION_SPELL_STOLEN_FULL_TEXT = "%1$s%2$s偷取了%4$s%5$s。",
ACTION_SPELL_STOLEN_FULL_TEXT_NO_SOURCE = "%2$s偷取了%4$s%5$s。",
ACTION_SPELL_STOLEN_POSSESSIVE = "1",
ACTION_SPELL_SUMMON = "召唤",
ACTION_SPELL_SUMMON_FULL_TEXT = "%1$s%2$s召唤了%4$s。%6$s",
ACTION_SPELL_SUMMON_FULL_TEXT_NO_SOURCE = "%2$s召唤了%4$s。%6$s",
ACTION_SPELL_SUMMON_POSSESSIVE = "1",
ACTION_SWING = "近战攻击",
ACTION_SWING_DAMAGE = "命中",
ACTION_SWING_DAMAGE_FULL_TEXT = "%1$s近战攻击命中%4$s造成了%5$s伤害。%6$s",
ACTION_SWING_DAMAGE_FULL_TEXT_NO_SOURCE = "一次近战攻击命中%4$s造成了%5$s伤害。%6$s",
ACTION_SWING_DAMAGE_POSSESSIVE = "1",
ACTION_SWING_MISSED = "未命中",
ACTION_SWING_MISSED_ABSORB = "(吸收)",
ACTION_SWING_MISSED_ABSORB_FULL_TEXT = "%1$s攻击被%4$s吸收了。%6$s",
ACTION_SWING_MISSED_ABSORB_POSSESSIVE = "1",
ACTION_SWING_MISSED_BLOCK = "(格挡)",
ACTION_SWING_MISSED_BLOCK_FULL_TEXT = "%1$s攻击被%4$s格挡了。%6$s",
ACTION_SWING_MISSED_BLOCK_POSSESSIVE = "1",
ACTION_SWING_MISSED_DEFLECT = "(偏转)",
ACTION_SWING_MISSED_DEFLECT_FULL_TEXT = "%1$s攻击被%4$s偏转了。",
ACTION_SWING_MISSED_DEFLECT_POSSESSIVE = "1",
ACTION_SWING_MISSED_DODGE = "(躲闪)",
ACTION_SWING_MISSED_DODGE_FULL_TEXT = "%1$s攻击被%4$s躲闪了。",
ACTION_SWING_MISSED_DODGE_POSSESSIVE = "1",
ACTION_SWING_MISSED_EVADE = "(闪避)",
ACTION_SWING_MISSED_EVADE_FULL_TEXT = "%1$s攻击被%4$s闪避了。",
ACTION_SWING_MISSED_EVADE_POSSESSIVE = "1",
ACTION_SWING_MISSED_FULL_TEXT = "%1$s攻击未命中%4$s。",
ACTION_SWING_MISSED_IMMUNE = "(免疫)",
ACTION_SWING_MISSED_IMMUNE_FULL_TEXT = "%1$s攻击失败。%4$s对此免疫。",
ACTION_SWING_MISSED_IMMUNE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISFIRE = "(未命中)",
ACTION_SWING_MISSED_MISFIRE_FULL_TEXT = "%1$s攻击未命中%4$s。",
ACTION_SWING_MISSED_MISFIRE_POSSESSIVE = "1",
ACTION_SWING_MISSED_MISS = "(未命中)",
ACTION_SWING_MISSED_MISS_FULL_TEXT = "%1$s攻击未命中%4$s。",
ACTION_SWING_MISSED_MISS_POSSESSIVE = "1",
ACTION_SWING_MISSED_PARRY = "(招架)",
ACTION_SWING_MISSED_PARRY_FULL_TEXT = "%1$s攻击被%4$s招架了。",
ACTION_SWING_MISSED_PARRY_POSSESSIVE = "1",
ACTION_SWING_MISSED_POSSESSIVE = "1",
ACTION_SWING_MISSED_RESIST = "(抵抗)",
ACTION_SWING_MISSED_RESIST_FULL_TEXT = "%1$s攻击被%4$s完全抵抗了。%6$s",
ACTION_SWING_MISSED_RESIST_POSSESSIVE = "1",
ACTION_UNIT_BECCOMES_UNCONSCIOUS = "倒下",
ACTION_UNIT_BECOMES_UNCONSCIOUS_FULL_TEXT = "%4$s倒下了。",
ACTION_UNIT_BECOMES_UNCONSCIOUS_POSSESSIVE = "0",
ACTION_UNIT_DESTROYED = "摧毁",
ACTION_UNIT_DESTROYED_FULL_TEXT = "%4$s被摧毁了。",
ACTION_UNIT_DESTROYED_POSSESSIVE = "0",
ACTION_UNIT_DIED = "死亡",
ACTION_UNIT_DIED_FULL_TEXT = "%4$s死亡了。",
ACTION_UNIT_DIED_POSSESSIVE = "0",
ACTION_UNIT_DISSIPATES = "消散",
ACTION_UNIT_DISSIPATES_FULL_TEXT = "%4$s消散了。",
ACTION_UNIT_DISSIPATES_POSSESSIVE = "0",
ADD = "添加",
ADDITIONAL_FILTERS = "更多过滤条件",
ADD_FILTER = "添加过滤",
AURAS = "光环",
AURAS_COMBATLOG_TOOLTIP = "显示有关增益和负面状态效果的信息。",
BENEFICIAL = "增益",
BENEFICIAL_AURA_COMBATLOG_TOOLTIP = "当你获得或失去有益光环时显示信息。",
BLIZZARD_COMBAT_LOG_MENU_BOTH = "显示所有与%s有关的信息?",
BLIZZARD_COMBAT_LOG_MENU_EVERYTHING = "全部显示",
BLIZZARD_COMBAT_LOG_MENU_INCOMING = "%s发生了什么事情?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING = "%s做了些什么?",
BLIZZARD_COMBAT_LOG_MENU_OUTGOING_ME = "%s对你做了什么?",
BLIZZARD_COMBAT_LOG_MENU_RESET = "重置",
BLIZZARD_COMBAT_LOG_MENU_SAVE = "保存为新的过滤条件",
BLIZZARD_COMBAT_LOG_MENU_SPELL_HIDE = "隐藏与这一条类似的信息。",
BLIZZARD_COMBAT_LOG_MENU_SPELL_LINK = "将%s链接到聊天频道中。",
BY_SOURCE = "按来源",
BY_SOURCE_COMBATLOG_TOOLTIP = "按照施法者以颜色区分。",
BY_TARGET = "按目标",
BY_TARGET_COMBATLOG_TOOLTIP = "按照目标以颜色区分。",
COLORIZE = "彩色标记:",
COLORS = "颜色",
COLOR_BY_SCHOOL = "按类型区分颜色",
COMBATLOG_DEFAULTS = "战斗记录默认",
COMBATLOG_FILTER_STRING_CUSTOM_UNIT = "自定义单位",
COMBATLOG_FILTER_STRING_FRIENDLY_UNITS = "友方",
COMBATLOG_FILTER_STRING_HOSTILE_PLAYERS = "敌方玩家",
COMBATLOG_FILTER_STRING_HOSTILE_UNITS = "敌方单位",
COMBATLOG_FILTER_STRING_ME = "我",
COMBATLOG_FILTER_STRING_MY_PET = "宠物",
COMBATLOG_FILTER_STRING_NEUTRAL_UNITS = "中立",
COMBATLOG_FILTER_STRING_UNKNOWN_UNITS = "未知",
COMBATLOG_HIGHLIGHT_ABILITY = "技能",
COMBATLOG_HIGHLIGHT_DAMAGE = "伤害",
COMBATLOG_HIGHLIGHT_KILL = "杀死",
COMBATLOG_HIGHLIGHT_SCHOOL = "类型",
COMBATLOG_UNKNOWN_UNIT = "某目标",
COMBAT_FACTION_CHANGE = "声望",
COMBAT_HONOR_GAIN = "荣誉",
COMBAT_LOG_UNIT_YOU_ENABLED = "1",
COMBAT_MISC_INFO = "其它信息",
COMBAT_XP_GAIN = "经验",
CONFIRM_COMBAT_FILTER_DEFAULTS = "你确定要将过滤条件设定为初始状态吗?",
CONFIRM_COMBAT_FILTER_DELETE = "你确认要删除这个过滤条件?",
COPY_FILTER = "复制过滤",
DAMAGE_NUMBER = "伤害数值",
DAMAGE_SCHOOL_TEXT = "伤害类型",
DAMAGE_SHIELD = "伤害护盾",
DAMAGE_SHIELD_COMBATLOG_TOOLTIP = "当法术或技能(如荆棘术)对近战攻击造成反弹伤害时显示信息。",
DEATHS_COMBATLOG_TOOLTIP = "当某生物死亡时显示信息。",
DEFAULT_COMBATLOG_FILTER_NAME = "过滤条件%d",
DISPELS = "驱散",
DISPEL_AURA_COMBATLOG_TOOLTIP = "当光环被移除、破坏或偷取时显示信息。",
DONE_BY = "来源为:",
DONE_TO = "目标为:",
DRAINS = "吸取",
ENTER_FILTER_NAME = "输入过滤名称:",
ENTIRE_LINE = "整条信息",
ENTIRE_LINE_COMBATLOG_TOOLTIP = "按照下面的方式用彩色标记整条信息。",
ENVIRONMENTAL_DAMAGE = "环境伤害",
ENVIRONMENTAL_DAMAGE_COMBATLOG_TOOLTIP = "当某人因摔落、溺水或泡在岩浆中而损失生命值时显示信息。",
EXAMPLE_SPELL_FIREBALL = "火球术",
EXAMPLE_SPELL_FROSTBOLT = "寒冰箭",
EXAMPLE_TARGET_MONSTER = "怪物",
EXAMPLE_TEXT = "范例文字:",
EXTRA_ATTACKS = "额外攻击",
FAILURES = "失败",
FILTER_BY_ENEMIES_COMBATLOG_TOOLTIP = "敌方怪物和宠物进行的动作。",
FILTER_BY_FRIENDS_COMBATLOG_TOOLTIP = "由友方玩家、宠物和怪物进行的动作。",
FILTER_BY_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "敌方玩家进行的动作。",
FILTER_BY_ME_COMBATLOG_TOOLTIP = "由你、你的陷阱和你的法术进行的动作。",
FILTER_BY_NEUTRAL_COMBATLOG_TOOLTIP = "由中立生物进行的动作。",
FILTER_BY_PET_COMBATLOG_TOOLTIP = "由你的宠物、召唤生物和被魅惑玩家进行的动作。",
FILTER_BY_UNKNOWN_COMBATLOG_TOOLTIP = "由掉落、酸液或岩浆之类的源头产生的动作。",
FILTER_NAME = "过滤名称",
FILTER_TO_FRIENDS_COMBATLOG_TOOLTIP = "对友方玩家、宠物和怪物进行的动作。",
FILTER_TO_HOSTILE_COMBATLOG_TOOLTIP = "对敌方宠物和怪物进行的动作。",
FILTER_TO_HOSTILE_PLAYERS_COMBATLOG_TOOLTIP = "对敌方玩家进行的动作。",
FILTER_TO_ME_COMBATLOG_TOOLTIP = "对你进行的动作。",
FILTER_TO_NEUTRAL_COMBATLOG_TOOLTIP = "对中立生物进行的动作。",
FILTER_TO_PET_COMBATLOG_TOOLTIP = "对你的宠物、召唤生物和被魅惑玩家进行的动作。",
FILTER_TO_UNKNOWN_COMBATLOG_TOOLTIP = "对隐形目标进行的动作。",
FORMATTING = "格式",
FULL_TEXT_COMBATLOG_TOOLTIP = "整句显示战斗记录信息。",
HARMFUL_AURA_COMBATLOG_TOOLTIP = "当你获得或失去有害光环时显示信息。",
HEALS = "治疗",
HIGHLIGHTING = "高亮显示:",
HIGHLIGHT_ABILITY_COMBATLOG_TOOLTIP = "在战斗信息中高亮显示技能名。",
HIGHLIGHT_DAMAGE_COMBATLOG_TOOLTIP = "在战斗信息中高亮显示伤害数值。",
HIGHLIGHT_KILL_COMBATLOG_TOOLTIP = "高亮显示你或你的队友杀死敌人时所显示的信息。",
HIGHLIGHT_SCHOOL_COMBATLOG_TOOLTIP = "在战斗信息中高亮显示法术的类型。",
HOSTILE = "敌对",
INTERRUPTS = "打断",
ITEM_NAMES = "物品名",
ITEM_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "在物品名称外显示括号。",
KILLS_COMBATLOG_TOOLTIP = "当你的队友杀死某目标时显示信息。",
MELEE = "近战",
MELEE_COMBATLOG_TOOLTIP = "显示普通的近战攻击。",
MESSAGE_SOURCES = "信息来源",
MISSES = "未命中",
MOVE_FILTER_DOWN = "过滤条件下移",
MOVE_FILTER_UP = "过滤条件上移",
OTHER = "其它",
PERIODIC = "周期",
POWER_GAINS = "获得能量",
POWER_GAINS_COMBATLOG_TOOLTIP = "当法术或技能恢复法力、能量、怒气、集中值、真气、神圣能量或暗影宝珠时显示信息。",
QUICKBUTTON_NAME_EVERYTHING = "所有",
QUICKBUTTON_NAME_EVERYTHING_TOOLTIP = "显示所有战斗信息。",
QUICKBUTTON_NAME_KILLS = "杀敌",
QUICKBUTTON_NAME_KILLS_TOOLTIP = "显示所有死亡和杀敌信息。",
QUICKBUTTON_NAME_ME = "我发生了什么?",
QUICKBUTTON_NAME_ME_TOOLTIP = "显示我所接收的所有行为信息。",
QUICKBUTTON_NAME_SELF = "自己",
QUICKBUTTON_NAME_SELF_TOOLTIP = "显示你所进行的和你所接收的动作的信息。",
QUICK_BUTTON_COMBATLOG_TOOLTIP = "在聊天窗口中放置一个该过滤条件的快捷方式。",
RANGED = "远程",
RANGED_COMBATLOG_TOOLTIP = "显示弓箭、枪械、投掷武器和魔杖的攻击。",
RANGE_DAMAGE_COMBATLOG_TOOLTIP = "显示造成了全额或部分伤害的远程射击。",
RANGE_MISSED_COMBATLOG_TOOLTIP = "显示未能造成伤害的远程射击。",
RESURRECT = "复活",
SETTINGS = "设置",
SHOW_BRACES = "显示括号",
SHOW_BRACES_COMBATLOG_TOOLTIP = "在战斗记录信息中的超链接外显示括号。",
SHOW_QUICK_BUTTON = "显示快捷按钮",
SHOW_TIMESTAMP = "显示时间戳",
SOURCE = "来源:",
SPECIAL = "特殊",
SPELLS_COMBATLOG_TOOLTIP = "显示有关法术和特殊技能的信息。",
SPELL_CASTING = "法术施放",
SPELL_CASTING_COMBATLOG_TOOLTIP = "显示有关法术施放的信息。",
SPELL_CAST_FAILED_COMBATLOG_TOOLTIP = "当法术无法施放或施放失败时显示信息。",
SPELL_CAST_START_COMBATLOG_TOOLTIP = "当法术开始施放时显示信息。",
SPELL_CAST_SUCCESS_COMBATLOG_TOOLTIP = "当法术成功施放时显示信息。",
SPELL_COLOR_BY_SCHOOL_COMBATLOG_TOOLTIP = "按类型用彩色标记法术名。",
SPELL_DAMAGE_COMBATLOG_TOOLTIP = "当法术或技能造成伤害时显示信息。",
SPELL_DAMAGE_NUMBER_COMBATLOG_TOOLTIP = "以彩色标记非普通攻击的伤害数值。",
SPELL_DAMAGE_SCHOOL_COMBATLOG_TOOLTIP = "彩色标记伤害类型。(例如:暗影)",
SPELL_DRAIN_COMBATLOG_TOOLTIP = "当法术或技能降低法力、能量、怒气、或集中值时显示信息。",
SPELL_EXTRA_ATTACKS_COMBATLOG_TOOLTIP = "当法术或技能提供额外攻击时显示信息。",
SPELL_HEAL_COMBATLOG_TOOLTIP = "当法术或技能恢复生命值时显示信息。",
SPELL_INSTAKILL_COMBATLOG_TOOLTIP = "显示有关特殊法术类型的信息,比如造成耐久度损失或者与宠物分担伤害的法术。",
SPELL_INTERRUPT_COMBATLOG_TOOLTIP = "当法术或技能打断另一个法术时显示信息。",
SPELL_MISSED_COMBATLOG_TOOLTIP = "当法术或技能未能造成伤害时显示信息。这包括躲闪、招架、格挡、偏转、免疫、吸收和闪避。",
SPELL_NAMES = "法术名",
SPELL_NAMES_COMBATLOG_TOOLTIP = "彩色标记法术名。",
SPELL_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "在法术名称外显示括号。",
SPELL_PERIODIC_COMBATLOG_TOOLTIP = "显示法术效果增量的信息。",
SPELL_PERIODIC_DAMAGE_COMBATLOG_TOOLTIP = "当法术或技能周期性地造成伤害时(如暗言术:痛或腐蚀术)显示信息。",
SPELL_PERIODIC_HEAL_COMBATLOG_TOOLTIP = "当法术或技能周期性地恢复生命值时(如恢复或回春术)显示信息。",
SPELL_PERIODIC_MISSED_COMBATLOG_TOOLTIP = "当法术或技能未能造成周期性的伤害时显示信息。这包括免疫、吸收和闪避。",
SPELL_PERIODIC_OTHER_COMBATLOG_TOOLTIP = "当法术或技能周期性地产生其它效果时(如恢复或吸取法力值)显示信息。",
SPELL_RESURRECT_COMBATLOG_TOOLTIP = "当法术或技能复活另一个玩家或怪物时显示信息。",
SPELL_SUMMON_COMBATLOG_TOOLTIP = "当法术召唤出怪物或创造一个物体时显示信息。",
START = "开始",
STRING_SCHOOL_UNKNOWN = "未知",
SUCCESS = "成功",
SUMMONS = "召唤",
SWING_DAMAGE_COMBATLOG_TOOLTIP = "显示造成了全额或部分伤害的近战攻击。",
SWING_MISSED_COMBATLOG_TOOLTIP = "显示未能造成伤害的近战攻击。",
TEXT_MODE_A = "A",
TEXT_MODE_A_STRING_1 = "%s %s %s %s %s. %s %11$s",
TEXT_MODE_A_STRING_2 = "%1$s %3$s%2$s%4$s%5$s。%6$s",
TEXT_MODE_A_STRING_3 = "%1$s%5$s%3$s%4$s%2$s。%6$s",
TEXT_MODE_A_STRING_ACTION = "|Haction:%s|h%s|h",
TEXT_MODE_A_STRING_BRACE_ITEM = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_SPELL = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_BRACE_UNIT = "|c%s[|r%s|c%s]|r",
TEXT_MODE_A_STRING_DEST_ICON = "|Hicon:%d:dest|h%s|h",
TEXT_MODE_A_STRING_DEST_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_ITEM = "|Hitem:%s|h%s|h",
TEXT_MODE_A_STRING_POSSESSIVE = "%s的",
TEXT_MODE_A_STRING_REMAINING_POINTS = "(剩余%s)",
TEXT_MODE_A_STRING_RESULT_ABSORB = "(%s 吸收)",
TEXT_MODE_A_STRING_RESULT_BLOCK = "(%s 格挡)",
TEXT_MODE_A_STRING_RESULT_CRITICAL = "(爆击)",
TEXT_MODE_A_STRING_RESULT_CRITICAL_SPELL = "(爆击)",
TEXT_MODE_A_STRING_RESULT_CRUSHING = "(碾压)",
TEXT_MODE_A_STRING_RESULT_FORMAT = "$resultAmount点$resultType",
TEXT_MODE_A_STRING_RESULT_GLANCING = "(偏斜)",
TEXT_MODE_A_STRING_RESULT_MULTISTRIKE = "(溅射)",
TEXT_MODE_A_STRING_RESULT_OVERENERGIZE = "(%s 过量充能)",
TEXT_MODE_A_STRING_RESULT_OVERHEALING = "(%s 过量治疗)",
TEXT_MODE_A_STRING_RESULT_OVERKILLING = "(%s 过量伤害)",
TEXT_MODE_A_STRING_RESULT_PARRY = "(%d招架)",
TEXT_MODE_A_STRING_RESULT_REFLECT = "被反射",
TEXT_MODE_A_STRING_RESULT_RESIST = "(%s 抵抗)",
TEXT_MODE_A_STRING_RESULT_VULNERABILITY = "(%s 易伤伤害)",
TEXT_MODE_A_STRING_SOURCE_ICON = "|Hicon:%s:source|h%s|h",
TEXT_MODE_A_STRING_SOURCE_UNIT = "%s|Hunit:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_SPELL_EXTRA = "|Hspell:%s:%s:%s|h%s|h",
TEXT_MODE_A_STRING_TIMESTAMP = "%s> %s",
TEXT_MODE_A_STRING_VALUE_SCHOOL = "%s %s",
TEXT_MODE_A_STRING_VALUE_TYPE = "%s(%s)",
TEXT_MODE_A_TIMESTAMP = "%H:%M:%S",
TIMESTAMP_COMBATLOG_TOOLTIP = "显示战斗记录信息的时间戳。",
UNIT_COLORS = "单位颜色:",
UNIT_NAMES = "单位名称",
UNIT_NAMES_COMBATLOG_TOOLTIP = "彩色标记单位名。",
UNIT_NAMES_SHOW_BRACES_COMBATLOG_TOOLTIP = "在单位名称外显示括号。",
UNIT_YOU = "你",
UNIT_YOU_DEST = "你",
UNIT_YOU_DEST_POSSESSIVE = "你的",
UNIT_YOU_SOURCE = "你",
UNIT_YOU_SOURCE_POSSESSIVE = "你的",
USE_FULL_TEXT_MODE = "使用详细模式",
}
+15 -1070
View File
File diff suppressed because it is too large Load Diff
+15 -1072
View File
File diff suppressed because it is too large Load Diff
+15 -1065
View File
File diff suppressed because it is too large Load Diff
+15 -1061
View File
File diff suppressed because it is too large Load Diff
+15 -1031
View File
File diff suppressed because it is too large Load Diff
+15 -1068
View File
File diff suppressed because it is too large Load Diff
+15 -1085
View File
File diff suppressed because it is too large Load Diff
+3 -3
View File
@@ -724,10 +724,10 @@ local light = {
["showicon"] = "1", ["showicon"] = "1",
}, },
}, },
["cooldown"] = {
["font"] = "Interface\\AddOns\\pfUI\\fonts\\Myriad-Pro.ttf",
},
["appearance"] = { ["appearance"] = {
["cd"] = {
["font"] = "Interface\\AddOns\\pfUI\\fonts\\Myriad-Pro.ttf",
},
["castbar"] = { ["castbar"] = {
["texture"] = "Interface\\AddOns\\pfUI\\img\\bar_gradient", ["texture"] = "Interface\\AddOns\\pfUI\\img\\bar_gradient",
}, },
+37 -62
View File
@@ -1,71 +1,46 @@
RACE_ICON_TCOORDS = RACE_ICON_TCOORDS or {
["HUMAN_MALE"] = {0, 0.25, 0, 0.25},
["DWARF_MALE"] = {0.25, 0.5, 0, 0.25},
["GNOME_MALE"] = {0.5, 0.75, 0, 0.25},
["NIGHTELF_MALE"] = {0.75, 1.0, 0, 0.25},
["TAUREN_MALE"] = {0, 0.25, 0.25, 0.5},
["SCOURGE_MALE"] = {0.25, 0.5, 0.25, 0.5},
["TROLL_MALE"] = {0.5, 0.75, 0.25, 0.5},
["ORC_MALE"] = {0.75, 1.0, 0.25, 0.5},
["HUMAN_FEMALE"] = {0, 0.25, 0.5, 0.75},
["DWARF_FEMALE"] = {0.25, 0.5, 0.5, 0.75},
["GNOME_FEMALE"] = {0.5, 0.75, 0.5, 0.75},
["NIGHTELF_FEMALE"] = {0.75, 1.0, 0.5, 0.75},
["TAUREN_FEMALE"] = {0, 0.25, 0.75, 1.0},
["SCOURGE_FEMALE"] = {0.25, 0.5, 0.75, 1.0},
["TROLL_FEMALE"] = {0.5, 0.75, 0.75, 1.0},
["ORC_FEMALE"] = {0.75, 1.0, 0.75, 1.0},
};
CLASS_ICON_TCOORDS = CLASS_ICON_TCOORDS or { CLASS_ICON_TCOORDS = CLASS_ICON_TCOORDS or {
["WARRIOR"] = {0, 0.25, 0, 0.25}, ["WARRIOR"] = {0, 0.25, 0, 0.25},
["MAGE"] = {0.25, 0.49609375, 0, 0.25}, ["MAGE"] = {0.25, 0.49609375, 0, 0.25},
["ROGUE"] = {0.49609375, 0.7421875, 0, 0.25}, ["ROGUE"] = {0.49609375, 0.7421875, 0, 0.25},
["DRUID"] = {0.7421875, 0.98828125, 0, 0.25}, ["DRUID"] = {0.7421875, 0.98828125, 0, 0.25},
["HUNTER"] = {0, 0.25, 0.25, 0.5}, ["HUNTER"] = {0, 0.25, 0.25, 0.5},
["SHAMAN"] = {0.25, 0.49609375, 0.25, 0.5}, ["SHAMAN"] = {0.25, 0.49609375, 0.25, 0.5},
["PRIEST"] = {0.49609375, 0.7421875, 0.25, 0.5}, ["PRIEST"] = {0.49609375, 0.7421875, 0.25, 0.5},
["WARLOCK"] = {0.7421875, 0.98828125, 0.25, 0.5}, ["WARLOCK"] = {0.7421875, 0.98828125, 0.25, 0.5},
["PALADIN"] = {0, 0.25, 0.5, 0.75}, ["PALADIN"] = {0, 0.25, 0.5, 0.75}
["DEATHKNIGHT"] = {0.25, .5, 0.5, .75}, };
["GM"] = {0.5, 0.73828125, 0.5, .75},
}
-- barlength = {[formfactor]={cols, rows}} -- Vendor-buy prices for the stock 1.12 item set. Pulled in by init\stock.xml,
pfGridmath = { -- so pfUI_ClassicAPI.toc only: Turtle has its own list in
[1] = {{1,1}}, -- env\tables_turtle.lua, loaded from init\turtle.xml instead.
[2] = {{2,1},{1,2}},
[3] = {{3,1},{1,3}},
[4] = {{4,1},{2,2},{1,4}},
[5] = {{5,1},{1,5}},
[6] = {{6,1},{3,2},{2,3},{1,6}},
[7] = {{7,1},{1,7}},
[8] = {{8,1},{4,2},{2,4},{1,8}},
[9] = {{9,1},{3,3},{1,9}},
[10] = {{10,1},{5,2},{2,5},{1,10}},
[11] = {{11,1},{1,11}},
[12] = {{12,1},{6,2},{4,3},{3,4},{2,6},{1,12}}
}
-- list of valid unitstrings
pfValidUnits = {}
pfValidUnits["pet"] = true
pfValidUnits["player"] = true
pfValidUnits["target"] = true
pfValidUnits["mouseover"] = true
pfValidUnits["focus"] = true
pfValidUnits["focustarget"] = true
pfValidUnits["focustargettarget"] = true
pfValidUnits["pettarget"] = true
pfValidUnits["playertarget"] = true
pfValidUnits["targettarget"] = true
pfValidUnits["mouseovertarget"] = true
pfValidUnits["targettargettarget"] = true
for i=1,4 do
pfValidUnits["party" .. i] = true
pfValidUnits["party" .. i .. "target"] = true
pfValidUnits["partypet" .. i] = true
pfValidUnits["partypet" .. i .. "target"] = true
end
for i=1,40 do
pfValidUnits["raid" .. i] = true
pfValidUnits["raid" .. i .. "target"] = true
pfValidUnits["raidpet" .. i] = true
pfValidUnits["raidpet" .. i .. "target"] = true
pfValidUnits["nameplate" .. i] = true
pfValidUnits["nameplate" .. i .. "target"] = true
end
-- This table makes me sick.
-- itemid = buyPrice (copper). Sell price comes from C_Item.GetItemSellPriceByID; -- itemid = buyPrice (copper). Sell price comes from C_Item.GetItemSellPriceByID;
-- this table only carries the curated vendor-buy price (which isn't a static -- this table only carries the curated vendor-buy price (which isn't a static
-- engine field — it's collected from real vendor encounters). -- engine field — it's collected from real vendor encounters).
pfSellData = { pfSellData = {
[25]=35, [35]=47, [36]=38, [37]=38, [38]=1, [39]=5, [25]=35, [35]=47, [36]=38, [37]=38, [38]=1, [39]=5,
[40]=4, [41]=2, [42]=2, [43]=4, [44]=4, [45]=1, [40]=4, [41]=2, [42]=2, [43]=4, [44]=4, [45]=1,
+2991
View File
File diff suppressed because it is too large Load Diff
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["deDE"] = { pfUI_translation["deDE"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = nil, ["Abbreviate Numbers (4200 -> 4.2k)"] = nil,
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["deDE"] = {
["Actionbar"] = nil, ["Actionbar"] = nil,
["Action Bar"] = nil, ["Action Bar"] = nil,
["Action Bar Border Size"] = nil, ["Action Bar Border Size"] = nil,
["Action Bars"] = nil,
["Active Addons"] = nil, ["Active Addons"] = nil,
["Add button to the frame"] = nil, ["Add button to the frame"] = nil,
["Added button"] = nil, ["Added button"] = nil,
@@ -27,12 +30,11 @@ pfUI_translation["deDE"] = {
["Always Show Item Comparison"] = nil, ["Always Show Item Comparison"] = nil,
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = nil,
["Ammo Counter"] = nil, ["Ammo Counter"] = nil,
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil, ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil,
["A new version is available"] = nil, ["A new version is available"] = nil,
["Animate Health And Power Bars"] = nil,
["Appearance"] = nil, ["Appearance"] = nil,
["Ascending"] = nil, ["Ascending"] = nil,
["Author"] = nil, ["Author"] = nil,
@@ -52,10 +54,12 @@ pfUI_translation["deDE"] = {
["Auto Sell Grey Items"] = nil, ["Auto Sell Grey Items"] = nil,
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = nil, ["Background Color"] = nil,
["Bags"] = "Taschen",
["Bags & Bank"] = nil, ["Bags & Bank"] = nil,
["Bags Border Size"] = nil, ["Bags Border Size"] = nil,
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = nil, ["Bagspace"] = nil,
["Bank"] = "Bank",
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -77,7 +81,7 @@ pfUI_translation["deDE"] = {
["Buffbar Width"] = nil, ["Buffbar Width"] = nil,
["Buff/Debuff Icons"] = nil, ["Buff/Debuff Icons"] = nil,
["Buff/Debuff Indicators"] = nil, ["Buff/Debuff Indicators"] = nil,
["Buff Font Size"] = nil, ["Buff Indicators"] = nil,
["Buff Limit"] = nil, ["Buff Limit"] = nil,
["Buff Position"] = nil, ["Buff Position"] = nil,
["Buffs"] = nil, ["Buffs"] = nil,
@@ -119,11 +123,16 @@ pfUI_translation["deDE"] = {
["Chat Bubble Transparency"] = nil, ["Chat Bubble Transparency"] = nil,
["Chat Default Brackets"] = nil, ["Chat Default Brackets"] = nil,
["Class"] = nil, ["Class"] = nil,
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = nil, ["Clear Rolls"] = nil,
["Click Action"] = nil, ["Click Action"] = nil,
["Click Casting"] = nil, ["Click Casting"] = nil,
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = nil, ["Clock"] = nil,
["Close"] = nil, ["Close"] = nil,
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -143,21 +152,16 @@ pfUI_translation["deDE"] = {
["Configuration"] = nil, ["Configuration"] = nil,
["Configure"] = nil, ["Configure"] = nil,
["Cooldown"] = nil, ["Cooldown"] = nil,
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = nil, ["Cooldown Color (Days)"] = nil,
["Cooldown Color (Hours)"] = nil, ["Cooldown Color (Hours)"] = nil,
["Cooldown Color (Less than 3 Sec)"] = nil,
["Cooldown Color (Minutes)"] = nil, ["Cooldown Color (Minutes)"] = nil,
["Cooldown Color (Seconds)"] = nil, ["Cooldown Color (Seconds)"] = nil,
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = nil,
["Cooldown Text Font Size (Blizzard Frames)"] = nil,
["Cooldown Text Font Size (Foreign Frames)"] = nil,
["Cooldown Text Size"] = nil,
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = nil,
["Coordinates Location"] = nil, ["Coordinates Location"] = nil,
["Coordinates On Minimap"] = nil, ["Coordinates On Minimap"] = nil,
["Copied to clipboard"] = nil,
["Count"] = nil, ["Count"] = nil,
["Create Profile"] = nil, ["Create Profile"] = nil,
["Ctrl-Click"] = nil, ["Ctrl-Click"] = nil,
@@ -198,7 +202,6 @@ pfUI_translation["deDE"] = {
["Description Font"] = nil, ["Description Font"] = nil,
["Description Font Size"] = nil, ["Description Font Size"] = nil,
["Detailed Random Roll Announcement"] = nil, ["Detailed Random Roll Announcement"] = nil,
["Detect Enemy Buffs"] = nil,
["Disable"] = nil, ["Disable"] = nil,
["Disable Blizzard Castbar"] = nil, ["Disable Blizzard Castbar"] = nil,
["Disabled"] = nil, ["Disabled"] = nil,
@@ -275,12 +278,9 @@ pfUI_translation["deDE"] = {
["Enable Custom Incoming Whispers Layout"] = nil, ["Enable Custom Incoming Whispers Layout"] = nil,
["Enable Debuff Display"] = nil, ["Enable Debuff Display"] = nil,
["Enable Debuffs"] = nil, ["Enable Debuffs"] = nil,
["Enable Durations On Blizzard Frames"] = nil,
["Enable Durations On Foreign Frames"] = nil,
["Enable Energy Ticks"] = nil, ["Enable Energy Ticks"] = nil,
["Enable Extended Guild Information"] = nil, ["Enable Extended Guild Information"] = nil,
["Enable Frame Shadow"] = nil, ["Enable Frame Shadow"] = nil,
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = nil, ["Enable Indicators"] = nil,
["Enable Item Quality Color For Equipment Only"] = nil, ["Enable Item Quality Color For Equipment Only"] = nil,
["Enable \"Loot & Spam\" Chat Window"] = nil, ["Enable \"Loot & Spam\" Chat Window"] = nil,
@@ -290,7 +290,6 @@ pfUI_translation["deDE"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = nil, ["Enable Micro Bar"] = nil,
["Enable Mouselook With Right Click"] = nil, ["Enable Mouselook With Right Click"] = nil,
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = nil, ["Enable Offscreen Frame Positions"] = nil,
["Enable Overlap"] = nil, ["Enable Overlap"] = nil,
@@ -311,6 +310,7 @@ pfUI_translation["deDE"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "Angelegt",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -335,6 +335,7 @@ pfUI_translation["deDE"] = {
["Font"] = nil, ["Font"] = nil,
["Font Options"] = nil, ["Font Options"] = nil,
["Font Padding"] = nil, ["Font Padding"] = nil,
["Font Size"] = nil,
["Font Style"] = nil, ["Font Style"] = nil,
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = nil, ["fps"] = nil,
@@ -369,7 +370,6 @@ pfUI_translation["deDE"] = {
["Health"] = nil, ["Health"] = nil,
["Health - Auto"] = nil, ["Health - Auto"] = nil,
["Healthbar"] = nil, ["Healthbar"] = nil,
["Healthbar Animation Speed"] = nil,
["Health Bar Color"] = nil, ["Health Bar Color"] = nil,
["Healthbar Embedded"] = nil, ["Healthbar Embedded"] = nil,
["Healthbar Height"] = nil, ["Healthbar Height"] = nil,
@@ -394,7 +394,6 @@ pfUI_translation["deDE"] = {
["Hide Channel Names"] = nil, ["Hide Channel Names"] = nil,
["Hide Chat When Bags Are Opened"] = nil, ["Hide Chat When Bags Are Opened"] = nil,
["Hide Combat Log"] = nil, ["Hide Combat Log"] = nil,
["Hide Foreign Cooldown Animations"] = nil,
["Hide Group Frames While In Raid"] = nil, ["Hide Group Frames While In Raid"] = nil,
["Hide Healthbar On Critters"] = nil, ["Hide Healthbar On Critters"] = nil,
["Hide Healthbar On Enemy NPCs"] = nil, ["Hide Healthbar On Enemy NPCs"] = nil,
@@ -403,6 +402,7 @@ pfUI_translation["deDE"] = {
["Hide Healthbar On Friendly Players"] = nil, ["Hide Healthbar On Friendly Players"] = nil,
["Hide Healthbar On Neutral NPCs"] = nil, ["Hide Healthbar On Neutral NPCs"] = nil,
["Hide Healthbar On Totems"] = nil, ["Hide Healthbar On Totems"] = nil,
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = nil, ["Hide Timeout"] = nil,
["Hide When Entering Combat"] = nil, ["Hide When Entering Combat"] = nil,
["Highlight Equipped Items"] = nil, ["Highlight Equipped Items"] = nil,
@@ -431,7 +431,6 @@ pfUI_translation["deDE"] = {
["Inherit Default Colors"] = nil, ["Inherit Default Colors"] = nil,
["Inputbox Height"] = nil, ["Inputbox Height"] = nil,
["Inputbox Width"] = nil, ["Inputbox Width"] = nil,
["Instant"] = nil,
["Integrations"] = nil, ["Integrations"] = nil,
["Invert Health Bar"] = nil, ["Invert Health Bar"] = nil,
["is not allowed in profile name"] = nil, ["is not allowed in profile name"] = nil,
@@ -476,6 +475,7 @@ pfUI_translation["deDE"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = nil, ["Loot"] = nil,
["Loot & Spam"] = nil, ["Loot & Spam"] = nil,
["Loss Of Control"] = nil,
["Macro Text Color"] = nil, ["Macro Text Color"] = nil,
["Macro Text Size"] = nil, ["Macro Text Size"] = nil,
["Main Actionbar"] = nil, ["Main Actionbar"] = nil,
@@ -515,6 +515,7 @@ pfUI_translation["deDE"] = {
["Name | Health Missing"] = nil, ["Name | Health Missing"] = nil,
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = nil, ["Nameplate Border Size"] = nil,
["Nameplate Debuffs"] = nil,
["Nameplates"] = nil, ["Nameplates"] = nil,
["Nameplate Width"] = nil, ["Nameplate Width"] = nil,
["Name (Short)"] = nil, ["Name (Short)"] = nil,
@@ -553,6 +554,7 @@ pfUI_translation["deDE"] = {
["On State Change"] = nil, ["On State Change"] = nil,
["Options"] = nil, ["Options"] = nil,
["Orientation"] = nil, ["Orientation"] = nil,
["Other Addons"] = nil,
["Other Panel: Minimap"] = nil, ["Other Panel: Minimap"] = nil,
["Outline"] = nil, ["Outline"] = nil,
["Outlines"] = nil, ["Outlines"] = nil,
@@ -568,6 +570,7 @@ pfUI_translation["deDE"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = nil, ["Panel"] = nil,
@@ -580,6 +583,7 @@ pfUI_translation["deDE"] = {
["Pixel"] = nil, ["Pixel"] = nil,
["Player"] = nil, ["Player"] = nil,
["Player Buff Bar"] = nil, ["Player Buff Bar"] = nil,
["Player Buffs"] = nil,
["Player Castbar"] = nil, ["Player Castbar"] = nil,
["Player Debuff Bar"] = nil, ["Player Debuff Bar"] = nil,
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["deDE"] = {
["Portrait Alpha"] = nil, ["Portrait Alpha"] = nil,
["Portrait Height"] = nil, ["Portrait Height"] = nil,
["Portrait Position"] = nil, ["Portrait Position"] = nil,
["Portrait Style"] = nil,
["Portrait Width"] = nil, ["Portrait Width"] = nil,
["Powerbar"] = nil, ["Powerbar"] = nil,
["Power Bar Anchor"] = nil, ["Power Bar Anchor"] = nil,
@@ -615,6 +620,7 @@ pfUI_translation["deDE"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
@@ -644,6 +650,7 @@ pfUI_translation["deDE"] = {
["Resting"] = nil, ["Resting"] = nil,
["Reveal Unexplored Areas"] = nil, ["Reveal Unexplored Areas"] = nil,
["Switch to current zone"] = "Zur aktuellen Zone wechseln", ["Switch to current zone"] = "Zur aktuellen Zone wechseln",
["Reverse Sweep On"] = nil,
["Right"] = nil, ["Right"] = nil,
["Right Actionbar"] = nil, ["Right Actionbar"] = nil,
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["deDE"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scale Font Size With Icon"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = nil, ["Screen Resolution"] = nil,
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -702,6 +709,7 @@ pfUI_translation["deDE"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -724,7 +732,7 @@ pfUI_translation["deDE"] = {
["Show Loot Icon"] = nil, ["Show Loot Icon"] = nil,
["Show Macro Text"] = nil, ["Show Macro Text"] = nil,
["Show Meters By Default"] = nil, ["Show Meters By Default"] = nil,
["Show Milliseconds When Timer Runs Out"] = nil, ["Show Numbers On"] = nil,
["Show On Friendly Units"] = nil, ["Show On Friendly Units"] = nil,
["Show On Hostile Units"] = nil, ["Show On Hostile Units"] = nil,
["Show Procs Indicators"] = nil, ["Show Procs Indicators"] = nil,
@@ -738,13 +746,14 @@ pfUI_translation["deDE"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = nil,
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = nil,
["Show Timer Text"] = nil, ["Show Timer Text"] = nil,
["Show Totems Indicators"] = nil, ["Show Totems Indicators"] = nil,
["Shrink & Return"] = nil, ["Shrink & Return"] = nil,
@@ -761,8 +770,10 @@ pfUI_translation["deDE"] = {
["Soulshards"] = nil, ["Soulshards"] = nil,
["Spacing"] = nil, ["Spacing"] = nil,
["Special Recipient"] = nil, ["Special Recipient"] = nil,
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = nil, ["Square"] = nil,
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = nil, ["Stance Bar 1"] = nil,
["Stance Bar 2"] = nil, ["Stance Bar 2"] = nil,
["Stance Bar 3"] = nil, ["Stance Bar 3"] = nil,
@@ -797,7 +808,6 @@ pfUI_translation["deDE"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = nil, ["Threshold To Trust Health Estimation"] = nil,
["Time"] = nil, ["Time"] = nil,
["Timer"] = nil,
["Time Remaining"] = nil, ["Time Remaining"] = nil,
["Timer In Minutes"] = nil, ["Timer In Minutes"] = nil,
["Timestamp Brackets"] = nil, ["Timestamp Brackets"] = nil,
@@ -808,6 +818,7 @@ pfUI_translation["deDE"] = {
["Tiny (PixelPerfect)"] = nil, ["Tiny (PixelPerfect)"] = nil,
["Toggle as Tank"] = nil, ["Toggle as Tank"] = nil,
["Tooltip"] = nil, ["Tooltip"] = nil,
["Tooltip Auras"] = nil,
["Tooltip Position"] = nil, ["Tooltip Position"] = nil,
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["deDE"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = "Gesamt",
["Total Gold"] = nil, ["Total Gold"] = nil,
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
["Totems"] = nil,
["Tracked Reputation"] = nil, ["Tracked Reputation"] = nil,
["Tracking Icon Size"] = nil, ["Tracking Icon Size"] = nil,
["Trigger Actions On Key Down"] = nil, ["Trigger Actions On Key Down"] = nil,
["UI-Scale"] = nil, ["UI-Scale"] = nil,
["Unbuffed"] = nil, ["Unbuffed"] = nil,
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = nil, ["Unit Frame Border Size"] = nil,
["Unit Frame Layout"] = nil, ["Unit Frame Layout"] = nil,
["Unit Frames"] = nil, ["Unit Frames"] = nil,
@@ -849,7 +863,6 @@ pfUI_translation["deDE"] = {
["Use Custom Color Power Bar Background"] = nil, ["Use Custom Color Power Bar Background"] = nil,
["Use Custom Font Settings"] = nil, ["Use Custom Font Settings"] = nil,
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = nil,
["Use Item Rarity Color For Loot-Roll Timer"] = nil, ["Use Item Rarity Color For Loot-Roll Timer"] = nil,
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = nil, ["Use Raid Frames To Display Group Members"] = nil,
@@ -867,7 +880,6 @@ pfUI_translation["deDE"] = {
["Website"] = nil, ["Website"] = nil,
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = nil, ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = nil,
["Whitelist"] = nil, ["Whitelist"] = nil,
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = nil, ["Width"] = nil,
["Wobble Zoom"] = nil, ["Wobble Zoom"] = nil,
["Won"] = nil, ["Won"] = nil,
+49 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["enUS"] = { pfUI_translation["enUS"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = nil, ["Abbreviate Numbers (4200 -> 4.2k)"] = nil,
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["enUS"] = {
["Actionbar"] = nil, ["Actionbar"] = nil,
["Action Bar"] = nil, ["Action Bar"] = nil,
["Action Bar Border Size"] = nil, ["Action Bar Border Size"] = nil,
["Action Bars"] = nil,
["Active Addons"] = nil, ["Active Addons"] = nil,
["Add button to the frame"] = nil, ["Add button to the frame"] = nil,
["Added button"] = nil, ["Added button"] = nil,
@@ -28,12 +31,11 @@ pfUI_translation["enUS"] = {
["Always Show Item Comparison"] = nil, ["Always Show Item Comparison"] = nil,
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = nil,
["Ammo Counter"] = nil, ["Ammo Counter"] = nil,
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil, ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil,
["A new version is available"] = nil, ["A new version is available"] = nil,
["Animate Health And Power Bars"] = nil,
["Appearance"] = nil, ["Appearance"] = nil,
["Ascending"] = nil, ["Ascending"] = nil,
["Author"] = nil, ["Author"] = nil,
@@ -53,15 +55,19 @@ pfUI_translation["enUS"] = {
["Auto Sell Grey Items"] = nil, ["Auto Sell Grey Items"] = nil,
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = nil, ["Background Color"] = nil,
["Bags"] = nil,
["Bags & Bank"] = nil, ["Bags & Bank"] = nil,
["Bags Border Size"] = nil, ["Bags Border Size"] = nil,
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = nil, ["Bagspace"] = nil,
["Bank"] = nil,
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
["Bar Texture"] = nil, ["Bar Texture"] = nil,
["Battleground Frames"] = nil,
["Battleground Statistics"] = nil, ["Battleground Statistics"] = nil,
["BEHIND"] = nil,
["Blacklist"] = nil, ["Blacklist"] = nil,
["Blinding Powder"] = nil, ["Blinding Powder"] = nil,
["Blue Border On Friendly Players"] = nil, ["Blue Border On Friendly Players"] = nil,
@@ -78,12 +84,14 @@ pfUI_translation["enUS"] = {
["Buffbar Width"] = nil, ["Buffbar Width"] = nil,
["Buff/Debuff Icons"] = nil, ["Buff/Debuff Icons"] = nil,
["Buff/Debuff Indicators"] = nil, ["Buff/Debuff Indicators"] = nil,
["Buff Font Size"] = nil, ["Buff Indicators"] = nil,
["Buff Limit"] = nil, ["Buff Limit"] = nil,
["Buff Position"] = nil, ["Buff Position"] = nil,
["Buffs"] = nil, ["Buffs"] = nil,
["Buff Size"] = nil, ["Buff Size"] = nil,
["Buff Spacing"] = nil, ["Buff Spacing"] = nil,
["Buff X-Spacing"] = nil,
["Buff Y-Spacing"] = nil,
["Buffs Per Row"] = nil, ["Buffs Per Row"] = nil,
["Button"] = nil, ["Button"] = nil,
["Button already exists in pfMinimapButtons frame"] = nil, ["Button already exists in pfMinimapButtons frame"] = nil,
@@ -120,12 +128,17 @@ pfUI_translation["enUS"] = {
["Chat Bubble Transparency"] = nil, ["Chat Bubble Transparency"] = nil,
["Chat Default Brackets"] = nil, ["Chat Default Brackets"] = nil,
["Class"] = nil, ["Class"] = nil,
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear"] = nil, ["Clear"] = nil,
["Clear Rolls"] = nil, ["Clear Rolls"] = nil,
["Click Action"] = nil, ["Click Action"] = nil,
["Click Casting"] = nil, ["Click Casting"] = nil,
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = nil, ["Clock"] = nil,
["Close"] = nil, ["Close"] = nil,
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -145,21 +158,16 @@ pfUI_translation["enUS"] = {
["Configuration"] = nil, ["Configuration"] = nil,
["Configure"] = nil, ["Configure"] = nil,
["Cooldown"] = nil, ["Cooldown"] = nil,
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = nil, ["Cooldown Color (Days)"] = nil,
["Cooldown Color (Hours)"] = nil, ["Cooldown Color (Hours)"] = nil,
["Cooldown Color (Less than 3 Sec)"] = nil,
["Cooldown Color (Minutes)"] = nil, ["Cooldown Color (Minutes)"] = nil,
["Cooldown Color (Seconds)"] = nil, ["Cooldown Color (Seconds)"] = nil,
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = nil,
["Cooldown Text Font Size (Blizzard Frames)"] = nil,
["Cooldown Text Font Size (Foreign Frames)"] = nil,
["Cooldown Text Size"] = nil,
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = nil,
["Coordinates Location"] = nil, ["Coordinates Location"] = nil,
["Coordinates On Minimap"] = nil, ["Coordinates On Minimap"] = nil,
["Copied to clipboard"] = nil,
["Count"] = nil, ["Count"] = nil,
["Create Profile"] = nil, ["Create Profile"] = nil,
["Ctrl-Click"] = nil, ["Ctrl-Click"] = nil,
@@ -188,6 +196,8 @@ pfUI_translation["enUS"] = {
["Debuff Position"] = nil, ["Debuff Position"] = nil,
["Debuffs"] = nil, ["Debuffs"] = nil,
["Debuff Size"] = nil, ["Debuff Size"] = nil,
["Debuff X-Spacing"] = nil,
["Debuff Y-Spacing"] = nil,
["Debuffs Per Row"] = nil, ["Debuffs Per Row"] = nil,
["Decode"] = nil, ["Decode"] = nil,
["Default"] = nil, ["Default"] = nil,
@@ -201,7 +211,6 @@ pfUI_translation["enUS"] = {
["Description Font"] = nil, ["Description Font"] = nil,
["Description Font Size"] = nil, ["Description Font Size"] = nil,
["Detailed Random Roll Announcement"] = nil, ["Detailed Random Roll Announcement"] = nil,
["Detect Enemy Buffs"] = nil,
["Disable"] = nil, ["Disable"] = nil,
["Disable Blizzard Castbar"] = nil, ["Disable Blizzard Castbar"] = nil,
["Disabled"] = nil, ["Disabled"] = nil,
@@ -278,12 +287,9 @@ pfUI_translation["enUS"] = {
["Enable Custom Incoming Whispers Layout"] = nil, ["Enable Custom Incoming Whispers Layout"] = nil,
["Enable Debuff Display"] = nil, ["Enable Debuff Display"] = nil,
["Enable Debuffs"] = nil, ["Enable Debuffs"] = nil,
["Enable Durations On Blizzard Frames"] = nil,
["Enable Durations On Foreign Frames"] = nil,
["Enable Energy Ticks"] = nil, ["Enable Energy Ticks"] = nil,
["Enable Extended Guild Information"] = nil, ["Enable Extended Guild Information"] = nil,
["Enable Frame Shadow"] = nil, ["Enable Frame Shadow"] = nil,
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = nil, ["Enable Indicators"] = nil,
["Enable Item Quality Color For Equipment Only"] = nil, ["Enable Item Quality Color For Equipment Only"] = nil,
["Enable \"Loot & Spam\" Chat Window"] = nil, ["Enable \"Loot & Spam\" Chat Window"] = nil,
@@ -293,7 +299,6 @@ pfUI_translation["enUS"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = nil, ["Enable Micro Bar"] = nil,
["Enable Mouselook With Right Click"] = nil, ["Enable Mouselook With Right Click"] = nil,
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = nil, ["Enable Offscreen Frame Positions"] = nil,
["Enable Overlap"] = nil, ["Enable Overlap"] = nil,
@@ -314,6 +319,7 @@ pfUI_translation["enUS"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = nil,
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -326,6 +332,7 @@ pfUI_translation["enUS"] = {
["Export"] = nil, ["Export"] = nil,
["Face"] = nil, ["Face"] = nil,
["Fade To Custom Color"] = nil, ["Fade To Custom Color"] = nil,
["FARM MODE"] = nil,
["Fast"] = nil, ["Fast"] = nil,
["Filter Mode"] = nil, ["Filter Mode"] = nil,
["Finish"] = nil, ["Finish"] = nil,
@@ -338,6 +345,7 @@ pfUI_translation["enUS"] = {
["Font"] = nil, ["Font"] = nil,
["Font Options"] = nil, ["Font Options"] = nil,
["Font Padding"] = nil, ["Font Padding"] = nil,
["Font Size"] = nil,
["Font Style"] = nil, ["Font Style"] = nil,
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = nil, ["fps"] = nil,
@@ -372,7 +380,6 @@ pfUI_translation["enUS"] = {
["Health"] = nil, ["Health"] = nil,
["Health - Auto"] = nil, ["Health - Auto"] = nil,
["Healthbar"] = nil, ["Healthbar"] = nil,
["Healthbar Animation Speed"] = nil,
["Health Bar Color"] = nil, ["Health Bar Color"] = nil,
["Healthbar Embedded"] = nil, ["Healthbar Embedded"] = nil,
["Healthbar Height"] = nil, ["Healthbar Height"] = nil,
@@ -397,7 +404,6 @@ pfUI_translation["enUS"] = {
["Hide Channel Names"] = nil, ["Hide Channel Names"] = nil,
["Hide Chat When Bags Are Opened"] = nil, ["Hide Chat When Bags Are Opened"] = nil,
["Hide Combat Log"] = nil, ["Hide Combat Log"] = nil,
["Hide Foreign Cooldown Animations"] = nil,
["Hide Group Frames While In Raid"] = nil, ["Hide Group Frames While In Raid"] = nil,
["Hide Healthbar On Critters"] = nil, ["Hide Healthbar On Critters"] = nil,
["Hide Healthbar On Enemy NPCs"] = nil, ["Hide Healthbar On Enemy NPCs"] = nil,
@@ -406,6 +412,7 @@ pfUI_translation["enUS"] = {
["Hide Healthbar On Friendly Players"] = nil, ["Hide Healthbar On Friendly Players"] = nil,
["Hide Healthbar On Neutral NPCs"] = nil, ["Hide Healthbar On Neutral NPCs"] = nil,
["Hide Healthbar On Totems"] = nil, ["Hide Healthbar On Totems"] = nil,
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = nil, ["Hide Timeout"] = nil,
["Hide When Entering Combat"] = nil, ["Hide When Entering Combat"] = nil,
["Highlight Equipped Items"] = nil, ["Highlight Equipped Items"] = nil,
@@ -435,7 +442,6 @@ pfUI_translation["enUS"] = {
["Inherit Default Colors"] = nil, ["Inherit Default Colors"] = nil,
["Inputbox Height"] = nil, ["Inputbox Height"] = nil,
["Inputbox Width"] = nil, ["Inputbox Width"] = nil,
["Instant"] = nil,
["Integrations"] = nil, ["Integrations"] = nil,
["Invert Health Bar"] = nil, ["Invert Health Bar"] = nil,
["is not allowed in profile name"] = nil, ["is not allowed in profile name"] = nil,
@@ -481,6 +487,7 @@ pfUI_translation["enUS"] = {
["Loot"] = nil, ["Loot"] = nil,
["Loot & Spam"] = nil, ["Loot & Spam"] = nil,
["Loot History"] = nil, ["Loot History"] = nil,
["Loss Of Control"] = nil,
["Macro Text Color"] = nil, ["Macro Text Color"] = nil,
["Macro Text Size"] = nil, ["Macro Text Size"] = nil,
["Main Actionbar"] = nil, ["Main Actionbar"] = nil,
@@ -521,6 +528,7 @@ pfUI_translation["enUS"] = {
["Name | Health Missing"] = nil, ["Name | Health Missing"] = nil,
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = nil, ["Nameplate Border Size"] = nil,
["Nameplate Debuffs"] = nil,
["Nameplates"] = nil, ["Nameplates"] = nil,
["Nameplate Width"] = nil, ["Nameplate Width"] = nil,
["Name (Short)"] = nil, ["Name (Short)"] = nil,
@@ -536,6 +544,7 @@ pfUI_translation["enUS"] = {
["Next Memory Cleanup"] = nil, ["Next Memory Cleanup"] = nil,
["No"] = nil, ["No"] = nil,
["No Anchor"] = nil, ["No Anchor"] = nil,
["NO LOS"] = nil,
["None"] = nil, ["None"] = nil,
["Not a valid button!"] = nil, ["Not a valid button!"] = nil,
["No tracking spell active"] = nil, ["No tracking spell active"] = nil,
@@ -561,6 +570,7 @@ pfUI_translation["enUS"] = {
["Optional Dependencies"] = nil, ["Optional Dependencies"] = nil,
["Options"] = nil, ["Options"] = nil,
["Orientation"] = nil, ["Orientation"] = nil,
["Other Addons"] = nil,
["Other Panel: Minimap"] = nil, ["Other Panel: Minimap"] = nil,
["Outline"] = nil, ["Outline"] = nil,
["Outlines"] = nil, ["Outlines"] = nil,
@@ -576,6 +586,9 @@ pfUI_translation["enUS"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Own Buff Size"] = nil,
["Own Debuff Size"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = nil, ["Panel"] = nil,
@@ -588,6 +601,7 @@ pfUI_translation["enUS"] = {
["Pixel"] = nil, ["Pixel"] = nil,
["Player"] = nil, ["Player"] = nil,
["Player Buff Bar"] = nil, ["Player Buff Bar"] = nil,
["Player Buffs"] = nil,
["Player Castbar"] = nil, ["Player Castbar"] = nil,
["Player Debuff Bar"] = nil, ["Player Debuff Bar"] = nil,
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -598,6 +612,7 @@ pfUI_translation["enUS"] = {
["Portrait Alpha"] = nil, ["Portrait Alpha"] = nil,
["Portrait Height"] = nil, ["Portrait Height"] = nil,
["Portrait Position"] = nil, ["Portrait Position"] = nil,
["Portrait Style"] = nil,
["Portrait Width"] = nil, ["Portrait Width"] = nil,
["Powerbar"] = nil, ["Powerbar"] = nil,
["Power Bar Anchor"] = nil, ["Power Bar Anchor"] = nil,
@@ -623,6 +638,7 @@ pfUI_translation["enUS"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
@@ -653,6 +669,7 @@ pfUI_translation["enUS"] = {
["Reveal Unexplored Areas"] = nil, ["Reveal Unexplored Areas"] = nil,
["Switch to current zone"] = nil, ["Switch to current zone"] = nil,
["Retrieving item information..."] = nil, ["Retrieving item information..."] = nil,
["Reverse Sweep On"] = nil,
["Right"] = nil, ["Right"] = nil,
["Right Actionbar"] = nil, ["Right Actionbar"] = nil,
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -674,8 +691,8 @@ pfUI_translation["enUS"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scale Font Size With Icon"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = nil, ["Screen Resolution"] = nil,
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -711,6 +728,7 @@ pfUI_translation["enUS"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -733,7 +751,7 @@ pfUI_translation["enUS"] = {
["Show Loot Icon"] = nil, ["Show Loot Icon"] = nil,
["Show Macro Text"] = nil, ["Show Macro Text"] = nil,
["Show Meters By Default"] = nil, ["Show Meters By Default"] = nil,
["Show Milliseconds When Timer Runs Out"] = nil, ["Show Numbers On"] = nil,
["Show On Friendly Units"] = nil, ["Show On Friendly Units"] = nil,
["Show On Hostile Units"] = nil, ["Show On Hostile Units"] = nil,
["Show Procs Indicators"] = nil, ["Show Procs Indicators"] = nil,
@@ -747,13 +765,14 @@ pfUI_translation["enUS"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = nil,
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = nil,
["Show Timer Text"] = nil, ["Show Timer Text"] = nil,
["Show Totems Indicators"] = nil, ["Show Totems Indicators"] = nil,
["Shrink & Return"] = nil, ["Shrink & Return"] = nil,
@@ -767,14 +786,18 @@ pfUI_translation["enUS"] = {
["Small"] = nil, ["Small"] = nil,
["Some settings need to reload the UI to take effect.\nDo you want to reload now?"] = nil, ["Some settings need to reload the UI to take effect.\nDo you want to reload now?"] = nil,
["Some settings need to reload the UI to take effect.\nDo you want to reloadUI now?"] = nil, ["Some settings need to reload the UI to take effect.\nDo you want to reloadUI now?"] = nil,
["Sort Bags"] = nil,
["Sort Bank"] = nil,
["Sort Order"] = nil, ["Sort Order"] = nil,
["Soul Shard"] = nil, ["Soul Shard"] = nil,
["Soulshard Counter"] = nil, ["Soulshard Counter"] = nil,
["Soulshards"] = nil, ["Soulshards"] = nil,
["Spacing"] = nil, ["Spacing"] = nil,
["Special Recipient"] = nil, ["Special Recipient"] = nil,
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = nil, ["Square"] = nil,
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = nil, ["Stance Bar 1"] = nil,
["Stance Bar 2"] = nil, ["Stance Bar 2"] = nil,
["Stance Bar 3"] = nil, ["Stance Bar 3"] = nil,
@@ -810,7 +833,6 @@ pfUI_translation["enUS"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = nil, ["Threshold To Trust Health Estimation"] = nil,
["Time"] = nil, ["Time"] = nil,
["Timer"] = nil,
["Timer Alignment"] = nil, ["Timer Alignment"] = nil,
["Timer X Offset"] = nil, ["Timer X Offset"] = nil,
["Timer Y Offset"] = nil, ["Timer Y Offset"] = nil,
@@ -824,6 +846,7 @@ pfUI_translation["enUS"] = {
["Tiny (PixelPerfect)"] = nil, ["Tiny (PixelPerfect)"] = nil,
["Toggle as Tank"] = nil, ["Toggle as Tank"] = nil,
["Tooltip"] = nil, ["Tooltip"] = nil,
["Tooltip Auras"] = nil,
["Tooltip Position"] = nil, ["Tooltip Position"] = nil,
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -831,14 +854,17 @@ pfUI_translation["enUS"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = nil,
["Total Gold"] = nil, ["Total Gold"] = nil,
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
["Totems"] = nil,
["Tracked Reputation"] = nil, ["Tracked Reputation"] = nil,
["Tracking Icon Size"] = nil, ["Tracking Icon Size"] = nil,
["Trigger Actions On Key Down"] = nil, ["Trigger Actions On Key Down"] = nil,
["UI-Scale"] = nil, ["UI-Scale"] = nil,
["Unbuffed"] = nil, ["Unbuffed"] = nil,
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = nil, ["Unit Frame Border Size"] = nil,
["Unit Frame Layout"] = nil, ["Unit Frame Layout"] = nil,
["Unit Frames"] = nil, ["Unit Frames"] = nil,
@@ -865,7 +891,6 @@ pfUI_translation["enUS"] = {
["Use Custom Color Power Bar Background"] = nil, ["Use Custom Color Power Bar Background"] = nil,
["Use Custom Font Settings"] = nil, ["Use Custom Font Settings"] = nil,
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = nil,
["Use Item Rarity Color For Loot-Roll Timer"] = nil, ["Use Item Rarity Color For Loot-Roll Timer"] = nil,
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = nil, ["Use Raid Frames To Display Group Members"] = nil,
@@ -883,7 +908,6 @@ pfUI_translation["enUS"] = {
["Website"] = nil, ["Website"] = nil,
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = nil, ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = nil,
["Whitelist"] = nil, ["Whitelist"] = nil,
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = nil, ["Width"] = nil,
["Wobble Zoom"] = nil, ["Wobble Zoom"] = nil,
["Won"] = nil, ["Won"] = nil,
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["esES"] = { pfUI_translation["esES"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = "Abreviar números (4200 -> 4.2k)", ["Abbreviate Numbers (4200 -> 4.2k)"] = "Abreviar números (4200 -> 4.2k)",
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["esES"] = {
["Actionbar"] = "Barra de acción", ["Actionbar"] = "Barra de acción",
["Action Bar"] = "Barra de acción", ["Action Bar"] = "Barra de acción",
["Action Bar Border Size"] = "Tamaño del borde de la barra de acción", ["Action Bar Border Size"] = "Tamaño del borde de la barra de acción",
["Action Bars"] = nil,
["Active Addons"] = "Accesorios activos", ["Active Addons"] = "Accesorios activos",
["Add button to the frame"] = "Añadir botón al marco", ["Add button to the frame"] = "Añadir botón al marco",
["Added button"] = "Botón añadido", ["Added button"] = "Botón añadido",
@@ -27,12 +30,11 @@ pfUI_translation["esES"] = {
["Always Show Item Comparison"] = "Mostrar siempre la comparativa entre objetos", ["Always Show Item Comparison"] = "Mostrar siempre la comparativa entre objetos",
["Always Show On Target Units"] = "Mostrar siempre en el objectivo", ["Always Show On Target Units"] = "Mostrar siempre en el objectivo",
["Always Show On Units With Missing HP"] = "Mostrar siempre en unidades con falta de salud", ["Always Show On Units With Missing HP"] = "Mostrar siempre en unidades con falta de salud",
["Always Show Self In Raid Frames"] = "Mostrarse siempre a sí mismo en los marcos de banda",
["Always Use 2D Portraits"] = "Usar siempre retratos 2D",
["Ammo Counter"] = "Contador de munición", ["Ammo Counter"] = "Contador de munición",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Una nueva instalación de |cff33ffccpf|rUI viene con 4 perfiles de diseño preconfigurados. Haga clic debajo si deseas cargar uno de estos perfiles.", ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Una nueva instalación de |cff33ffccpf|rUI viene con 4 perfiles de diseño preconfigurados. Haga clic debajo si deseas cargar uno de estos perfiles.",
["A new version is available"] = "Una nueva versión está disponible", ["A new version is available"] = "Una nueva versión está disponible",
["Animate Health And Power Bars"] = nil,
["Appearance"] = "Apariencia", ["Appearance"] = "Apariencia",
["Ascending"] = "Ascendiendo", ["Ascending"] = "Ascendiendo",
["Author"] = "Autor", ["Author"] = "Autor",
@@ -52,10 +54,12 @@ pfUI_translation["esES"] = {
["Auto Sell Grey Items"] = "Vender objetos grises automáticamente", ["Auto Sell Grey Items"] = "Vender objetos grises automáticamente",
["Average Per Hour"] = "Promedio por hora", ["Average Per Hour"] = "Promedio por hora",
["Background Color"] = "Color del fondo", ["Background Color"] = "Color del fondo",
["Bags"] = "Bolsas",
["Bags & Bank"] = "Bolsas y banco", ["Bags & Bank"] = "Bolsas y banco",
["Bags Border Size"] = "Tamaño del borde de las bolsas", ["Bags Border Size"] = "Tamaño del borde de las bolsas",
["Bagslots Per Row"] = "Casillas de la bolsa por fila", ["Bagslots Per Row"] = "Casillas de la bolsa por fila",
["Bagspace"] = "Huecos en las bolsas", ["Bagspace"] = "Huecos en las bolsas",
["Bank"] = "Banco",
["Banker"] = "Banquero", ["Banker"] = "Banquero",
["Bankslots Per Row"] = "Casillas del banco por fila", ["Bankslots Per Row"] = "Casillas del banco por fila",
["Bar Background"] = "Fondo de la barra", ["Bar Background"] = "Fondo de la barra",
@@ -77,7 +81,7 @@ pfUI_translation["esES"] = {
["Buffbar Width"] = "Ancho de la barra de beneficios", ["Buffbar Width"] = "Ancho de la barra de beneficios",
["Buff/Debuff Icons"] = "Iconos de los beneficios/perjuicios", ["Buff/Debuff Icons"] = "Iconos de los beneficios/perjuicios",
["Buff/Debuff Indicators"] = "Indicadores de beneficios/perjuicios", ["Buff/Debuff Indicators"] = "Indicadores de beneficios/perjuicios",
["Buff Font Size"] = "Tamaño de la fuente de beneficios", ["Buff Indicators"] = nil,
["Buff Limit"] = "Límite de beneficios", ["Buff Limit"] = "Límite de beneficios",
["Buff Position"] = "Posición de los beneficios", ["Buff Position"] = "Posición de los beneficios",
["Buffs"] = "Beneficios", ["Buffs"] = "Beneficios",
@@ -119,11 +123,16 @@ pfUI_translation["esES"] = {
["Chat Bubble Transparency"] = "Transparencia de los bocadillos de chat", ["Chat Bubble Transparency"] = "Transparencia de los bocadillos de chat",
["Chat Default Brackets"] = "Corchetes de chat predeterminados", ["Chat Default Brackets"] = "Corchetes de chat predeterminados",
["Class"] = "Clase", ["Class"] = "Clase",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = "Borrar los dados", ["Clear Rolls"] = "Borrar los dados",
["Click Action"] = "Acción al hacer clic", ["Click Action"] = "Acción al hacer clic",
["Click Casting"] = "Lanzamiento al hacer click", ["Click Casting"] = "Lanzamiento al hacer click",
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "Reloj", ["Clock"] = "Reloj",
["Close"] = "Cerrar", ["Close"] = "Cerrar",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Colorear pilas de beneficios", ["Color Buff Stacks"] = "Colorear pilas de beneficios",
["Color Debuff Stacks"] = "Colorear pilas de perjuicios", ["Color Debuff Stacks"] = "Colorear pilas de perjuicios",
@@ -143,21 +152,16 @@ pfUI_translation["esES"] = {
["Configuration"] = "Configuración", ["Configuration"] = "Configuración",
["Configure"] = "Configurar", ["Configure"] = "Configurar",
["Cooldown"] = "Reutilización", ["Cooldown"] = "Reutilización",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "Color de reutilización (días)", ["Cooldown Color (Days)"] = "Color de reutilización (días)",
["Cooldown Color (Hours)"] = "Color de reutilización (horas)", ["Cooldown Color (Hours)"] = "Color de reutilización (horas)",
["Cooldown Color (Less than 3 Sec)"] = "Color de reutilización (menos de 3 segundos)",
["Cooldown Color (Minutes)"] = "Color de reutilización (minutos)", ["Cooldown Color (Minutes)"] = "Color de reutilización (minutos)",
["Cooldown Color (Seconds)"] = "Color de reutilización (segundos)", ["Cooldown Color (Seconds)"] = "Color de reutilización (segundos)",
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = "Tamaño de la fuente de texto de reutilización",
["Cooldown Text Font Size (Blizzard Frames)"] = "Tamaño de la fuente del tiempo de reutilización (Marcos de Blizzard)",
["Cooldown Text Font Size (Foreign Frames)"] = "Tamaño de la fuente del tiempo de reutilización (Marcos ajenos)",
["Cooldown Text Size"] = "Tamaño del texto del tiempo de reutilización",
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = "Umbral del texto del tiempo de reutilización",
["Coordinates Location"] = "Coordenadas de localización", ["Coordinates Location"] = "Coordenadas de localización",
["Coordinates On Minimap"] = "Coordenadas en el minimapa", ["Coordinates On Minimap"] = "Coordenadas en el minimapa",
["Copied to clipboard"] = nil,
["Count"] = "Recuento", ["Count"] = "Recuento",
["Create Profile"] = "Crear perfil", ["Create Profile"] = "Crear perfil",
["Ctrl-Click"] = "Ctrl-Clic", ["Ctrl-Click"] = "Ctrl-Clic",
@@ -198,7 +202,6 @@ pfUI_translation["esES"] = {
["Description Font"] = "Fuente de descripción", ["Description Font"] = "Fuente de descripción",
["Description Font Size"] = "Tamaño de la fuente de descripción", ["Description Font Size"] = "Tamaño de la fuente de descripción",
["Detailed Random Roll Announcement"] = "Anuncio detallado para tirar los dados aleatoriamente", ["Detailed Random Roll Announcement"] = "Anuncio detallado para tirar los dados aleatoriamente",
["Detect Enemy Buffs"] = nil,
["Disable"] = "Desactivar", ["Disable"] = "Desactivar",
["Disable Blizzard Castbar"] = "Desactivar la barra de lanzamiento de Blizzard", ["Disable Blizzard Castbar"] = "Desactivar la barra de lanzamiento de Blizzard",
["Disabled"] = "Desactivado", ["Disabled"] = "Desactivado",
@@ -275,12 +278,9 @@ pfUI_translation["esES"] = {
["Enable Custom Incoming Whispers Layout"] = "Activar disposición de susurros entrantes personalizado", ["Enable Custom Incoming Whispers Layout"] = "Activar disposición de susurros entrantes personalizado",
["Enable Debuff Display"] = "Mostrar los perjuicios", ["Enable Debuff Display"] = "Mostrar los perjuicios",
["Enable Debuffs"] = "Activar los perjuicios", ["Enable Debuffs"] = "Activar los perjuicios",
["Enable Durations On Blizzard Frames"] = "Activar duración en los marcos de Blizzard",
["Enable Durations On Foreign Frames"] = "Activar duración en los marcos extranjeros",
["Enable Energy Ticks"] = "Activar tics de energía", ["Enable Energy Ticks"] = "Activar tics de energía",
["Enable Extended Guild Information"] = "Activar información de hermandad extendida", ["Enable Extended Guild Information"] = "Activar información de hermandad extendida",
["Enable Frame Shadow"] = "Activar sombra del marco", ["Enable Frame Shadow"] = "Activar sombra del marco",
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = "Activar indicadores", ["Enable Indicators"] = "Activar indicadores",
["Enable Item Quality Color For Equipment Only"] = "Mostrar el color de calidad de objetos solo para equipo", ["Enable Item Quality Color For Equipment Only"] = "Mostrar el color de calidad de objetos solo para equipo",
["Enable \"Loot & Spam\" Chat Window"] = "Activar ventana de chat \"Botín y spam\"", ["Enable \"Loot & Spam\" Chat Window"] = "Activar ventana de chat \"Botín y spam\"",
@@ -290,7 +290,6 @@ pfUI_translation["esES"] = {
["Enable Mana Ticks"] = "Activar el indicador de pulsos del maná", ["Enable Mana Ticks"] = "Activar el indicador de pulsos del maná",
["Enable Micro Bar"] = "Activar microbarra", ["Enable Micro Bar"] = "Activar microbarra",
["Enable Mouselook With Right Click"] = "Mirar usando el puntero con clic derecho", ["Enable Mouselook With Right Click"] = "Mirar usando el puntero con clic derecho",
["Enable Mouseover Tooltip"] = "Activar la descripción emergente al pasar el puntero",
["Enable Movable Bags"] = "Permitir mover las bolsas", ["Enable Movable Bags"] = "Permitir mover las bolsas",
["Enable Offscreen Frame Positions"] = "Permitir mover los marcos fuera de la pantalla", ["Enable Offscreen Frame Positions"] = "Permitir mover los marcos fuera de la pantalla",
["Enable Overlap"] = "Permitir superposición", ["Enable Overlap"] = "Permitir superposición",
@@ -311,6 +310,7 @@ pfUI_translation["esES"] = {
["Encode"] = "Codificar", ["Encode"] = "Codificar",
["Ended"] = "Terminado", ["Ended"] = "Terminado",
["Energy Color"] = "Color de energía", ["Energy Color"] = "Color de energía",
["Equipped"] = "Equipado",
["Equipped Item Color"] = "Color del objeto equipado", ["Equipped Item Color"] = "Color del objeto equipado",
["Estimate Debuffs"] = "Estimar los perjuicios", ["Estimate Debuffs"] = "Estimar los perjuicios",
["Estimate Enemy Health Points"] = "Estimar los puntos de salud del enemigo", ["Estimate Enemy Health Points"] = "Estimar los puntos de salud del enemigo",
@@ -335,6 +335,7 @@ pfUI_translation["esES"] = {
["Font"] = "Fuente", ["Font"] = "Fuente",
["Font Options"] = "Opciones de fuente", ["Font Options"] = "Opciones de fuente",
["Font Padding"] = "Relleno de fuente", ["Font Padding"] = "Relleno de fuente",
["Font Size"] = nil,
["Font Style"] = "Estilo de la fuente", ["Font Style"] = "Estilo de la fuente",
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = "ips", ["fps"] = "ips",
@@ -369,7 +370,6 @@ pfUI_translation["esES"] = {
["Health"] = "Salud", ["Health"] = "Salud",
["Health - Auto"] = "Salud - Auto", ["Health - Auto"] = "Salud - Auto",
["Healthbar"] = "Barra de salud", ["Healthbar"] = "Barra de salud",
["Healthbar Animation Speed"] = "Velocidad de animación de la barra de salud",
["Health Bar Color"] = "Color de la barra de salud", ["Health Bar Color"] = "Color de la barra de salud",
["Healthbar Embedded"] = "Barra de salud embebida", ["Healthbar Embedded"] = "Barra de salud embebida",
["Healthbar Height"] = "Altura de la barra de salud", ["Healthbar Height"] = "Altura de la barra de salud",
@@ -394,7 +394,6 @@ pfUI_translation["esES"] = {
["Hide Channel Names"] = "Ocultar nombres de canales", ["Hide Channel Names"] = "Ocultar nombres de canales",
["Hide Chat When Bags Are Opened"] = "Ocultar el chat al abrir las bolsas", ["Hide Chat When Bags Are Opened"] = "Ocultar el chat al abrir las bolsas",
["Hide Combat Log"] = "Ocultar el registro del combate", ["Hide Combat Log"] = "Ocultar el registro del combate",
["Hide Foreign Cooldown Animations"] = "Esconde animaciones de reutilización externas",
["Hide Group Frames While In Raid"] = "Ocultar los marcos de grupo mientras estés en banda", ["Hide Group Frames While In Raid"] = "Ocultar los marcos de grupo mientras estés en banda",
["Hide Healthbar On Critters"] = "Esconder la barra de salud con las alimañas", ["Hide Healthbar On Critters"] = "Esconder la barra de salud con las alimañas",
["Hide Healthbar On Enemy NPCs"] = "Esconder la barra de salud con los PNJs enemigos", ["Hide Healthbar On Enemy NPCs"] = "Esconder la barra de salud con los PNJs enemigos",
@@ -403,6 +402,7 @@ pfUI_translation["esES"] = {
["Hide Healthbar On Friendly Players"] = "Esconder la barra de salud con los jugadores amistosos", ["Hide Healthbar On Friendly Players"] = "Esconder la barra de salud con los jugadores amistosos",
["Hide Healthbar On Neutral NPCs"] = "Esconder la barra de salud con los PNJs neutrales", ["Hide Healthbar On Neutral NPCs"] = "Esconder la barra de salud con los PNJs neutrales",
["Hide Healthbar On Totems"] = "Esconder la barra de salud con los tótems", ["Hide Healthbar On Totems"] = "Esconder la barra de salud con los tótems",
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = "Ocultar temporizador", ["Hide Timeout"] = "Ocultar temporizador",
["Hide When Entering Combat"] = "Ocultar si entras combate", ["Hide When Entering Combat"] = "Ocultar si entras combate",
["Highlight Equipped Items"] = "Resaltar objetos equipados", ["Highlight Equipped Items"] = "Resaltar objetos equipados",
@@ -431,7 +431,6 @@ pfUI_translation["esES"] = {
["Inherit Default Colors"] = "Color predeterminado", ["Inherit Default Colors"] = "Color predeterminado",
["Inputbox Height"] = "Altura de la barra de entrada", ["Inputbox Height"] = "Altura de la barra de entrada",
["Inputbox Width"] = "Ancho de la barra de entrada", ["Inputbox Width"] = "Ancho de la barra de entrada",
["Instant"] = "Instantáneo",
["Integrations"] = "Integraciones", ["Integrations"] = "Integraciones",
["Invert Health Bar"] = "Invertir la barra de salud", ["Invert Health Bar"] = "Invertir la barra de salud",
["is not allowed in profile name"] = "no se permite en el nombre de perfil", ["is not allowed in profile name"] = "no se permite en el nombre de perfil",
@@ -476,6 +475,7 @@ pfUI_translation["esES"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = "Botín", ["Loot"] = "Botín",
["Loot & Spam"] = "Botín y spam", ["Loot & Spam"] = "Botín y spam",
["Loss Of Control"] = nil,
["Macro Text Color"] = "Color de texto de macros", ["Macro Text Color"] = "Color de texto de macros",
["Macro Text Size"] = "Tamaño de texto de macros", ["Macro Text Size"] = "Tamaño de texto de macros",
["Main Actionbar"] = "Barra de acción principal", ["Main Actionbar"] = "Barra de acción principal",
@@ -515,6 +515,7 @@ pfUI_translation["esES"] = {
["Name | Health Missing"] = "Nombre | Falta de salud", ["Name | Health Missing"] = "Nombre | Falta de salud",
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = "Tamaño del borde de las placas de nombre", ["Nameplate Border Size"] = "Tamaño del borde de las placas de nombre",
["Nameplate Debuffs"] = nil,
["Nameplates"] = "Placas identificativas", ["Nameplates"] = "Placas identificativas",
["Nameplate Width"] = "Ancho de las placas identificativas", ["Nameplate Width"] = "Ancho de las placas identificativas",
["Name (Short)"] = "Nombre (corto)", ["Name (Short)"] = "Nombre (corto)",
@@ -553,6 +554,7 @@ pfUI_translation["esES"] = {
["On State Change"] = "En un cambio de estado", ["On State Change"] = "En un cambio de estado",
["Options"] = "Opciones", ["Options"] = "Opciones",
["Orientation"] = "Orientación", ["Orientation"] = "Orientación",
["Other Addons"] = nil,
["Other Panel: Minimap"] = "Otro panel: minimapa", ["Other Panel: Minimap"] = "Otro panel: minimapa",
["Outline"] = "Contorno", ["Outline"] = "Contorno",
["Outlines"] = "Contornos", ["Outlines"] = "Contornos",
@@ -568,6 +570,7 @@ pfUI_translation["esES"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Paginable", ["Pageable"] = "Paginable",
["Paging Actionbar"] = "Paginando la barra de acción", ["Paging Actionbar"] = "Paginando la barra de acción",
["Panel"] = "Panel", ["Panel"] = "Panel",
@@ -580,6 +583,7 @@ pfUI_translation["esES"] = {
["Pixel"] = "Píxel", ["Pixel"] = "Píxel",
["Player"] = "Jugador", ["Player"] = "Jugador",
["Player Buff Bar"] = "Barra de beneficios del jugador", ["Player Buff Bar"] = "Barra de beneficios del jugador",
["Player Buffs"] = nil,
["Player Castbar"] = "Barra de lanzamiento del jugador", ["Player Castbar"] = "Barra de lanzamiento del jugador",
["Player Debuff Bar"] = "Barra de perjuicios del jugador", ["Player Debuff Bar"] = "Barra de perjuicios del jugador",
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["esES"] = {
["Portrait Alpha"] = "Transparencia del retrato", ["Portrait Alpha"] = "Transparencia del retrato",
["Portrait Height"] = "Altura Retrato", ["Portrait Height"] = "Altura Retrato",
["Portrait Position"] = "Posición del retrato", ["Portrait Position"] = "Posición del retrato",
["Portrait Style"] = nil,
["Portrait Width"] = "Ancho Retrato", ["Portrait Width"] = "Ancho Retrato",
["Powerbar"] = "Barra de poder", ["Powerbar"] = "Barra de poder",
["Power Bar Anchor"] = "Ancla de la barra de poder", ["Power Bar Anchor"] = "Ancla de la barra de poder",
@@ -615,6 +620,7 @@ pfUI_translation["esES"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Espaciado del marco de banda", ["Raid Padding"] = "Espaciado del marco de banda",
["Raid-Pet"] = nil,
["Random"] = "Aleatorio", ["Random"] = "Aleatorio",
["Random Roll Announcement Rarity"] = "Anuncio para tirar los dados aleatoriamente", ["Random Roll Announcement Rarity"] = "Anuncio para tirar los dados aleatoriamente",
["Random Rolling"] = "Tirar los dados aleatoriamente", ["Random Rolling"] = "Tirar los dados aleatoriamente",
@@ -644,6 +650,7 @@ pfUI_translation["esES"] = {
["Resting"] = "Descansando", ["Resting"] = "Descansando",
["Reveal Unexplored Areas"] = "Mostrar áreas no exploradas", ["Reveal Unexplored Areas"] = "Mostrar áreas no exploradas",
["Switch to current zone"] = "Ir a la zona actual", ["Switch to current zone"] = "Ir a la zona actual",
["Reverse Sweep On"] = nil,
["Right"] = "Derecho", ["Right"] = "Derecho",
["Right Actionbar"] = "Barra de acción derecha", ["Right Actionbar"] = "Barra de acción derecha",
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["esES"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = "Escala", ["Scale"] = "Escala",
["Scale Border On HiDPI Displays"] = "Escalar los bordes en las pantallas con DPI alto", ["Scale Border On HiDPI Displays"] = "Escalar los bordes en las pantallas con DPI alto",
["Scale Font Size With Icon"] = nil,
["Scaling"] = "Escalada", ["Scaling"] = "Escalada",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = "Intensidad de brillo en los bordes de la pantalla", ["Screen Edge Glow Intensity"] = "Intensidad de brillo en los bordes de la pantalla",
["Screen Resolution"] = "Resolución de pantalla", ["Screen Resolution"] = "Resolución de pantalla",
["Screenshot"] = "Captura de pantalla", ["Screenshot"] = "Captura de pantalla",
@@ -702,6 +709,7 @@ pfUI_translation["esES"] = {
["Show Description"] = "Mostrar descripción", ["Show Description"] = "Mostrar descripción",
["Show Dispel Indicators"] = "Mostrar indicadores para disipar", ["Show Dispel Indicators"] = "Mostrar indicadores para disipar",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Mostrar la duración dentro del beneficios", ["Show Duration Inside Buff"] = "Mostrar la duración dentro del beneficios",
["Show Empty Buttons"] = "Mostrar botones vacíos", ["Show Empty Buttons"] = "Mostrar botones vacíos",
["Show FPS and Latency Colors"] = "Mostrar FPS y colores de latencia", ["Show FPS and Latency Colors"] = "Mostrar FPS y colores de latencia",
@@ -724,7 +732,7 @@ pfUI_translation["esES"] = {
["Show Loot Icon"] = "Mostrar icono de botín", ["Show Loot Icon"] = "Mostrar icono de botín",
["Show Macro Text"] = "Mostrar texto de macro", ["Show Macro Text"] = "Mostrar texto de macro",
["Show Meters By Default"] = "Mostrar medidores por defecto", ["Show Meters By Default"] = "Mostrar medidores por defecto",
["Show Milliseconds When Timer Runs Out"] = "Mostrar milisegundos cuando el temporizador se acaba", ["Show Numbers On"] = nil,
["Show On Friendly Units"] = "Mostrar en unidades amistosas", ["Show On Friendly Units"] = "Mostrar en unidades amistosas",
["Show On Hostile Units"] = "Mostrar en unidades enemigas", ["Show On Hostile Units"] = "Mostrar en unidades enemigas",
["Show Procs Indicators"] = "Mostrar indicadores de beneficios temporales activados", ["Show Procs Indicators"] = "Mostrar indicadores de beneficios temporales activados",
@@ -738,13 +746,14 @@ pfUI_translation["esES"] = {
["Show Required Questitem Count"] = "Muestra el número requerido de objetos de misión", ["Show Required Questitem Count"] = "Muestra el número requerido de objetos de misión",
["Show Resting"] = "Mostrar descanso", ["Show Resting"] = "Mostrar descanso",
["Show Self In Group Frames"] = "Mostrar a sí mismo en marcos de grupo", ["Show Self In Group Frames"] = "Mostrar a sí mismo en marcos de grupo",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Mostrar icono de hechizo", ["Show Spell Icon"] = "Mostrar icono de hechizo",
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = "Mostrar pilas", ["Show Stacks"] = "Mostrar pilas",
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = "Mostrar el tiempo restante",
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = "Mostrar la animación del temporizador",
["Show Timer Text"] = "Mostrar el texto del temporizador", ["Show Timer Text"] = "Mostrar el texto del temporizador",
["Show Totems Indicators"] = "Mostrar los indicadores de tótems", ["Show Totems Indicators"] = "Mostrar los indicadores de tótems",
["Shrink & Return"] = "Encogerse y volver", ["Shrink & Return"] = "Encogerse y volver",
@@ -761,8 +770,10 @@ pfUI_translation["esES"] = {
["Soulshards"] = "Fragmentos de alma", ["Soulshards"] = "Fragmentos de alma",
["Spacing"] = "Espaciado", ["Spacing"] = "Espaciado",
["Special Recipient"] = "Destinatario especial", ["Special Recipient"] = "Destinatario especial",
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = "Cuadrado", ["Square"] = "Cuadrado",
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = "Barra de actitud 1", ["Stance Bar 1"] = "Barra de actitud 1",
["Stance Bar 2"] = "Barra de actitud 2", ["Stance Bar 2"] = "Barra de actitud 2",
["Stance Bar 3"] = "Barra de actitud 3", ["Stance Bar 3"] = "Barra de actitud 3",
@@ -797,7 +808,6 @@ pfUI_translation["esES"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = "Umbral para confiar en la estimación de salud", ["Threshold To Trust Health Estimation"] = "Umbral para confiar en la estimación de salud",
["Time"] = "Tiempo", ["Time"] = "Tiempo",
["Timer"] = "Temporizador",
["Time Remaining"] = "Tiempo restante", ["Time Remaining"] = "Tiempo restante",
["Timer In Minutes"] = "Temporizador en minutos", ["Timer In Minutes"] = "Temporizador en minutos",
["Timestamp Brackets"] = "Corchetes de marca de tiempo", ["Timestamp Brackets"] = "Corchetes de marca de tiempo",
@@ -808,6 +818,7 @@ pfUI_translation["esES"] = {
["Tiny (PixelPerfect)"] = "Minúsculo (píxel perfecta)", ["Tiny (PixelPerfect)"] = "Minúsculo (píxel perfecta)",
["Toggle as Tank"] = "Alternar si eres el tanque", ["Toggle as Tank"] = "Alternar si eres el tanque",
["Tooltip"] = "Descripción emergente", ["Tooltip"] = "Descripción emergente",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "Posición de la descripción emergente", ["Tooltip Position"] = "Posición de la descripción emergente",
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["esES"] = {
["Top Actionbar"] = "Barra de acción superior", ["Top Actionbar"] = "Barra de acción superior",
["Top Left"] = "Superior derecha", ["Top Left"] = "Superior derecha",
["Top Right"] = "Superior izquierda", ["Top Right"] = "Superior izquierda",
["Total"] = "Total",
["Total Gold"] = "Oro Total", ["Total Gold"] = "Oro Total",
["Totem Direction"] = "Dirección del tótem", ["Totem Direction"] = "Dirección del tótem",
["Totem Icons"] = "Iconos de los tótems", ["Totem Icons"] = "Iconos de los tótems",
["Totems"] = nil,
["Tracked Reputation"] = "Reputación rastreada", ["Tracked Reputation"] = "Reputación rastreada",
["Tracking Icon Size"] = "Tamaño del icono de rastreo", ["Tracking Icon Size"] = "Tamaño del icono de rastreo",
["Trigger Actions On Key Down"] = "Disparar acciones por presionar la tecla abajo", ["Trigger Actions On Key Down"] = "Disparar acciones por presionar la tecla abajo",
["UI-Scale"] = "Escala de IU", ["UI-Scale"] = "Escala de IU",
["Unbuffed"] = "Sin beneficios", ["Unbuffed"] = "Sin beneficios",
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "Tamaño del borde del marco de unidad", ["Unit Frame Border Size"] = "Tamaño del borde del marco de unidad",
["Unit Frame Layout"] = "Disposición del Marco de unidad", ["Unit Frame Layout"] = "Disposición del Marco de unidad",
["Unit Frames"] = "Marcos de unidad", ["Unit Frames"] = "Marcos de unidad",
@@ -849,7 +863,6 @@ pfUI_translation["esES"] = {
["Use Custom Color Power Bar Background"] = "Usar un color personalizado para el fondo de la barra de poder", ["Use Custom Color Power Bar Background"] = "Usar un color personalizado para el fondo de la barra de poder",
["Use Custom Font Settings"] = "Usar las opciones de fuente personalizada", ["Use Custom Font Settings"] = "Usar las opciones de fuente personalizada",
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = "Usar un tamaño de fuente dinámico",
["Use Item Rarity Color For Loot-Roll Timer"] = "Usar el color de la rareza del objeto para el temporizador de tirar los dados", ["Use Item Rarity Color For Loot-Roll Timer"] = "Usar el color de la rareza del objeto para el temporizador de tirar los dados",
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = "Usar marcos de la banda para mostrar miembros del grupo", ["Use Raid Frames To Display Group Members"] = "Usar marcos de la banda para mostrar miembros del grupo",
@@ -867,7 +880,6 @@ pfUI_translation["esES"] = {
["Website"] = "Sitio de web", ["Website"] = "Sitio de web",
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "¡Bienvenido a |cff33ffccpf|cffffffffUI|r!\n\nSoy el asistente de instalación que te guiará con la configuración básica. Si prefieres, puedes hacer clic el botón \"Predeterminado\" para cargar la configuración por defecto. Si quieres abrir este diálogo de nuevo, ve a la configuración y haz clic en el botón \"Reiniciar Primera vez\".\n\nVisita |cff33ffcc%s|r para descargar la última versión.", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "¡Bienvenido a |cff33ffccpf|cffffffffUI|r!\n\nSoy el asistente de instalación que te guiará con la configuración básica. Si prefieres, puedes hacer clic el botón \"Predeterminado\" para cargar la configuración por defecto. Si quieres abrir este diálogo de nuevo, ve a la configuración y haz clic en el botón \"Reiniciar Primera vez\".\n\nVisita |cff33ffcc%s|r para descargar la última versión.",
["Whitelist"] = "Lista blanca", ["Whitelist"] = "Lista blanca",
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = "Ancho", ["Width"] = "Ancho",
["Wobble Zoom"] = "Acerca tambalea", ["Wobble Zoom"] = "Acerca tambalea",
["Won"] = "Ganado", ["Won"] = "Ganado",
+107 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["frFR"] = { pfUI_translation["frFR"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = "Nombre abrégés (4200 -> 4.2k)", ["Abbreviate Numbers (4200 -> 4.2k)"] = "Nombre abrégés (4200 -> 4.2k)",
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["frFR"] = {
["Actionbar"] = "Barre d'action", ["Actionbar"] = "Barre d'action",
["Action Bar"] = "Barre d'action", ["Action Bar"] = "Barre d'action",
["Action Bar Border Size"] = "Taille de la bordure de la barre d'action", ["Action Bar Border Size"] = "Taille de la bordure de la barre d'action",
["Action Bars"] = nil,
["Active Addons"] = "Addons Actif", ["Active Addons"] = "Addons Actif",
["Add button to the frame"] = "Ajoute un bouton au cadre", ["Add button to the frame"] = "Ajoute un bouton au cadre",
["Added button"] = "Bouton ajouté", ["Added button"] = "Bouton ajouté",
@@ -27,12 +30,11 @@ pfUI_translation["frFR"] = {
["Always Show Item Comparison"] = "Toujours afficher la comparaison d'objet", ["Always Show Item Comparison"] = "Toujours afficher la comparaison d'objet",
["Always Show On Target Units"] = "Toujours montrer sur la cible", ["Always Show On Target Units"] = "Toujours montrer sur la cible",
["Always Show On Units With Missing HP"] = "Toujours montrer sur les cibles avec de la vie manquante", ["Always Show On Units With Missing HP"] = "Toujours montrer sur les cibles avec de la vie manquante",
["Always Show Self In Raid Frames"] = "Toujours montrer soi-même dans le cadre de raid",
["Always Use 2D Portraits"] = "Toujours utiliser les portraits 2D",
["Ammo Counter"] = "Compteur de munitions", ["Ammo Counter"] = "Compteur de munitions",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Une nouvelle installation de |cff33ffccpf|rUI est livrée avec 4 profils de conception prédéfinis, Cliquez ci-dessous si vous souhaitez charger l'un de ces profils", ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Une nouvelle installation de |cff33ffccpf|rUI est livrée avec 4 profils de conception prédéfinis, Cliquez ci-dessous si vous souhaitez charger l'un de ces profils",
["A new version is available"] = "Une nouvelle version est disponible", ["A new version is available"] = "Une nouvelle version est disponible",
["Animate Health And Power Bars"] = nil,
["Appearance"] = "Apparence", ["Appearance"] = "Apparence",
["Ascending"] = "Ascendante", ["Ascending"] = "Ascendante",
["Author"] = "Auteur", ["Author"] = "Auteur",
@@ -52,10 +54,12 @@ pfUI_translation["frFR"] = {
["Auto Sell Grey Items"] = "Vente automatique des objets gris", ["Auto Sell Grey Items"] = "Vente automatique des objets gris",
["Average Per Hour"] = "Moyenne par heure", ["Average Per Hour"] = "Moyenne par heure",
["Background Color"] = "Couleur de l'arrière-plan", ["Background Color"] = "Couleur de l'arrière-plan",
["Bags"] = "Sacs",
["Bags & Bank"] = "Sacs et Banque", ["Bags & Bank"] = "Sacs et Banque",
["Bags Border Size"] = "Taille de la bordure des Sacs", ["Bags Border Size"] = "Taille de la bordure des Sacs",
["Bagslots Per Row"] = "Emplacements des sacs par rangée", ["Bagslots Per Row"] = "Emplacements des sacs par rangée",
["Bagspace"] = "Place libre des sacs", ["Bagspace"] = "Place libre des sacs",
["Bank"] = "Banque",
["Banker"] = "Banquier", ["Banker"] = "Banquier",
["Bankslots Per Row"] = "Emplacements de la banque par rangée", ["Bankslots Per Row"] = "Emplacements de la banque par rangée",
["Bar Background"] = "Arrière plan de la barre", ["Bar Background"] = "Arrière plan de la barre",
@@ -77,7 +81,7 @@ pfUI_translation["frFR"] = {
["Buffbar Width"] = "Largeur de la barre des Améliorations", ["Buffbar Width"] = "Largeur de la barre des Améliorations",
["Buff/Debuff Icons"] = "Icones de Améliorations/Affaiblissements", ["Buff/Debuff Icons"] = "Icones de Améliorations/Affaiblissements",
["Buff/Debuff Indicators"] = nil, ["Buff/Debuff Indicators"] = nil,
["Buff Font Size"] = "Taille de la police des Améliorations", ["Buff Indicators"] = nil,
["Buff Limit"] = "Limite des améliorations", ["Buff Limit"] = "Limite des améliorations",
["Buff Position"] = "Position des améliorations", ["Buff Position"] = "Position des améliorations",
["Buffs"] = "Buffs", ["Buffs"] = "Buffs",
@@ -119,11 +123,16 @@ pfUI_translation["frFR"] = {
["Chat Bubble Transparency"] = "Transparence de la bulle de chat", ["Chat Bubble Transparency"] = "Transparence de la bulle de chat",
["Chat Default Brackets"] = "Supports par défaut du chat", ["Chat Default Brackets"] = "Supports par défaut du chat",
["Class"] = "Classe", ["Class"] = "Classe",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = "Clear les roulements", ["Clear Rolls"] = "Clear les roulements",
["Click Action"] = "Action au clic", ["Click Action"] = "Action au clic",
["Click Casting"] = "Clique sur le lancement de sort", ["Click Casting"] = "Clique sur le lancement de sort",
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "Horloge", ["Clock"] = "Horloge",
["Close"] = "Fermer", ["Close"] = "Fermer",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Couleur des l'empilements des Améliorations", ["Color Buff Stacks"] = "Couleur des l'empilements des Améliorations",
["Color Debuff Stacks"] = "Couleur de l'empilements de Affaiblissements", ["Color Debuff Stacks"] = "Couleur de l'empilements de Affaiblissements",
@@ -143,21 +152,16 @@ pfUI_translation["frFR"] = {
["Configuration"] = "Configuration", ["Configuration"] = "Configuration",
["Configure"] = "Configurer", ["Configure"] = "Configurer",
["Cooldown"] = "Temps de recharge", ["Cooldown"] = "Temps de recharge",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "Couleur des temps de recharge (Jours)", ["Cooldown Color (Days)"] = "Couleur des temps de recharge (Jours)",
["Cooldown Color (Hours)"] = "Couleur des temps de recharge (Heures)", ["Cooldown Color (Hours)"] = "Couleur des temps de recharge (Heures)",
["Cooldown Color (Less than 3 Sec)"] = "Couleur des temps de recharge (Moins de 3 secondes)",
["Cooldown Color (Minutes)"] = "Couleur des temps de recharge (Minutes)", ["Cooldown Color (Minutes)"] = "Couleur des temps de recharge (Minutes)",
["Cooldown Color (Seconds)"] = "Couleur des temps de recharge (Secondes)", ["Cooldown Color (Seconds)"] = "Couleur des temps de recharge (Secondes)",
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = "Taille de la police du texte des temps de recharge",
["Cooldown Text Font Size (Blizzard Frames)"] = "Taille de la police du texte des temps de recharge (Blizzard Frames)",
["Cooldown Text Font Size (Foreign Frames)"] = "Taille de la police du texte des temps de recharge (Foreign Frames)",
["Cooldown Text Size"] = nil,
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = "Seuil du texte des temps de recharge",
["Coordinates Location"] = "Coordonnées Emplacement", ["Coordinates Location"] = "Coordonnées Emplacement",
["Coordinates On Minimap"] = "Coordonnées sur la mini-carte", ["Coordinates On Minimap"] = "Coordonnées sur la mini-carte",
["Copied to clipboard"] = nil,
["Count"] = "Compter", ["Count"] = "Compter",
["Create Profile"] = "Créer un profil", ["Create Profile"] = "Créer un profil",
["Ctrl-Click"] = "Ctrl-Clique", ["Ctrl-Click"] = "Ctrl-Clique",
@@ -198,7 +202,6 @@ pfUI_translation["frFR"] = {
["Description Font"] = "Description de la Police", ["Description Font"] = "Description de la Police",
["Description Font Size"] = "Description de la taille de la Police", ["Description Font Size"] = "Description de la taille de la Police",
["Detailed Random Roll Announcement"] = "Annonce détaillée des Rolls aléatoires", ["Detailed Random Roll Announcement"] = "Annonce détaillée des Rolls aléatoires",
["Detect Enemy Buffs"] = nil,
["Disable"] = "Désactiver", ["Disable"] = "Désactiver",
["Disable Blizzard Castbar"] = "Désactiver la barre d'incantation d'origine", ["Disable Blizzard Castbar"] = "Désactiver la barre d'incantation d'origine",
["Disabled"] = "Désactivé", ["Disabled"] = "Désactivé",
@@ -275,12 +278,9 @@ pfUI_translation["frFR"] = {
["Enable Custom Incoming Whispers Layout"] = "Activer la personnalisation de la fenêtre des Chuchotements entrants", ["Enable Custom Incoming Whispers Layout"] = "Activer la personnalisation de la fenêtre des Chuchotements entrants",
["Enable Debuff Display"] = "Activer l'affichage des Affaiblissements", ["Enable Debuff Display"] = "Activer l'affichage des Affaiblissements",
["Enable Debuffs"] = "Activer les affaiblissements", ["Enable Debuffs"] = "Activer les affaiblissements",
["Enable Durations On Blizzard Frames"] = "Activer les durées sur les cadres Blizzard",
["Enable Durations On Foreign Frames"] = "Activer les durées sur les cadres extérieur",
["Enable Energy Ticks"] = "Activer la barre de rechargement d'énergie", ["Enable Energy Ticks"] = "Activer la barre de rechargement d'énergie",
["Enable Extended Guild Information"] = "Activer les informations de guilde étendues", ["Enable Extended Guild Information"] = "Activer les informations de guilde étendues",
["Enable Frame Shadow"] = "Activer l'ombre des cadres", ["Enable Frame Shadow"] = "Activer l'ombre des cadres",
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = "Activer les indicateurs", ["Enable Indicators"] = "Activer les indicateurs",
["Enable Item Quality Color For Equipment Only"] = "Activer la couleur de la qualité des objets seulement sur les pièces d'équipement", ["Enable Item Quality Color For Equipment Only"] = "Activer la couleur de la qualité des objets seulement sur les pièces d'équipement",
["Enable \"Loot & Spam\" Chat Window"] = "Activer la fenêtre de chat \"Butins & Spam\"", ["Enable \"Loot & Spam\" Chat Window"] = "Activer la fenêtre de chat \"Butins & Spam\"",
@@ -290,7 +290,6 @@ pfUI_translation["frFR"] = {
["Enable Mana Ticks"] = "Activer les Ticks de mana", ["Enable Mana Ticks"] = "Activer les Ticks de mana",
["Enable Micro Bar"] = "Activer la barre des menus miniature", ["Enable Micro Bar"] = "Activer la barre des menus miniature",
["Enable Mouselook With Right Click"] = "Activer le déplacement de la caméra avec le clic droit", ["Enable Mouselook With Right Click"] = "Activer le déplacement de la caméra avec le clic droit",
["Enable Mouseover Tooltip"] = "Activer l'infobulle au passage de la souris",
["Enable Movable Bags"] = "Activer les sacs mobiles", ["Enable Movable Bags"] = "Activer les sacs mobiles",
["Enable Offscreen Frame Positions"] = "Activer le positionnement des cadres en dehors de l'écran", ["Enable Offscreen Frame Positions"] = "Activer le positionnement des cadres en dehors de l'écran",
["Enable Overlap"] = "Activer la superposition", ["Enable Overlap"] = "Activer la superposition",
@@ -311,6 +310,7 @@ pfUI_translation["frFR"] = {
["Encode"] = "Encoder", ["Encode"] = "Encoder",
["Ended"] = "Terminé", ["Ended"] = "Terminé",
["Energy Color"] = "Couleur de l'energie", ["Energy Color"] = "Couleur de l'energie",
["Equipped"] = "Équipé",
["Equipped Item Color"] = "Couleur de l'objet équipé", ["Equipped Item Color"] = "Couleur de l'objet équipé",
["Estimate Debuffs"] = "Estimer les Affaiblissements", ["Estimate Debuffs"] = "Estimer les Affaiblissements",
["Estimate Enemy Health Points"] = "Estimer les points de vie ennemis", ["Estimate Enemy Health Points"] = "Estimer les points de vie ennemis",
@@ -335,6 +335,7 @@ pfUI_translation["frFR"] = {
["Font"] = "Police de caractère", ["Font"] = "Police de caractère",
["Font Options"] = "Options de la Police", ["Font Options"] = "Options de la Police",
["Font Padding"] = "Remplissage de la police", ["Font Padding"] = "Remplissage de la police",
["Font Size"] = nil,
["Font Style"] = "Style de la police", ["Font Style"] = "Style de la police",
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = "fps", ["fps"] = "fps",
@@ -369,7 +370,6 @@ pfUI_translation["frFR"] = {
["Health"] = "Point de vie", ["Health"] = "Point de vie",
["Health - Auto"] = "Points de vie - Automatique", ["Health - Auto"] = "Points de vie - Automatique",
["Healthbar"] = "Barre des points de vie", ["Healthbar"] = "Barre des points de vie",
["Healthbar Animation Speed"] = "Vitesse de l'animation des barres de vie",
["Health Bar Color"] = "Couleur de la barre des points de vie", ["Health Bar Color"] = "Couleur de la barre des points de vie",
["Healthbar Embedded"] = "Barres de vies intégrées", ["Healthbar Embedded"] = "Barres de vies intégrées",
["Healthbar Height"] = "Hauteur des barres de vies", ["Healthbar Height"] = "Hauteur des barres de vies",
@@ -394,7 +394,6 @@ pfUI_translation["frFR"] = {
["Hide Channel Names"] = "Masquer le nom des canaux", ["Hide Channel Names"] = "Masquer le nom des canaux",
["Hide Chat When Bags Are Opened"] = "Masquer le chat quand les sacs sont ouverts", ["Hide Chat When Bags Are Opened"] = "Masquer le chat quand les sacs sont ouverts",
["Hide Combat Log"] = "Masquer le journal de combat", ["Hide Combat Log"] = "Masquer le journal de combat",
["Hide Foreign Cooldown Animations"] = "Masquer les animations de temps de recharge étrangères",
["Hide Group Frames While In Raid"] = "Masquer l'UI Groupe en Raid", ["Hide Group Frames While In Raid"] = "Masquer l'UI Groupe en Raid",
["Hide Healthbar On Critters"] = "Masquer la barre de vie des bêtes", ["Hide Healthbar On Critters"] = "Masquer la barre de vie des bêtes",
["Hide Healthbar On Enemy NPCs"] = "Masquer la barre de vie des PNJs ennemis", ["Hide Healthbar On Enemy NPCs"] = "Masquer la barre de vie des PNJs ennemis",
@@ -403,6 +402,7 @@ pfUI_translation["frFR"] = {
["Hide Healthbar On Friendly Players"] = "Masquer la barre de vie des joueurs amicaux", ["Hide Healthbar On Friendly Players"] = "Masquer la barre de vie des joueurs amicaux",
["Hide Healthbar On Neutral NPCs"] = "Masquer la barre de vie des PNJs neutre", ["Hide Healthbar On Neutral NPCs"] = "Masquer la barre de vie des PNJs neutre",
["Hide Healthbar On Totems"] = "Masquer la barre de vie des totems", ["Hide Healthbar On Totems"] = "Masquer la barre de vie des totems",
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = "Masquer le délai d'expiration", ["Hide Timeout"] = "Masquer le délai d'expiration",
["Hide When Entering Combat"] = "Masquer lors de l'entrée en combat", ["Hide When Entering Combat"] = "Masquer lors de l'entrée en combat",
["Highlight Equipped Items"] = "Mettre en surbrillance les objets équipés", ["Highlight Equipped Items"] = "Mettre en surbrillance les objets équipés",
@@ -431,7 +431,6 @@ pfUI_translation["frFR"] = {
["Inherit Default Colors"] = "Hériter des couleurs par défaut", ["Inherit Default Colors"] = "Hériter des couleurs par défaut",
["Inputbox Height"] = "Hauteur du champ de saisie du texte", ["Inputbox Height"] = "Hauteur du champ de saisie du texte",
["Inputbox Width"] = "Largeur du champ de saisie du texte", ["Inputbox Width"] = "Largeur du champ de saisie du texte",
["Instant"] = "Instantané",
["Integrations"] = nil, ["Integrations"] = nil,
["Invert Health Bar"] = "Inverser les barres de vie", ["Invert Health Bar"] = "Inverser les barres de vie",
["is not allowed in profile name"] = "n'est pas autorisé comme nom de profil", ["is not allowed in profile name"] = "n'est pas autorisé comme nom de profil",
@@ -476,6 +475,7 @@ pfUI_translation["frFR"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = "Butin", ["Loot"] = "Butin",
["Loot & Spam"] = "Butin & Spam", ["Loot & Spam"] = "Butin & Spam",
["Loss Of Control"] = nil,
["Macro Text Color"] = "Couleur du texte de la macro", ["Macro Text Color"] = "Couleur du texte de la macro",
["Macro Text Size"] = "Taille du texte de la macro", ["Macro Text Size"] = "Taille du texte de la macro",
["Main Actionbar"] = "Barre d'action principale", ["Main Actionbar"] = "Barre d'action principale",
@@ -515,6 +515,7 @@ pfUI_translation["frFR"] = {
["Name | Health Missing"] = "Nom | santé manquante", ["Name | Health Missing"] = "Nom | santé manquante",
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = "Taille de la bordure des barres de vie flottantes", ["Nameplate Border Size"] = "Taille de la bordure des barres de vie flottantes",
["Nameplate Debuffs"] = nil,
["Nameplates"] = "Barres de vie flottantes", ["Nameplates"] = "Barres de vie flottantes",
["Nameplate Width"] = "Largeur des barres de vie flottantes", ["Nameplate Width"] = "Largeur des barres de vie flottantes",
["Name (Short)"] = "Nom (Court)", ["Name (Short)"] = "Nom (Court)",
@@ -553,6 +554,7 @@ pfUI_translation["frFR"] = {
["On State Change"] = "Sur changement d'état", ["On State Change"] = "Sur changement d'état",
["Options"] = "Options", ["Options"] = "Options",
["Orientation"] = "Orientation", ["Orientation"] = "Orientation",
["Other Addons"] = nil,
["Other Panel: Minimap"] = "Autre panneau : Minicarte", ["Other Panel: Minimap"] = "Autre panneau : Minicarte",
["Outline"] = "Contour", ["Outline"] = "Contour",
["Outlines"] = "Grandes lignes", ["Outlines"] = "Grandes lignes",
@@ -568,6 +570,7 @@ pfUI_translation["frFR"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Pageable", ["Pageable"] = "Pageable",
["Paging Actionbar"] = "Barre d'action de pagination", ["Paging Actionbar"] = "Barre d'action de pagination",
["Panel"] = "Panneau", ["Panel"] = "Panneau",
@@ -580,6 +583,7 @@ pfUI_translation["frFR"] = {
["Pixel"] = "Pixel", ["Pixel"] = "Pixel",
["Player"] = "Joueur", ["Player"] = "Joueur",
["Player Buff Bar"] = "Barre des Améliorations du Joueur", ["Player Buff Bar"] = "Barre des Améliorations du Joueur",
["Player Buffs"] = nil,
["Player Castbar"] = "Barre d'incantation du Joueur", ["Player Castbar"] = "Barre d'incantation du Joueur",
["Player Debuff Bar"] = "Barre des Affaiblissements du Joueur", ["Player Debuff Bar"] = "Barre des Affaiblissements du Joueur",
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["frFR"] = {
["Portrait Alpha"] = "Transparence du portrait", ["Portrait Alpha"] = "Transparence du portrait",
["Portrait Height"] = "Hauteur du portrait", ["Portrait Height"] = "Hauteur du portrait",
["Portrait Position"] = "Position du portrait", ["Portrait Position"] = "Position du portrait",
["Portrait Style"] = nil,
["Portrait Width"] = "Largeur du portrait", ["Portrait Width"] = "Largeur du portrait",
["Powerbar"] = "Barre des ressources", ["Powerbar"] = "Barre des ressources",
["Power Bar Anchor"] = "Ancrage de la Barre des ressources", ["Power Bar Anchor"] = "Ancrage de la Barre des ressources",
@@ -615,6 +620,7 @@ pfUI_translation["frFR"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Remplissage du Raid", ["Raid Padding"] = "Remplissage du Raid",
["Raid-Pet"] = nil,
["Random"] = "Aléatoire", ["Random"] = "Aléatoire",
["Random Roll Announcement Rarity"] = "Rareté des annonces des jets de dés aléatoires", ["Random Roll Announcement Rarity"] = "Rareté des annonces des jets de dés aléatoires",
["Random Rolling"] = "Lancer de dés aléatoires", ["Random Rolling"] = "Lancer de dés aléatoires",
@@ -644,6 +650,7 @@ pfUI_translation["frFR"] = {
["Resting"] = "Au Repos", ["Resting"] = "Au Repos",
["Reveal Unexplored Areas"] = "Révèle les zones non explorées", ["Reveal Unexplored Areas"] = "Révèle les zones non explorées",
["Switch to current zone"] = "Aller à la zone actuelle", ["Switch to current zone"] = "Aller à la zone actuelle",
["Reverse Sweep On"] = nil,
["Right"] = "Droit", ["Right"] = "Droit",
["Right Actionbar"] = "Barre d'action droite", ["Right Actionbar"] = "Barre d'action droite",
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["frFR"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = "Échelle", ["Scale"] = "Échelle",
["Scale Border On HiDPI Displays"] = "Échelle de bordure sur les écrans HiDPI", ["Scale Border On HiDPI Displays"] = "Échelle de bordure sur les écrans HiDPI",
["Scale Font Size With Icon"] = nil,
["Scaling"] = "Mise à l'échelle", ["Scaling"] = "Mise à l'échelle",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "Résolution d'écran", ["Screen Resolution"] = "Résolution d'écran",
["Screenshot"] = "Imprime écran", ["Screenshot"] = "Imprime écran",
@@ -702,6 +709,7 @@ pfUI_translation["frFR"] = {
["Show Description"] = "Afficher les descriptions", ["Show Description"] = "Afficher les descriptions",
["Show Dispel Indicators"] = "Afficher les indicateurs de dissipation", ["Show Dispel Indicators"] = "Afficher les indicateurs de dissipation",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Afficher la durée à l'intérieur des améliorations", ["Show Duration Inside Buff"] = "Afficher la durée à l'intérieur des améliorations",
["Show Empty Buttons"] = "Afficher les boutons vides", ["Show Empty Buttons"] = "Afficher les boutons vides",
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -724,7 +732,7 @@ pfUI_translation["frFR"] = {
["Show Loot Icon"] = "Afficher l'icône du butin", ["Show Loot Icon"] = "Afficher l'icône du butin",
["Show Macro Text"] = "Afficher le texte des macros", ["Show Macro Text"] = "Afficher le texte des macros",
["Show Meters By Default"] = "Afficher les compteurs par défaut", ["Show Meters By Default"] = "Afficher les compteurs par défaut",
["Show Milliseconds When Timer Runs Out"] = "Afficher les Millisecondes quand le temps est épuisée", ["Show Numbers On"] = nil,
["Show On Friendly Units"] = "Afficher sur les unités amicales", ["Show On Friendly Units"] = "Afficher sur les unités amicales",
["Show On Hostile Units"] = "Afficher sur les unités hostiles", ["Show On Hostile Units"] = "Afficher sur les unités hostiles",
["Show Procs Indicators"] = "Afficher les indicateurs de Procs", ["Show Procs Indicators"] = "Afficher les indicateurs de Procs",
@@ -738,13 +746,14 @@ pfUI_translation["frFR"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = "Afficher au repos", ["Show Resting"] = "Afficher au repos",
["Show Self In Group Frames"] = "S'afficher dans les cadres de groupe", ["Show Self In Group Frames"] = "S'afficher dans les cadres de groupe",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Afficher l'icone des sorts", ["Show Spell Icon"] = "Afficher l'icone des sorts",
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = "Afficher les empilements", ["Show Stacks"] = "Afficher les empilements",
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = "Afficher le temps restant",
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = nil,
["Show Timer Text"] = nil, ["Show Timer Text"] = nil,
["Show Totems Indicators"] = "Afficher les indicateurs des totems", ["Show Totems Indicators"] = "Afficher les indicateurs des totems",
["Shrink & Return"] = "Rétrécir et retourner", ["Shrink & Return"] = "Rétrécir et retourner",
@@ -761,8 +770,10 @@ pfUI_translation["frFR"] = {
["Soulshards"] = "Pierre d'âme", ["Soulshards"] = "Pierre d'âme",
["Spacing"] = "Espacement", ["Spacing"] = "Espacement",
["Special Recipient"] = "Recipient spécial", ["Special Recipient"] = "Recipient spécial",
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = "Carré", ["Square"] = "Carré",
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = "Barre de posture 1", ["Stance Bar 1"] = "Barre de posture 1",
["Stance Bar 2"] = "Barre de posture 2", ["Stance Bar 2"] = "Barre de posture 2",
["Stance Bar 3"] = "Barre de posture 3", ["Stance Bar 3"] = "Barre de posture 3",
@@ -797,7 +808,6 @@ pfUI_translation["frFR"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = "Seuil de confiance pour l'estimation de la santé", ["Threshold To Trust Health Estimation"] = "Seuil de confiance pour l'estimation de la santé",
["Time"] = "Heure", ["Time"] = "Heure",
["Timer"] = nil,
["Time Remaining"] = "Temps restant", ["Time Remaining"] = "Temps restant",
["Timer In Minutes"] = "Temps en minutes", ["Timer In Minutes"] = "Temps en minutes",
["Timestamp Brackets"] = "Supports des horaires des messages", ["Timestamp Brackets"] = "Supports des horaires des messages",
@@ -808,6 +818,7 @@ pfUI_translation["frFR"] = {
["Tiny (PixelPerfect)"] = "Minuscule (PixelParfait)", ["Tiny (PixelPerfect)"] = "Minuscule (PixelParfait)",
["Toggle as Tank"] = "Basculer en tant que tank", ["Toggle as Tank"] = "Basculer en tant que tank",
["Tooltip"] = "Infobulle", ["Tooltip"] = "Infobulle",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "Position de l'infobulle", ["Tooltip Position"] = "Position de l'infobulle",
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["frFR"] = {
["Top Actionbar"] = "Barre d'action supérieure", ["Top Actionbar"] = "Barre d'action supérieure",
["Top Left"] = "Haut Gauche", ["Top Left"] = "Haut Gauche",
["Top Right"] = "Haut Droit", ["Top Right"] = "Haut Droit",
["Total"] = "Total",
["Total Gold"] = "Or Total", ["Total Gold"] = "Or Total",
["Totem Direction"] = "Direction des totems", ["Totem Direction"] = "Direction des totems",
["Totem Icons"] = "Icones des totems", ["Totem Icons"] = "Icones des totems",
["Totems"] = nil,
["Tracked Reputation"] = nil, ["Tracked Reputation"] = nil,
["Tracking Icon Size"] = "Taille de l'icône de suivi", ["Tracking Icon Size"] = "Taille de l'icône de suivi",
["Trigger Actions On Key Down"] = "Déclencher des actions sur la touche enfoncée", ["Trigger Actions On Key Down"] = "Déclencher des actions sur la touche enfoncée",
["UI-Scale"] = "Echelle de l'interface", ["UI-Scale"] = "Echelle de l'interface",
["Unbuffed"] = "Sans Améliorations", ["Unbuffed"] = "Sans Améliorations",
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "Taille de la bordure des cadres d'unité", ["Unit Frame Border Size"] = "Taille de la bordure des cadres d'unité",
["Unit Frame Layout"] = "Position des cadres d'unité", ["Unit Frame Layout"] = "Position des cadres d'unité",
["Unit Frames"] = "Cadres d'unités", ["Unit Frames"] = "Cadres d'unités",
@@ -849,7 +863,6 @@ pfUI_translation["frFR"] = {
["Use Custom Color Power Bar Background"] = "Utiliser l'arrière-plan de la barre d'alimentation de couleur personnalisée", ["Use Custom Color Power Bar Background"] = "Utiliser l'arrière-plan de la barre d'alimentation de couleur personnalisée",
["Use Custom Font Settings"] = nil, ["Use Custom Font Settings"] = nil,
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = "Utiliser la taille de police dynamique",
["Use Item Rarity Color For Loot-Roll Timer"] = "Utiliser la couleur de la rareté de l'objet pour la minuterie du lancer de dés", ["Use Item Rarity Color For Loot-Roll Timer"] = "Utiliser la couleur de la rareté de l'objet pour la minuterie du lancer de dés",
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = "Utiliser l'UI Raid pour afficher les Membres du Groupe", ["Use Raid Frames To Display Group Members"] = "Utiliser l'UI Raid pour afficher les Membres du Groupe",
@@ -867,7 +880,6 @@ pfUI_translation["frFR"] = {
["Website"] = "Site web", ["Website"] = "Site web",
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "Bienvenue sur l'assistant d'installation de l'interface |cff33ffccpf|cffffffffUI|r!\n\nNous allons effectuer quelques configurations de base. Si vous n'avez pas la patience, cliquer sur le bouton \"Paramètres par défaut\". Si vous souhaitez relancer cette fenêtre de dialogue, allez dans les options et cliquez sur le bouton\"Réinitialiser l'assistant d'installation\" .\n\nAllez sur |cff33ffcc%s|r pour télécharger la dernière version.", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "Bienvenue sur l'assistant d'installation de l'interface |cff33ffccpf|cffffffffUI|r!\n\nNous allons effectuer quelques configurations de base. Si vous n'avez pas la patience, cliquer sur le bouton \"Paramètres par défaut\". Si vous souhaitez relancer cette fenêtre de dialogue, allez dans les options et cliquez sur le bouton\"Réinitialiser l'assistant d'installation\" .\n\nAllez sur |cff33ffcc%s|r pour télécharger la dernière version.",
["Whitelist"] = "List blanche", ["Whitelist"] = "List blanche",
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = "Largeur", ["Width"] = "Largeur",
["Wobble Zoom"] = "Zoom oscillant", ["Wobble Zoom"] = "Zoom oscillant",
["Won"] = "A gagné", ["Won"] = "A gagné",
@@ -886,4 +898,74 @@ pfUI_translation["frFR"] = {
["Zonetime"] = nil, ["Zonetime"] = nil,
["Zoom & Fade"] = "Zoom et fondu", ["Zoom & Fade"] = "Zoom et fondu",
["Zoom Target Nameplate"] = "Zoom la cible des barres de vie flottantes", ["Zoom Target Nameplate"] = "Zoom la cible des barres de vie flottantes",
["%d items, %d ignored"] = "%d objets, %d ignorés",
["Add the current zone"] = "Ajouter la zone actuelle",
["Announce Automatic Set Switches In Chat"] = "Annoncer les changements automatiques d'ensemble dans le chat",
["Any Form"] = "N'importe quelle forme",
["Aquatic Form"] = "Forme aquatique",
["Automatic Set Switching"] = "Changement automatique d'ensemble",
["Battle Stance"] = "Posture de combat",
["Battleground"] = "Champ de bataille",
["Bear Form"] = "Forme d'ours",
["Berserker Stance"] = "Posture berserker",
["Cat Form"] = "Forme de félin",
["Condition met, but a trigger higher in the list wins"] = "Condition remplie, mais un déclencheur plus haut dans la liste est prioritaire",
["Create an equipment set first."] = "Créez d'abord un ensemble d'équipement.",
["Currently active"] = "Actuellement actif",
["Defensive Stance"] = "Posture défensive",
["Do Nothing"] = "Ne rien faire",
["Dungeon"] = "Donjon",
["Eating / Drinking"] = "Manger / Boire",
["Enable Automatic Set Switching"] = "Activer le changement automatique d'ensemble",
["Equip"] = "Équiper",
["Equip sets automatically when mounted, swimming, eating, in a zone, at a given time and more."] = "Équipe automatiquement des ensembles en monture, en nageant, en mangeant, dans une zone, à une heure donnée, etc.",
["Equipment Manager"] = "Gestionnaire d'équipement",
["Equippable items in your bags, bank and paperdoll that no equipment set uses."] = "Objets équipables dans vos sacs, votre banque et sur votre personnage qu'aucun ensemble n'utilise.",
["Equipping %s"] = "Équipement de %s",
["Equipping %s (%s)"] = "Équipement de %s (%s)",
["Every equippable item is part of a set."] = "Tous les objets équipables font partie d'un ensemble.",
["Ghost Wolf"] = "Loup fantôme",
["Here"] = "Ici",
["Ignored (Right-Click to unignore)"] = "Ignoré (clic droit pour ne plus ignorer)",
["In Bags"] = "Dans les sacs",
["In Bank"] = "En banque",
["Include Bank Items"] = "Inclure les objets en banque",
["Instance Type"] = "Type d'instance",
["Items Not In Any Set"] = "Objets hors de tout ensemble",
["Local time window, e.g. 20:00-23:00"] = "Plage horaire locale, ex. 20:00-23:00",
["Minimum Item Quality"] = "Qualité minimale des objets",
["Moonkin Form"] = "Forme de sélénien",
["Mounted"] = "En monture",
["New Trigger"] = "Nouveau déclencheur",
["No Form (Caster)"] = "Sans forme (lanceur de sorts)",
["No set selected"] = "Aucun ensemble choisi",
["No triggers yet. Click \"New Trigger\" to add one."] = "Aucun déclencheur. Cliquez sur \"Nouveau déclencheur\" pour en ajouter un.",
["Not part of any equipment set"] = "Ne fait partie d'aucun ensemble",
["Open World"] = "Monde extérieur",
["Resting (Inn / City)"] = "Repos (auberge / ville)",
["Restore Previous Gear"] = "Remettre l'équipement précédent",
["Restoring previous gear"] = "Remise de l'équipement précédent",
["Select a trigger to edit it."] = "Sélectionnez un déclencheur pour le modifier.",
["Selected Trigger"] = "Déclencheur sélectionné",
["Separate several zones with ;"] = "Séparez plusieurs zones par ;",
["Shadowform"] = "Forme d'Ombre",
["Shapeshift Form / Stance"] = "Forme / Posture",
["Shift-Click: Link Ctrl-Click: Preview\nRight-Click: Ignore / Unignore"] = "Maj-clic : lien Ctrl-clic : aperçu\nClic droit : ignorer / ne plus ignorer",
["Show Ignored"] = "Afficher les ignorés",
["Stealth"] = "Camouflage",
["Stealthed"] = "Camouflé",
["Swimming"] = "À la nage",
["Targeting A Boss"] = "Cible un boss",
["Time Of Day"] = "Heure de la journée",
["Travel Form"] = "Forme de voyage",
["Tree of Life Form"] = "Forme d'arbre de vie",
["Triggers"] = "Déclencheurs",
["Triggers higher in the list take priority. Gear is never swapped in combat, while dead or while casting: the switch waits until it can happen."] = "Les déclencheurs en haut de la liste sont prioritaires. L'équipement n'est jamais changé en combat, mort ou pendant une incantation : le changement attend que ce soit possible.",
["Unused"] = "Inutilisés",
["Value"] = "Valeur",
["When"] = "Quand",
["When It Ends"] = "À la fin",
["Windows may wrap past midnight (22:00-02:00)."] = "Une plage peut passer minuit (22:00-02:00).",
["Zone"] = "Zone",
["Zone or subzone name"] = "Nom de zone ou de sous-zone",
} }
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["koKR"] = { pfUI_translation["koKR"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = "체력수치 약어 (4200 -> 4.2k)", ["Abbreviate Numbers (4200 -> 4.2k)"] = "체력수치 약어 (4200 -> 4.2k)",
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["koKR"] = {
["Actionbar"] = "액션바", ["Actionbar"] = "액션바",
["Action Bar"] = nil, ["Action Bar"] = nil,
["Action Bar Border Size"] = "액션바 테두리 크기", ["Action Bar Border Size"] = "액션바 테두리 크기",
["Action Bars"] = nil,
["Active Addons"] = "애드온 활성화", ["Active Addons"] = "애드온 활성화",
["Add button to the frame"] = nil, ["Add button to the frame"] = nil,
["Added button"] = nil, ["Added button"] = nil,
@@ -27,12 +30,11 @@ pfUI_translation["koKR"] = {
["Always Show Item Comparison"] = "항상 착용 장비와 비교 표시", ["Always Show Item Comparison"] = "항상 착용 장비와 비교 표시",
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = "항상 2D초상화 사용",
["Ammo Counter"] = "탄약 갯수", ["Ammo Counter"] = "탄약 갯수",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil, ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = nil,
["A new version is available"] = nil, ["A new version is available"] = nil,
["Animate Health And Power Bars"] = nil,
["Appearance"] = "외관 설정", ["Appearance"] = "외관 설정",
["Ascending"] = nil, ["Ascending"] = nil,
["Author"] = nil, ["Author"] = nil,
@@ -52,10 +54,12 @@ pfUI_translation["koKR"] = {
["Auto Sell Grey Items"] = "회색아이템 자동 판매", ["Auto Sell Grey Items"] = "회색아이템 자동 판매",
["Average Per Hour"] = nil, ["Average Per Hour"] = nil,
["Background Color"] = "백그라운드 색상", ["Background Color"] = "백그라운드 색상",
["Bags"] = "가방",
["Bags & Bank"] = "가방&은행", ["Bags & Bank"] = "가방&은행",
["Bags Border Size"] = "가방 테두리 크기", ["Bags Border Size"] = "가방 테두리 크기",
["Bagslots Per Row"] = nil, ["Bagslots Per Row"] = nil,
["Bagspace"] = "가방 공간", ["Bagspace"] = "가방 공간",
["Bank"] = "은행",
["Banker"] = nil, ["Banker"] = nil,
["Bankslots Per Row"] = nil, ["Bankslots Per Row"] = nil,
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -77,7 +81,7 @@ pfUI_translation["koKR"] = {
["Buffbar Width"] = nil, ["Buffbar Width"] = nil,
["Buff/Debuff Icons"] = nil, ["Buff/Debuff Icons"] = nil,
["Buff/Debuff Indicators"] = nil, ["Buff/Debuff Indicators"] = nil,
["Buff Font Size"] = nil, ["Buff Indicators"] = nil,
["Buff Limit"] = "버프 한도", ["Buff Limit"] = "버프 한도",
["Buff Position"] = "버프 위치", ["Buff Position"] = "버프 위치",
["Buffs"] = nil, ["Buffs"] = nil,
@@ -119,11 +123,16 @@ pfUI_translation["koKR"] = {
["Chat Bubble Transparency"] = nil, ["Chat Bubble Transparency"] = nil,
["Chat Default Brackets"] = nil, ["Chat Default Brackets"] = nil,
["Class"] = "클래스(직업)", ["Class"] = "클래스(직업)",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = nil, ["Clear Rolls"] = nil,
["Click Action"] = "클릭 액션", ["Click Action"] = "클릭 액션",
["Click Casting"] = nil, ["Click Casting"] = nil,
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "시계", ["Clock"] = "시계",
["Close"] = "닫기", ["Close"] = "닫기",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -143,21 +152,16 @@ pfUI_translation["koKR"] = {
["Configuration"] = "구성", ["Configuration"] = "구성",
["Configure"] = nil, ["Configure"] = nil,
["Cooldown"] = "쿨다운", ["Cooldown"] = "쿨다운",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "재사용 대기시간 컬러(일)", ["Cooldown Color (Days)"] = "재사용 대기시간 컬러(일)",
["Cooldown Color (Hours)"] = "재사용 대기시간 컬러(시간)", ["Cooldown Color (Hours)"] = "재사용 대기시간 컬러(시간)",
["Cooldown Color (Less than 3 Sec)"] = "재사용 대기시간 컬러(3초전)",
["Cooldown Color (Minutes)"] = "재사용 대기시간 컬러(분)", ["Cooldown Color (Minutes)"] = "재사용 대기시간 컬러(분)",
["Cooldown Color (Seconds)"] = "재사용 대기시간 컬러(초)", ["Cooldown Color (Seconds)"] = "재사용 대기시간 컬러(초)",
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = "재사용 대기시간 텍스트 폰트 크기",
["Cooldown Text Font Size (Blizzard Frames)"] = nil,
["Cooldown Text Font Size (Foreign Frames)"] = nil,
["Cooldown Text Size"] = nil,
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = "재사용 대기시간 텍스트 임계 값",
["Coordinates Location"] = nil, ["Coordinates Location"] = nil,
["Coordinates On Minimap"] = "미니맵의 좌표", ["Coordinates On Minimap"] = "미니맵의 좌표",
["Copied to clipboard"] = nil,
["Count"] = "카운트", ["Count"] = "카운트",
["Create Profile"] = "프로파일 생성", ["Create Profile"] = "프로파일 생성",
["Ctrl-Click"] = nil, ["Ctrl-Click"] = nil,
@@ -198,7 +202,6 @@ pfUI_translation["koKR"] = {
["Description Font"] = nil, ["Description Font"] = nil,
["Description Font Size"] = nil, ["Description Font Size"] = nil,
["Detailed Random Roll Announcement"] = nil, ["Detailed Random Roll Announcement"] = nil,
["Detect Enemy Buffs"] = nil,
["Disable"] = "가리기", ["Disable"] = "가리기",
["Disable Blizzard Castbar"] = "블리자드 캐스트바 사용 중지", ["Disable Blizzard Castbar"] = "블리자드 캐스트바 사용 중지",
["Disabled"] = "가리기", ["Disabled"] = "가리기",
@@ -275,12 +278,9 @@ pfUI_translation["koKR"] = {
["Enable Custom Incoming Whispers Layout"] = "사용자 지정 귓속말 레이아웃 활성화", ["Enable Custom Incoming Whispers Layout"] = "사용자 지정 귓속말 레이아웃 활성화",
["Enable Debuff Display"] = nil, ["Enable Debuff Display"] = nil,
["Enable Debuffs"] = "디버프 활성화", ["Enable Debuffs"] = "디버프 활성화",
["Enable Durations On Blizzard Frames"] = nil,
["Enable Durations On Foreign Frames"] = nil,
["Enable Energy Ticks"] = "Energy Ticks 활성화", ["Enable Energy Ticks"] = "Energy Ticks 활성화",
["Enable Extended Guild Information"] = "길드 정보 확장 사용", ["Enable Extended Guild Information"] = "길드 정보 확장 사용",
["Enable Frame Shadow"] = nil, ["Enable Frame Shadow"] = nil,
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = nil, ["Enable Indicators"] = nil,
["Enable Item Quality Color For Equipment Only"] = "착용장비 전용 아이템품질 색상 활성화", ["Enable Item Quality Color For Equipment Only"] = "착용장비 전용 아이템품질 색상 활성화",
["Enable \"Loot & Spam\" Chat Window"] = "\"루팅 & 스팜\"채팅 창 사용", ["Enable \"Loot & Spam\" Chat Window"] = "\"루팅 & 스팜\"채팅 창 사용",
@@ -290,7 +290,6 @@ pfUI_translation["koKR"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = "미니바 보기(블리자드 마이크로바)", ["Enable Micro Bar"] = "미니바 보기(블리자드 마이크로바)",
["Enable Mouselook With Right Click"] = "오른쪽 클릭 Mouselook 사용", ["Enable Mouselook With Right Click"] = "오른쪽 클릭 Mouselook 사용",
["Enable Mouseover Tooltip"] = nil,
["Enable Movable Bags"] = nil, ["Enable Movable Bags"] = nil,
["Enable Offscreen Frame Positions"] = "오프스크린 프레임 위치 활성화", ["Enable Offscreen Frame Positions"] = "오프스크린 프레임 위치 활성화",
["Enable Overlap"] = "겹쳐서 표시", ["Enable Overlap"] = "겹쳐서 표시",
@@ -311,6 +310,7 @@ pfUI_translation["koKR"] = {
["Encode"] = nil, ["Encode"] = nil,
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "착용 중",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -335,6 +335,7 @@ pfUI_translation["koKR"] = {
["Font"] = nil, ["Font"] = nil,
["Font Options"] = nil, ["Font Options"] = nil,
["Font Padding"] = nil, ["Font Padding"] = nil,
["Font Size"] = nil,
["Font Style"] = nil, ["Font Style"] = nil,
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = "프레임", ["fps"] = "프레임",
@@ -369,7 +370,6 @@ pfUI_translation["koKR"] = {
["Health"] = nil, ["Health"] = nil,
["Health - Auto"] = "체력-자동", ["Health - Auto"] = "체력-자동",
["Healthbar"] = nil, ["Healthbar"] = nil,
["Healthbar Animation Speed"] = "체력바 애니메이션 속도",
["Health Bar Color"] = nil, ["Health Bar Color"] = nil,
["Healthbar Embedded"] = "체력바에 겹쳐보기", ["Healthbar Embedded"] = "체력바에 겹쳐보기",
["Healthbar Height"] = "체력바 높이", ["Healthbar Height"] = "체력바 높이",
@@ -394,7 +394,6 @@ pfUI_translation["koKR"] = {
["Hide Channel Names"] = "채널 이름 숨기기", ["Hide Channel Names"] = "채널 이름 숨기기",
["Hide Chat When Bags Are Opened"] = nil, ["Hide Chat When Bags Are Opened"] = nil,
["Hide Combat Log"] = "전투 기록 숨기기", ["Hide Combat Log"] = "전투 기록 숨기기",
["Hide Foreign Cooldown Animations"] = nil,
["Hide Group Frames While In Raid"] = nil, ["Hide Group Frames While In Raid"] = nil,
["Hide Healthbar On Critters"] = nil, ["Hide Healthbar On Critters"] = nil,
["Hide Healthbar On Enemy NPCs"] = nil, ["Hide Healthbar On Enemy NPCs"] = nil,
@@ -403,6 +402,7 @@ pfUI_translation["koKR"] = {
["Hide Healthbar On Friendly Players"] = nil, ["Hide Healthbar On Friendly Players"] = nil,
["Hide Healthbar On Neutral NPCs"] = nil, ["Hide Healthbar On Neutral NPCs"] = nil,
["Hide Healthbar On Totems"] = nil, ["Hide Healthbar On Totems"] = nil,
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = nil, ["Hide Timeout"] = nil,
["Hide When Entering Combat"] = nil, ["Hide When Entering Combat"] = nil,
["Highlight Equipped Items"] = nil, ["Highlight Equipped Items"] = nil,
@@ -431,7 +431,6 @@ pfUI_translation["koKR"] = {
["Inherit Default Colors"] = nil, ["Inherit Default Colors"] = nil,
["Inputbox Height"] = "챗팅 입력창 높이", ["Inputbox Height"] = "챗팅 입력창 높이",
["Inputbox Width"] = "챗팅 입력창 넓이", ["Inputbox Width"] = "챗팅 입력창 넓이",
["Instant"] = "즉시",
["Integrations"] = nil, ["Integrations"] = nil,
["Invert Health Bar"] = "체력바 반전", ["Invert Health Bar"] = "체력바 반전",
["is not allowed in profile name"] = "프로필 이름에 허용되지 않습니다.", ["is not allowed in profile name"] = "프로필 이름에 허용되지 않습니다.",
@@ -476,6 +475,7 @@ pfUI_translation["koKR"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = "룻팅", ["Loot"] = "룻팅",
["Loot & Spam"] = "룻팅 & 기타", ["Loot & Spam"] = "룻팅 & 기타",
["Loss Of Control"] = nil,
["Macro Text Color"] = nil, ["Macro Text Color"] = nil,
["Macro Text Size"] = nil, ["Macro Text Size"] = nil,
["Main Actionbar"] = nil, ["Main Actionbar"] = nil,
@@ -515,6 +515,7 @@ pfUI_translation["koKR"] = {
["Name | Health Missing"] = nil, ["Name | Health Missing"] = nil,
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = nil, ["Nameplate Border Size"] = nil,
["Nameplate Debuffs"] = nil,
["Nameplates"] = "상바", ["Nameplates"] = "상바",
["Nameplate Width"] = "상바 넓이", ["Nameplate Width"] = "상바 넓이",
["Name (Short)"] = nil, ["Name (Short)"] = nil,
@@ -553,6 +554,7 @@ pfUI_translation["koKR"] = {
["On State Change"] = nil, ["On State Change"] = nil,
["Options"] = nil, ["Options"] = nil,
["Orientation"] = nil, ["Orientation"] = nil,
["Other Addons"] = nil,
["Other Panel: Minimap"] = "나머지 패널:미니맵", ["Other Panel: Minimap"] = "나머지 패널:미니맵",
["Outline"] = nil, ["Outline"] = nil,
["Outlines"] = nil, ["Outlines"] = nil,
@@ -568,6 +570,7 @@ pfUI_translation["koKR"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = "패널", ["Panel"] = "패널",
@@ -580,6 +583,7 @@ pfUI_translation["koKR"] = {
["Pixel"] = nil, ["Pixel"] = nil,
["Player"] = "플레이어", ["Player"] = "플레이어",
["Player Buff Bar"] = nil, ["Player Buff Bar"] = nil,
["Player Buffs"] = nil,
["Player Castbar"] = nil, ["Player Castbar"] = nil,
["Player Debuff Bar"] = nil, ["Player Debuff Bar"] = nil,
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["koKR"] = {
["Portrait Alpha"] = "초상화 투명도", ["Portrait Alpha"] = "초상화 투명도",
["Portrait Height"] = "세로 높이", ["Portrait Height"] = "세로 높이",
["Portrait Position"] = "초상화 위치", ["Portrait Position"] = "초상화 위치",
["Portrait Style"] = nil,
["Portrait Width"] = "세로 너비", ["Portrait Width"] = "세로 너비",
["Powerbar"] = nil, ["Powerbar"] = nil,
["Power Bar Anchor"] = nil, ["Power Bar Anchor"] = nil,
@@ -615,6 +620,7 @@ pfUI_translation["koKR"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = nil, ["Random"] = nil,
["Random Roll Announcement Rarity"] = nil, ["Random Roll Announcement Rarity"] = nil,
["Random Rolling"] = nil, ["Random Rolling"] = nil,
@@ -644,6 +650,7 @@ pfUI_translation["koKR"] = {
["Resting"] = "휴식", ["Resting"] = "휴식",
["Reveal Unexplored Areas"] = nil, ["Reveal Unexplored Areas"] = nil,
["Switch to current zone"] = nil, ["Switch to current zone"] = nil,
["Reverse Sweep On"] = nil,
["Right"] = "오른쪽", ["Right"] = "오른쪽",
["Right Actionbar"] = nil, ["Right Actionbar"] = nil,
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["koKR"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = nil, ["Scale"] = nil,
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scale Font Size With Icon"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "화면 해상도", ["Screen Resolution"] = "화면 해상도",
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -702,6 +709,7 @@ pfUI_translation["koKR"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = nil, ["Show Duration Inside Buff"] = nil,
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -724,7 +732,7 @@ pfUI_translation["koKR"] = {
["Show Loot Icon"] = nil, ["Show Loot Icon"] = nil,
["Show Macro Text"] = "매크로 텍스트 표시", ["Show Macro Text"] = "매크로 텍스트 표시",
["Show Meters By Default"] = nil, ["Show Meters By Default"] = nil,
["Show Milliseconds When Timer Runs Out"] = nil, ["Show Numbers On"] = nil,
["Show On Friendly Units"] = nil, ["Show On Friendly Units"] = nil,
["Show On Hostile Units"] = nil, ["Show On Hostile Units"] = nil,
["Show Procs Indicators"] = nil, ["Show Procs Indicators"] = nil,
@@ -738,13 +746,14 @@ pfUI_translation["koKR"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = nil,
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = nil,
["Show Timer Text"] = nil, ["Show Timer Text"] = nil,
["Show Totems Indicators"] = nil, ["Show Totems Indicators"] = nil,
["Shrink & Return"] = nil, ["Shrink & Return"] = nil,
@@ -761,8 +770,10 @@ pfUI_translation["koKR"] = {
["Soulshards"] = "영혼의 조각", ["Soulshards"] = "영혼의 조각",
["Spacing"] = nil, ["Spacing"] = nil,
["Special Recipient"] = nil, ["Special Recipient"] = nil,
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = nil, ["Square"] = nil,
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = nil, ["Stance Bar 1"] = nil,
["Stance Bar 2"] = nil, ["Stance Bar 2"] = nil,
["Stance Bar 3"] = nil, ["Stance Bar 3"] = nil,
@@ -797,7 +808,6 @@ pfUI_translation["koKR"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = nil, ["Threshold To Trust Health Estimation"] = nil,
["Time"] = "시간", ["Time"] = "시간",
["Timer"] = nil,
["Time Remaining"] = nil, ["Time Remaining"] = nil,
["Timer In Minutes"] = nil, ["Timer In Minutes"] = nil,
["Timestamp Brackets"] = nil, ["Timestamp Brackets"] = nil,
@@ -808,6 +818,7 @@ pfUI_translation["koKR"] = {
["Tiny (PixelPerfect)"] = nil, ["Tiny (PixelPerfect)"] = nil,
["Toggle as Tank"] = nil, ["Toggle as Tank"] = nil,
["Tooltip"] = "툴팁", ["Tooltip"] = "툴팁",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "툴팁위치", ["Tooltip Position"] = "툴팁위치",
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["koKR"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = nil, ["Top Left"] = nil,
["Top Right"] = nil, ["Top Right"] = nil,
["Total"] = "총",
["Total Gold"] = "총 금", ["Total Gold"] = "총 금",
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
["Totems"] = nil,
["Tracked Reputation"] = nil, ["Tracked Reputation"] = nil,
["Tracking Icon Size"] = nil, ["Tracking Icon Size"] = nil,
["Trigger Actions On Key Down"] = nil, ["Trigger Actions On Key Down"] = nil,
["UI-Scale"] = "UI-크기", ["UI-Scale"] = "UI-크기",
["Unbuffed"] = nil, ["Unbuffed"] = nil,
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "유닛프레임 테두리 크기", ["Unit Frame Border Size"] = "유닛프레임 테두리 크기",
["Unit Frame Layout"] = "유닛프레임 레이아웃", ["Unit Frame Layout"] = "유닛프레임 레이아웃",
["Unit Frames"] = "유닛프레임", ["Unit Frames"] = "유닛프레임",
@@ -849,7 +863,6 @@ pfUI_translation["koKR"] = {
["Use Custom Color Power Bar Background"] = nil, ["Use Custom Color Power Bar Background"] = nil,
["Use Custom Font Settings"] = nil, ["Use Custom Font Settings"] = nil,
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = nil,
["Use Item Rarity Color For Loot-Roll Timer"] = nil, ["Use Item Rarity Color For Loot-Roll Timer"] = nil,
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = nil, ["Use Raid Frames To Display Group Members"] = nil,
@@ -867,7 +880,6 @@ pfUI_translation["koKR"] = {
["Website"] = nil, ["Website"] = nil,
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "|cff33ffccpf|cffffffffUI|r에 |cff33ffcc오신걸 환영합니다.|r \n\n저는 몇 가지 기본 구성을 안내 할 첫 번째 실행 위자드입니다. 모든 단계를 건너 뛰고 싶으시면 \"기본값 사용\" 버튼을 누르십시오. 이 대화 상자를 다시 실행하려면 추후 설정으로 이동하여 \"첫단계로 재설정\" 버튼을 누르십시오.\n\n최신버전 다운로드 사이트: |cff33ffcc%s|r", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "|cff33ffccpf|cffffffffUI|r에 |cff33ffcc오신걸 환영합니다.|r \n\n저는 몇 가지 기본 구성을 안내 할 첫 번째 실행 위자드입니다. 모든 단계를 건너 뛰고 싶으시면 \"기본값 사용\" 버튼을 누르십시오. 이 대화 상자를 다시 실행하려면 추후 설정으로 이동하여 \"첫단계로 재설정\" 버튼을 누르십시오.\n\n최신버전 다운로드 사이트: |cff33ffcc%s|r",
["Whitelist"] = nil, ["Whitelist"] = nil,
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = nil, ["Width"] = nil,
["Wobble Zoom"] = nil, ["Wobble Zoom"] = nil,
["Won"] = nil, ["Won"] = nil,
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["ruRU"] = { pfUI_translation["ruRU"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = "Сокращать числа (4200 -> 4.2k)", ["Abbreviate Numbers (4200 -> 4.2k)"] = "Сокращать числа (4200 -> 4.2k)",
["Abbreviate Unit Names"] = "Сокращать имена юнитов", ["Abbreviate Unit Names"] = "Сокращать имена юнитов",
@@ -6,6 +8,7 @@ pfUI_translation["ruRU"] = {
["Actionbar"] = "Панель действий", ["Actionbar"] = "Панель действий",
["Action Bar"] = "Панель действий", ["Action Bar"] = "Панель действий",
["Action Bar Border Size"] = "Размер границы панели действий", ["Action Bar Border Size"] = "Размер границы панели действий",
["Action Bars"] = nil,
["Active Addons"] = "Активные аддоны", ["Active Addons"] = "Активные аддоны",
["Add button to the frame"] = "Добавить кнопку в окно", ["Add button to the frame"] = "Добавить кнопку в окно",
["Added button"] = "Добавлена кнопка", ["Added button"] = "Добавлена кнопка",
@@ -27,12 +30,11 @@ pfUI_translation["ruRU"] = {
["Always Show Item Comparison"] = "Всегда показывать сравнение предметов", ["Always Show Item Comparison"] = "Всегда показывать сравнение предметов",
["Always Show On Target Units"] = "Всегда показывать над выбранной целью", ["Always Show On Target Units"] = "Всегда показывать над выбранной целью",
["Always Show On Units With Missing HP"] = "Всегда показывать над целями с неполным здоровьем", ["Always Show On Units With Missing HP"] = "Всегда показывать над целями с неполным здоровьем",
["Always Show Self In Raid Frames"] = "Всегда показывать себя в рейде",
["Always Use 2D Portraits"] = "Всегда использовать 2D-портреты",
["Ammo Counter"] = "Счетчик боеприпасов", ["Ammo Counter"] = "Счетчик боеприпасов",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Новая установка |cff33ffccpf|rUI предлагает 4 предварительно созданных профиля дизайна. Нажмите ниже, если вы хотите загрузить один из этих профилей.", ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "Новая установка |cff33ffccpf|rUI предлагает 4 предварительно созданных профиля дизайна. Нажмите ниже, если вы хотите загрузить один из этих профилей.",
["A new version is available"] = "Доступна новая версия", ["A new version is available"] = "Доступна новая версия",
["Animate Health And Power Bars"] = nil,
["Appearance"] = "Внешний вид", ["Appearance"] = "Внешний вид",
["Ascending"] = "По возрастанию", ["Ascending"] = "По возрастанию",
["Author"] = "Автор", ["Author"] = "Автор",
@@ -52,10 +54,12 @@ pfUI_translation["ruRU"] = {
["Auto Sell Grey Items"] = "Автоматическая продажа серых предметов", ["Auto Sell Grey Items"] = "Автоматическая продажа серых предметов",
["Average Per Hour"] = "Среднее за час", ["Average Per Hour"] = "Среднее за час",
["Background Color"] = "Цвет фона", ["Background Color"] = "Цвет фона",
["Bags"] = "Сумки",
["Bags & Bank"] = "Сумки & Банк", ["Bags & Bank"] = "Сумки & Банк",
["Bags Border Size"] = "Размер границы сумок", ["Bags Border Size"] = "Размер границы сумок",
["Bagslots Per Row"] = "Количество ячеек в сумке на строку", ["Bagslots Per Row"] = "Количество ячеек в сумке на строку",
["Bagspace"] = "Место в сумках", ["Bagspace"] = "Место в сумках",
["Bank"] = "Банк",
["Banker"] = "Банкир", ["Banker"] = "Банкир",
["Bankslots Per Row"] = "Количество ячеек в банке на строку", ["Bankslots Per Row"] = "Количество ячеек в банке на строку",
["Bar Background"] = "Фон панели", ["Bar Background"] = "Фон панели",
@@ -77,7 +81,7 @@ pfUI_translation["ruRU"] = {
["Buffbar Width"] = "Ширина панели баффов", ["Buffbar Width"] = "Ширина панели баффов",
["Buff/Debuff Icons"] = "Иконки баффов/дебаффов", ["Buff/Debuff Icons"] = "Иконки баффов/дебаффов",
["Buff/Debuff Indicators"] = "Индикаторы баффов/дебаффов", ["Buff/Debuff Indicators"] = "Индикаторы баффов/дебаффов",
["Buff Font Size"] = "Размер шрифта баффов", ["Buff Indicators"] = nil,
["Buff Limit"] = "Предел баффов", ["Buff Limit"] = "Предел баффов",
["Buff Position"] = "Расположение баффов", ["Buff Position"] = "Расположение баффов",
["Buffs"] = "Баффы", ["Buffs"] = "Баффы",
@@ -119,11 +123,16 @@ pfUI_translation["ruRU"] = {
["Chat Bubble Transparency"] = "Прозрачность пузыря чата", ["Chat Bubble Transparency"] = "Прозрачность пузыря чата",
["Chat Default Brackets"] = "Скобки чата", ["Chat Default Brackets"] = "Скобки чата",
["Class"] = "Класс", ["Class"] = "Класс",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = "Очистить броски", ["Clear Rolls"] = "Очистить броски",
["Click Action"] = "Действие при нажатии", ["Click Action"] = "Действие при нажатии",
["Click Casting"] = "Каст по нажатию", ["Click Casting"] = "Каст по нажатию",
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "Часы", ["Clock"] = "Часы",
["Close"] = "Закрыть", ["Close"] = "Закрыть",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = "Цвет стаков баффа", ["Color Buff Stacks"] = "Цвет стаков баффа",
["Color Debuff Stacks"] = "Цвет стаков дебаффа", ["Color Debuff Stacks"] = "Цвет стаков дебаффа",
@@ -143,21 +152,16 @@ pfUI_translation["ruRU"] = {
["Configuration"] = "Конфигурация", ["Configuration"] = "Конфигурация",
["Configure"] = "Применить", ["Configure"] = "Применить",
["Cooldown"] = "Восстановление", ["Cooldown"] = "Восстановление",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "Цвет восстановления (дни)", ["Cooldown Color (Days)"] = "Цвет восстановления (дни)",
["Cooldown Color (Hours)"] = "Цвет восстановления (часы)", ["Cooldown Color (Hours)"] = "Цвет восстановления (часы)",
["Cooldown Color (Less than 3 Sec)"] = "Цвет восстановления (менее 3 секунд)",
["Cooldown Color (Minutes)"] = "Цвет восстановления (минуты)", ["Cooldown Color (Minutes)"] = "Цвет восстановления (минуты)",
["Cooldown Color (Seconds)"] = "Цвет восстановления (секунды)", ["Cooldown Color (Seconds)"] = "Цвет восстановления (секунды)",
["Cooldown / Durations"] = "Восстановление / Длительность", ["Cooldown / Durations"] = "Восстановление / Длительность",
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = "Текст времени восстановления(CD)",
["Cooldown Text Font Size (Blizzard Frames)"] = "Текст времени восстановления (окна Blizzard)",
["Cooldown Text Font Size (Foreign Frames)"] = "Текст времени восстановления (Сторонние окна)",
["Cooldown Text Size"] = "Размер текста восстановления",
["Cooldown Text Threshold"] = "Текст порога восстановления", ["Cooldown Text Threshold"] = "Текст порога восстановления",
["Cooldown Text Time Threshold"] = "Порог текста восстановления",
["Coordinates Location"] = "Расположение координат", ["Coordinates Location"] = "Расположение координат",
["Coordinates On Minimap"] = "Координаты на миникарте", ["Coordinates On Minimap"] = "Координаты на миникарте",
["Copied to clipboard"] = nil,
["Count"] = "Счет", ["Count"] = "Счет",
["Create Profile"] = "Создать профиль", ["Create Profile"] = "Создать профиль",
["Ctrl-Click"] = "Ctrl+нажатие", ["Ctrl-Click"] = "Ctrl+нажатие",
@@ -198,7 +202,6 @@ pfUI_translation["ruRU"] = {
["Description Font"] = "Шрифт описания", ["Description Font"] = "Шрифт описания",
["Description Font Size"] = "Размер шрифта описания", ["Description Font Size"] = "Размер шрифта описания",
["Detailed Random Roll Announcement"] = "Подробное объявление о случайном броске", ["Detailed Random Roll Announcement"] = "Подробное объявление о случайном броске",
["Detect Enemy Buffs"] = nil,
["Disable"] = "Отключить", ["Disable"] = "Отключить",
["Disable Blizzard Castbar"] = "Отключить панель применения Blizzard", ["Disable Blizzard Castbar"] = "Отключить панель применения Blizzard",
["Disabled"] = "Отключено", ["Disabled"] = "Отключено",
@@ -275,12 +278,9 @@ pfUI_translation["ruRU"] = {
["Enable Custom Incoming Whispers Layout"] = "Включить пользовательский макет входящего шепота", ["Enable Custom Incoming Whispers Layout"] = "Включить пользовательский макет входящего шепота",
["Enable Debuff Display"] = "Включить отображение дебаффов", ["Enable Debuff Display"] = "Включить отображение дебаффов",
["Enable Debuffs"] = "Включить дебаффы", ["Enable Debuffs"] = "Включить дебаффы",
["Enable Durations On Blizzard Frames"] = "Включить длительность на окнах Blizzard",
["Enable Durations On Foreign Frames"] = "Включить длительность на сторонних окнах",
["Enable Energy Ticks"] = "Включить восполнение энергии", ["Enable Energy Ticks"] = "Включить восполнение энергии",
["Enable Extended Guild Information"] = "Включить расширенную информацию о гильдии", ["Enable Extended Guild Information"] = "Включить расширенную информацию о гильдии",
["Enable Frame Shadow"] = "Включить тень окон", ["Enable Frame Shadow"] = "Включить тень окон",
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = "Включить индикаторы", ["Enable Indicators"] = "Включить индикаторы",
["Enable Item Quality Color For Equipment Only"] = "Включить цвет качества предметов только для экипировки", ["Enable Item Quality Color For Equipment Only"] = "Включить цвет качества предметов только для экипировки",
["Enable \"Loot & Spam\" Chat Window"] = "Включить окно чата \"Добыча & Спам\"", ["Enable \"Loot & Spam\" Chat Window"] = "Включить окно чата \"Добыча & Спам\"",
@@ -290,7 +290,6 @@ pfUI_translation["ruRU"] = {
["Enable Mana Ticks"] = "Включить восполнение маны", ["Enable Mana Ticks"] = "Включить восполнение маны",
["Enable Micro Bar"] = "Включить панель микро меню", ["Enable Micro Bar"] = "Включить панель микро меню",
["Enable Mouselook With Right Click"] = "Включить нажатие правой кнопки мыши на индикаторе здоровья", ["Enable Mouselook With Right Click"] = "Включить нажатие правой кнопки мыши на индикаторе здоровья",
["Enable Mouseover Tooltip"] = "Включить подсказку при наведении мыши",
["Enable Movable Bags"] = "Включить подвижные сумки", ["Enable Movable Bags"] = "Включить подвижные сумки",
["Enable Offscreen Frame Positions"] = "Включить расположение окон за пределами экрана", ["Enable Offscreen Frame Positions"] = "Включить расположение окон за пределами экрана",
["Enable Overlap"] = "Включить перекрытие", ["Enable Overlap"] = "Включить перекрытие",
@@ -311,6 +310,7 @@ pfUI_translation["ruRU"] = {
["Encode"] = "Кодировать", ["Encode"] = "Кодировать",
["Ended"] = "Окончание", ["Ended"] = "Окончание",
["Energy Color"] = "Цвет энергии", ["Energy Color"] = "Цвет энергии",
["Equipped"] = "Экипировано",
["Equipped Item Color"] = "Цвет экипированных предметов", ["Equipped Item Color"] = "Цвет экипированных предметов",
["Estimate Debuffs"] = "Оценка дебафов", ["Estimate Debuffs"] = "Оценка дебафов",
["Estimate Enemy Health Points"] = "Оценка очков здоровья врага", ["Estimate Enemy Health Points"] = "Оценка очков здоровья врага",
@@ -335,6 +335,7 @@ pfUI_translation["ruRU"] = {
["Font"] = "Шрифт", ["Font"] = "Шрифт",
["Font Options"] = "Шрифт", ["Font Options"] = "Шрифт",
["Font Padding"] = "Отступ шрифта", ["Font Padding"] = "Отступ шрифта",
["Font Size"] = nil,
["Font Style"] = "Стиль шрифта", ["Font Style"] = "Стиль шрифта",
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = "Границы Blizzard принудительно (|cffffaaaaЭкспериментально|r)", ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = "Границы Blizzard принудительно (|cffffaaaaЭкспериментально|r)",
["fps"] = "кад./сек.", ["fps"] = "кад./сек.",
@@ -369,7 +370,6 @@ pfUI_translation["ruRU"] = {
["Health"] = "Здоровье", ["Health"] = "Здоровье",
["Health - Auto"] = "Здоровье - автоматически", ["Health - Auto"] = "Здоровье - автоматически",
["Healthbar"] = "Панель здоровья", ["Healthbar"] = "Панель здоровья",
["Healthbar Animation Speed"] = "Скорость анимации панели здоровья",
["Health Bar Color"] = "Цвет панели здоровья", ["Health Bar Color"] = "Цвет панели здоровья",
["Healthbar Embedded"] = "На панели здоровья", ["Healthbar Embedded"] = "На панели здоровья",
["Healthbar Height"] = "Высота панели здоровья", ["Healthbar Height"] = "Высота панели здоровья",
@@ -394,7 +394,6 @@ pfUI_translation["ruRU"] = {
["Hide Channel Names"] = "Скрыть названия каналов", ["Hide Channel Names"] = "Скрыть названия каналов",
["Hide Chat When Bags Are Opened"] = "Скрыть чат, когда сумки открыты", ["Hide Chat When Bags Are Opened"] = "Скрыть чат, когда сумки открыты",
["Hide Combat Log"] = "Скрыть журнал боя", ["Hide Combat Log"] = "Скрыть журнал боя",
["Hide Foreign Cooldown Animations"] = "Скрыть сторонние анимации перезарядки",
["Hide Group Frames While In Raid"] = "Скрыть окно группы, когда в рейде", ["Hide Group Frames While In Raid"] = "Скрыть окно группы, когда в рейде",
["Hide Healthbar On Critters"] = "Скрыть панель здоровья существ", ["Hide Healthbar On Critters"] = "Скрыть панель здоровья существ",
["Hide Healthbar On Enemy NPCs"] = "Скрыть панель здоровья вражеских NPC", ["Hide Healthbar On Enemy NPCs"] = "Скрыть панель здоровья вражеских NPC",
@@ -403,6 +402,7 @@ pfUI_translation["ruRU"] = {
["Hide Healthbar On Friendly Players"] = "Скрыть панель здоровья дружеских игроков", ["Hide Healthbar On Friendly Players"] = "Скрыть панель здоровья дружеских игроков",
["Hide Healthbar On Neutral NPCs"] = "Скрыть панель здоровья нейтральных NPC", ["Hide Healthbar On Neutral NPCs"] = "Скрыть панель здоровья нейтральных NPC",
["Hide Healthbar On Totems"] = "Скрыть панель здоровья тотемов", ["Hide Healthbar On Totems"] = "Скрыть панель здоровья тотемов",
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = "Время до скрытия", ["Hide Timeout"] = "Время до скрытия",
["Hide When Entering Combat"] = "Скрыть при вхождении в режим боя", ["Hide When Entering Combat"] = "Скрыть при вхождении в режим боя",
["Highlight Equipped Items"] = "Выделять экипированные предметы", ["Highlight Equipped Items"] = "Выделять экипированные предметы",
@@ -431,7 +431,6 @@ pfUI_translation["ruRU"] = {
["Inherit Default Colors"] = "Наследовать цвета по умолчанию", ["Inherit Default Colors"] = "Наследовать цвета по умолчанию",
["Inputbox Height"] = "Высота поля ввода", ["Inputbox Height"] = "Высота поля ввода",
["Inputbox Width"] = "Ширина поля ввода", ["Inputbox Width"] = "Ширина поля ввода",
["Instant"] = "Мгновенно",
["Integrations"] = "Встраиваемые", ["Integrations"] = "Встраиваемые",
["Invert Health Bar"] = "Инвертировать панель здоровья", ["Invert Health Bar"] = "Инвертировать панель здоровья",
["is not allowed in profile name"] = "не разрешено в имени профиля", ["is not allowed in profile name"] = "не разрешено в имени профиля",
@@ -476,6 +475,7 @@ pfUI_translation["ruRU"] = {
["Look & Feel"] = "Смотреть и чувствовать", ["Look & Feel"] = "Смотреть и чувствовать",
["Loot"] = "Добыча", ["Loot"] = "Добыча",
["Loot & Spam"] = "Добыча & Спам", ["Loot & Spam"] = "Добыча & Спам",
["Loss Of Control"] = nil,
["Macro Text Color"] = "Цвет текста макросов", ["Macro Text Color"] = "Цвет текста макросов",
["Macro Text Size"] = "Размер текста макросов", ["Macro Text Size"] = "Размер текста макросов",
["Main Actionbar"] = "Основная", ["Main Actionbar"] = "Основная",
@@ -515,6 +515,7 @@ pfUI_translation["ruRU"] = {
["Name | Health Missing"] = "Имя | Отсутствующее здоровье", ["Name | Health Missing"] = "Имя | Отсутствующее здоровье",
["Name (Linebreak) -Health Missing"] = "Имя (разрыв линии) -Отсутствует здоровье", ["Name (Linebreak) -Health Missing"] = "Имя (разрыв линии) -Отсутствует здоровье",
["Nameplate Border Size"] = "Размер границы индикатора здоровья", ["Nameplate Border Size"] = "Размер границы индикатора здоровья",
["Nameplate Debuffs"] = nil,
["Nameplates"] = "Индикаторы здоровья", ["Nameplates"] = "Индикаторы здоровья",
["Nameplate Width"] = "Ширина индикатора здоровья", ["Nameplate Width"] = "Ширина индикатора здоровья",
["Name (Short)"] = "Короткое имя", ["Name (Short)"] = "Короткое имя",
@@ -553,6 +554,7 @@ pfUI_translation["ruRU"] = {
["On State Change"] = "Изменение статуса", ["On State Change"] = "Изменение статуса",
["Options"] = "Опции", ["Options"] = "Опции",
["Orientation"] = "Ориентация", ["Orientation"] = "Ориентация",
["Other Addons"] = nil,
["Other Panel: Minimap"] = "Другая панель: миникарта", ["Other Panel: Minimap"] = "Другая панель: миникарта",
["Outline"] = "Контурный", -- font style ["Outline"] = "Контурный", -- font style
["Outlines"] = "Контуры", ["Outlines"] = "Контуры",
@@ -568,6 +570,7 @@ pfUI_translation["ruRU"] = {
["Overwrite If Unit Is Attacking Others"] = nil, ["Overwrite If Unit Is Attacking Others"] = nil,
["Overwrite If Unit Is Attacking You"] = nil, ["Overwrite If Unit Is Attacking You"] = nil,
["Overwrite If Unit Is Casting"] = nil, ["Overwrite If Unit Is Casting"] = nil,
["Owner Name"] = nil,
["Pageable"] = "Прокрутка страниц", ["Pageable"] = "Прокрутка страниц",
["Paging Actionbar"] = "Прокрутка панелей", ["Paging Actionbar"] = "Прокрутка панелей",
["Panel"] = "Панель", ["Panel"] = "Панель",
@@ -580,6 +583,7 @@ pfUI_translation["ruRU"] = {
["Pixel"] = "пиксель", ["Pixel"] = "пиксель",
["Player"] = "Игрок", ["Player"] = "Игрок",
["Player Buff Bar"] = "Панель баффов игрока", ["Player Buff Bar"] = "Панель баффов игрока",
["Player Buffs"] = nil,
["Player Castbar"] = "Панель применения игрока", ["Player Castbar"] = "Панель применения игрока",
["Player Debuff Bar"] = "Панель дебаффов игрока", ["Player Debuff Bar"] = "Панель дебаффов игрока",
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["ruRU"] = {
["Portrait Alpha"] = "Прозрачность портрета", ["Portrait Alpha"] = "Прозрачность портрета",
["Portrait Height"] = "Рост портрета", ["Portrait Height"] = "Рост портрета",
["Portrait Position"] = "Расположение портрета", ["Portrait Position"] = "Расположение портрета",
["Portrait Style"] = nil,
["Portrait Width"] = "Ширина портрета", ["Portrait Width"] = "Ширина портрета",
["Powerbar"] = "Панель силы (мана, ярость, энергия, фокус)", ["Powerbar"] = "Панель силы (мана, ярость, энергия, фокус)",
["Power Bar Anchor"] = "Привязка панели силы", ["Power Bar Anchor"] = "Привязка панели силы",
@@ -615,6 +620,7 @@ pfUI_translation["ruRU"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "Отступ рейда", ["Raid Padding"] = "Отступ рейда",
["Raid-Pet"] = nil,
["Random"] = "Случайно", ["Random"] = "Случайно",
["Random Roll Announcement Rarity"] = "Оповещение случайного броска для качества предмета", ["Random Roll Announcement Rarity"] = "Оповещение случайного броска для качества предмета",
["Random Rolling"] = "Случайный бросок костей для", ["Random Rolling"] = "Случайный бросок костей для",
@@ -644,6 +650,7 @@ pfUI_translation["ruRU"] = {
["Resting"] = "Отдыхающий", ["Resting"] = "Отдыхающий",
["Reveal Unexplored Areas"] = "Показывать неисследованные области", ["Reveal Unexplored Areas"] = "Показывать неисследованные области",
["Switch to current zone"] = "Перейти к текущей зоне", ["Switch to current zone"] = "Перейти к текущей зоне",
["Reverse Sweep On"] = nil,
["Right"] = "Справа", ["Right"] = "Справа",
["Right Actionbar"] = "Правая", ["Right Actionbar"] = "Правая",
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["ruRU"] = {
["Save & Reload"] = "Сохранить и перезагрузить", ["Save & Reload"] = "Сохранить и перезагрузить",
["Scale"] = "Масштаб", ["Scale"] = "Масштаб",
["Scale Border On HiDPI Displays"] = "Масштабировать границы на HiDPI мониторах", ["Scale Border On HiDPI Displays"] = "Масштабировать границы на HiDPI мониторах",
["Scale Font Size With Icon"] = nil,
["Scaling"] = "Масштаб интерфейса", ["Scaling"] = "Масштаб интерфейса",
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = "Интенсивность свечения на краях экрана", ["Screen Edge Glow Intensity"] = "Интенсивность свечения на краях экрана",
["Screen Resolution"] = "Разрешение экрана", ["Screen Resolution"] = "Разрешение экрана",
["Screenshot"] = "Снимок экрана", ["Screenshot"] = "Снимок экрана",
@@ -702,6 +709,7 @@ pfUI_translation["ruRU"] = {
["Show Description"] = "Показать описание", ["Show Description"] = "Показать описание",
["Show Dispel Indicators"] = "Показать индикаторы рассеивания", ["Show Dispel Indicators"] = "Показать индикаторы рассеивания",
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "Показать продолжительность внутри баффа", ["Show Duration Inside Buff"] = "Показать продолжительность внутри баффа",
["Show Empty Buttons"] = "Показать пустые кнопки", ["Show Empty Buttons"] = "Показать пустые кнопки",
["Show FPS and Latency Colors"] = "Показать частоту кадров и задержку в цвете", ["Show FPS and Latency Colors"] = "Показать частоту кадров и задержку в цвете",
@@ -724,7 +732,7 @@ pfUI_translation["ruRU"] = {
["Show Loot Icon"] = "Показать иконку добычи", ["Show Loot Icon"] = "Показать иконку добычи",
["Show Macro Text"] = "Показать текст макросов", ["Show Macro Text"] = "Показать текст макросов",
["Show Meters By Default"] = "Показать счетчики по умолчанию", ["Show Meters By Default"] = "Показать счетчики по умолчанию",
["Show Milliseconds When Timer Runs Out"] = "Показать миллисекунды, когда таймер заканчивается", ["Show Numbers On"] = nil,
["Show On Friendly Units"] = "Показать на дружественных юнитах", ["Show On Friendly Units"] = "Показать на дружественных юнитах",
["Show On Hostile Units"] = "Показать на вражеских юнитах", ["Show On Hostile Units"] = "Показать на вражеских юнитах",
["Show Procs Indicators"] = "Показать проки (Procs)", ["Show Procs Indicators"] = "Показать проки (Procs)",
@@ -738,13 +746,14 @@ pfUI_translation["ruRU"] = {
["Show Required Questitem Count"] = "Показать необходимое количество предметов для задания", ["Show Required Questitem Count"] = "Показать необходимое количество предметов для задания",
["Show Resting"] = "Показать иконку отдыха", ["Show Resting"] = "Показать иконку отдыха",
["Show Self In Group Frames"] = "Показать себя в окне группы", ["Show Self In Group Frames"] = "Показать себя в окне группы",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "Показать иконку заклинания", ["Show Spell Icon"] = "Показать иконку заклинания",
["Show Spell Name"] = "Показать название заклинания", ["Show Spell Name"] = "Показать название заклинания",
["Show Stacks"] = "Показать стаки", ["Show Stacks"] = "Показать стаки",
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = "Показать оставшееся время",
["Show Timer"] = "Показать таймер", ["Show Timer"] = "Показать таймер",
["Show Timer Animation"] = "Показать анимацию таймера",
["Show Timer Text"] = "Показать текст таймера", ["Show Timer Text"] = "Показать текст таймера",
["Show Totems Indicators"] = "Показать индикаторы тотемов", ["Show Totems Indicators"] = "Показать индикаторы тотемов",
["Shrink & Return"] = "Сжатие и возврат", ["Shrink & Return"] = "Сжатие и возврат",
@@ -761,8 +770,10 @@ pfUI_translation["ruRU"] = {
["Soulshards"] = "Камни душ", ["Soulshards"] = "Камни душ",
["Spacing"] = "Расстояние", ["Spacing"] = "Расстояние",
["Special Recipient"] = "Конкретный получатель", ["Special Recipient"] = "Конкретный получатель",
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = "Квадрат", ["Square"] = "Квадрат",
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = "Панель 1-ой стойки", ["Stance Bar 1"] = "Панель 1-ой стойки",
["Stance Bar 2"] = "Панель 2-ой стойки", ["Stance Bar 2"] = "Панель 2-ой стойки",
["Stance Bar 3"] = "Панель 3-ей стойки", ["Stance Bar 3"] = "Панель 3-ей стойки",
@@ -797,7 +808,6 @@ pfUI_translation["ruRU"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = "Точность подсчетов здоровья", ["Threshold To Trust Health Estimation"] = "Точность подсчетов здоровья",
["Time"] = "Время", ["Time"] = "Время",
["Timer"] = "Таймер",
["Time Remaining"] = "Время до нового уровня", ["Time Remaining"] = "Время до нового уровня",
["Timer In Minutes"] = "Таймер в минутах", ["Timer In Minutes"] = "Таймер в минутах",
["Timestamp Brackets"] = "Скобки отметок времени", ["Timestamp Brackets"] = "Скобки отметок времени",
@@ -808,6 +818,7 @@ pfUI_translation["ruRU"] = {
["Tiny (PixelPerfect)"] = "Крошечный (идеальный пиксель)", ["Tiny (PixelPerfect)"] = "Крошечный (идеальный пиксель)",
["Toggle as Tank"] = "Переключить как танк", ["Toggle as Tank"] = "Переключить как танк",
["Tooltip"] = "Подсказка", ["Tooltip"] = "Подсказка",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "Расположение подсказки", ["Tooltip Position"] = "Расположение подсказки",
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["ruRU"] = {
["Top Actionbar"] = "Верхняя", ["Top Actionbar"] = "Верхняя",
["Top Left"] = "Сверху слева", ["Top Left"] = "Сверху слева",
["Top Right"] = "Сверху справа", ["Top Right"] = "Сверху справа",
["Total"] = "Всего",
["Total Gold"] = "Всего золота", ["Total Gold"] = "Всего золота",
["Totem Direction"] = "Направление тотемов", ["Totem Direction"] = "Направление тотемов",
["Totem Icons"] = "Иконки тотемов", ["Totem Icons"] = "Иконки тотемов",
["Totems"] = nil,
["Tracked Reputation"] = "Отслеживаемая репутация", ["Tracked Reputation"] = "Отслеживаемая репутация",
["Tracking Icon Size"] = "Размер иконки отслеживания", ["Tracking Icon Size"] = "Размер иконки отслеживания",
["Trigger Actions On Key Down"] = "Активация действий при нажатии клавиши (а не ее отпускании)", ["Trigger Actions On Key Down"] = "Активация действий при нажатии клавиши (а не ее отпускании)",
["UI-Scale"] = "Масштаб пользовательского интерфейса", ["UI-Scale"] = "Масштаб пользовательского интерфейса",
["Unbuffed"] = "Без баффа", ["Unbuffed"] = "Без баффа",
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "Размер границы окна юнита", ["Unit Frame Border Size"] = "Размер границы окна юнита",
["Unit Frame Layout"] = "Макет окна юнита", ["Unit Frame Layout"] = "Макет окна юнита",
["Unit Frames"] = "Окна юнита", ["Unit Frames"] = "Окна юнита",
@@ -849,7 +863,6 @@ pfUI_translation["ruRU"] = {
["Use Custom Color Power Bar Background"] = "Использовать пользовательский цвет фона панели силы", ["Use Custom Color Power Bar Background"] = "Использовать пользовательский цвет фона панели силы",
["Use Custom Font Settings"] = "Использовать пользовательские настройки шрифта", ["Use Custom Font Settings"] = "Использовать пользовательские настройки шрифта",
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = "Использовать динамический размер шрифта",
["Use Item Rarity Color For Loot-Roll Timer"] = "Использовать цвет качества предмета для таймера распределения добычи", ["Use Item Rarity Color For Loot-Roll Timer"] = "Использовать цвет качества предмета для таймера распределения добычи",
["Use Original Game Fonts"] = "Использовать оригинальные игровые шрифты", ["Use Original Game Fonts"] = "Использовать оригинальные игровые шрифты",
["Use Raid Frames To Display Group Members"] = "Использовать окна рейда для отображения членов группы", ["Use Raid Frames To Display Group Members"] = "Использовать окна рейда для отображения членов группы",
@@ -867,7 +880,6 @@ pfUI_translation["ruRU"] = {
["Website"] = "Веб-сайт", ["Website"] = "Веб-сайт",
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "Добро пожаловать в |cff33ffccpf|cffffffffUI|r!\n\nЯ мастер первого запуска, который проведет вас через некоторую базовую конфигурацию. Если вы ленитесь, не стесняйтесь нажать кнопку \"По умолчанию\". Если вы хотите снова запустить этот диалог, перейдите к настройкам и нажмите кнопку \"Первый запуск\".\n\nПосетите |cff33ffcc%s|r, чтобы проверить последнюю версию.", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "Добро пожаловать в |cff33ffccpf|cffffffffUI|r!\n\nЯ мастер первого запуска, который проведет вас через некоторую базовую конфигурацию. Если вы ленитесь, не стесняйтесь нажать кнопку \"По умолчанию\". Если вы хотите снова запустить этот диалог, перейдите к настройкам и нажмите кнопку \"Первый запуск\".\n\nПосетите |cff33ffcc%s|r, чтобы проверить последнюю версию.",
["Whitelist"] = "\"Белый\" список", ["Whitelist"] = "\"Белый\" список",
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = "Ширина", ["Width"] = "Ширина",
["Wobble Zoom"] = "Подпрыгивание", ["Wobble Zoom"] = "Подпрыгивание",
["Won"] = "Победа", ["Won"] = "Победа",
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["zhCN"] = { pfUI_translation["zhCN"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = "3D世界单位字体", ["3D World Unit Font"] = "3D世界单位字体",
["Abbreviate Numbers (4200 -> 4.2k)"] = "缩写数字格式[4200为4.2K]", ["Abbreviate Numbers (4200 -> 4.2k)"] = "缩写数字格式[4200为4.2K]",
["Abbreviate Unit Names"] = "缩写单位名称", ["Abbreviate Unit Names"] = "缩写单位名称",
@@ -6,6 +8,7 @@ pfUI_translation["zhCN"] = {
["Actionbar"] = "动作条", ["Actionbar"] = "动作条",
["Action Bar"] = "动作条", ["Action Bar"] = "动作条",
["Action Bar Border Size"] = "动作条边框大小", ["Action Bar Border Size"] = "动作条边框大小",
["Action Bars"] = nil,
["Active Addons"] = "激活的插件", ["Active Addons"] = "激活的插件",
["Add button to the frame"] = "添加按钮到框架", ["Add button to the frame"] = "添加按钮到框架",
["Added button"] = "已添加按钮", ["Added button"] = "已添加按钮",
@@ -27,12 +30,11 @@ pfUI_translation["zhCN"] = {
["Always Show Item Comparison"] = "始终显示装备比较(或按SHIFT键)", ["Always Show Item Comparison"] = "始终显示装备比较(或按SHIFT键)",
["Always Show On Target Units"] = "始终在目标单位上显示", ["Always Show On Target Units"] = "始终在目标单位上显示",
["Always Show On Units With Missing HP"] = "始终在未满血单位上显示", ["Always Show On Units With Missing HP"] = "始终在未满血单位上显示",
["Always Show Self In Raid Frames"] = "始终在团队框架中显示自己",
["Always Use 2D Portraits"] = "始终使用2D头像",
["Ammo Counter"] = "弹药数量", ["Ammo Counter"] = "弹药数量",
["Anchor Bags Above Chat"] = "将背包锚定在聊天框上方", ["Anchor Bags Above Chat"] = "将背包锚定在聊天框上方",
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "pfUI的新安装自带4以下四种预设风格.点击下方可选择其一", ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "pfUI的新安装自带4以下四种预设风格.点击下方可选择其一",
["A new version is available"] = "发现新版本!", ["A new version is available"] = "发现新版本!",
["Animate Health And Power Bars"] = nil,
["Appearance"] = "外观设置", ["Appearance"] = "外观设置",
["Ascending"] = "上移", ["Ascending"] = "上移",
["Author"] = "作者", ["Author"] = "作者",
@@ -52,10 +54,12 @@ pfUI_translation["zhCN"] = {
["Auto Sell Grey Items"] = "自动贩卖灰色物品", ["Auto Sell Grey Items"] = "自动贩卖灰色物品",
["Average Per Hour"] = "平均每小时", ["Average Per Hour"] = "平均每小时",
["Background Color"] = "背景颜色", ["Background Color"] = "背景颜色",
["Bags"] = "背包",
["Bags & Bank"] = "背包和银行", ["Bags & Bank"] = "背包和银行",
["Bags Border Size"] = "背包边框大小", ["Bags Border Size"] = "背包边框大小",
["Bagslots Per Row"] = "每行包裹槽数量", ["Bagslots Per Row"] = "每行包裹槽数量",
["Bagspace"] = "背包空间", ["Bagspace"] = "背包空间",
["Bank"] = "银行",
["Banker"] = "工会银行角色", ["Banker"] = "工会银行角色",
["Bankslots Per Row"] = "每行银行槽数量", ["Bankslots Per Row"] = "每行银行槽数量",
["Bar Background"] = "动作条背景", ["Bar Background"] = "动作条背景",
@@ -77,7 +81,7 @@ pfUI_translation["zhCN"] = {
["Buffbar Width"] = "Buff条宽度", ["Buffbar Width"] = "Buff条宽度",
["Buff/Debuff Icons"] = "Buff/Debuff图标", ["Buff/Debuff Icons"] = "Buff/Debuff图标",
["Buff/Debuff Indicators"] = "Buff/Debuff指示器", ["Buff/Debuff Indicators"] = "Buff/Debuff指示器",
["Buff Font Size"] = "Buff字体大小", ["Buff Indicators"] = nil,
["Buff Limit"] = "Buff总数量", ["Buff Limit"] = "Buff总数量",
["Buff Position"] = "Buff显示的位置", ["Buff Position"] = "Buff显示的位置",
["Buffs"] = "Buff(增益)", ["Buffs"] = "Buff(增益)",
@@ -119,11 +123,16 @@ pfUI_translation["zhCN"] = {
["Chat Bubble Transparency"] = "聊天框气泡效果透明度", ["Chat Bubble Transparency"] = "聊天框气泡效果透明度",
["Chat Default Brackets"] = "聊天框默认括号", ["Chat Default Brackets"] = "聊天框默认括号",
["Class"] = "职业", ["Class"] = "职业",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = "清除Roll点", ["Clear Rolls"] = "清除Roll点",
["Click Action"] = "点击操作", ["Click Action"] = "点击操作",
["Click Casting"] = "点击施法", ["Click Casting"] = "点击施法",
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "时间", ["Clock"] = "时间",
["Close"] = "关闭", ["Close"] = "关闭",
["Collapse Empty Slots"] = nil,
["Color"] = "颜色", ["Color"] = "颜色",
["Color Buff Stacks"] = "Buff堆叠颜色", ["Color Buff Stacks"] = "Buff堆叠颜色",
["Color Debuff Stacks"] = "Debuff堆叠颜色", ["Color Debuff Stacks"] = "Debuff堆叠颜色",
@@ -143,21 +152,16 @@ pfUI_translation["zhCN"] = {
["Configuration"] = "配置", ["Configuration"] = "配置",
["Configure"] = "配置", ["Configure"] = "配置",
["Cooldown"] = "冷却时间", ["Cooldown"] = "冷却时间",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "技能冷却时间颜色[天]", ["Cooldown Color (Days)"] = "技能冷却时间颜色[天]",
["Cooldown Color (Hours)"] = "技能冷却时间颜色[时]", ["Cooldown Color (Hours)"] = "技能冷却时间颜色[时]",
["Cooldown Color (Less than 3 Sec)"] = "技能冷却时间颜色[少于3秒]",
["Cooldown Color (Minutes)"] = "技能冷却时间颜色[分]", ["Cooldown Color (Minutes)"] = "技能冷却时间颜色[分]",
["Cooldown Color (Seconds)"] = "技能冷却时间颜色[秒]", ["Cooldown Color (Seconds)"] = "技能冷却时间颜色[秒]",
["Cooldown / Durations"] = "冷却 / 时长", ["Cooldown / Durations"] = "冷却 / 时长",
["Cooldown Text Font"] = "Debuff计时字体",
["Cooldown Text Font Size"] = "Debuff计时文字大小",
["Cooldown Text Font Size (Blizzard Frames)"] = "Debuff计时文字大小(暴雪姓名板)",
["Cooldown Text Font Size (Foreign Frames)"] = "Debuff计时文字大小(插件姓名板)",
["Cooldown Text Size"] = "技能冷却文字大小",
["Cooldown Text Threshold"] = "冷却监控阈值(只监控大于该数值的技能)", ["Cooldown Text Threshold"] = "冷却监控阈值(只监控大于该数值的技能)",
["Cooldown Text Time Threshold"] = "技能冷却时间文字临界值",
["Coordinates Location"] = "坐标位置", ["Coordinates Location"] = "坐标位置",
["Coordinates On Minimap"] = "小地图上的坐标", ["Coordinates On Minimap"] = "小地图上的坐标",
["Copied to clipboard"] = nil,
["Count"] = "计数器", ["Count"] = "计数器",
["Create Profile"] = "新建配置", ["Create Profile"] = "新建配置",
["Ctrl-Click"] = "CTRL点击", ["Ctrl-Click"] = "CTRL点击",
@@ -198,7 +202,6 @@ pfUI_translation["zhCN"] = {
["Description Font"] = "描述字体", ["Description Font"] = "描述字体",
["Description Font Size"] = "描述字体大小", ["Description Font Size"] = "描述字体大小",
["Detailed Random Roll Announcement"] = "通告详细随机Roll点", ["Detailed Random Roll Announcement"] = "通告详细随机Roll点",
["Detect Enemy Buffs"] = "探测敌方Buffs",
["Disable"] = "禁用", ["Disable"] = "禁用",
["Disable Blizzard Castbar"] = "隐藏暴雪施法条", ["Disable Blizzard Castbar"] = "隐藏暴雪施法条",
["Disabled"] = "不显示", ["Disabled"] = "不显示",
@@ -275,12 +278,9 @@ pfUI_translation["zhCN"] = {
["Enable Custom Incoming Whispers Layout"] = "启用私聊样式", ["Enable Custom Incoming Whispers Layout"] = "启用私聊样式",
["Enable Debuff Display"] = "启用Debuff显示", ["Enable Debuff Display"] = "启用Debuff显示",
["Enable Debuffs"] = "显示Debuff", ["Enable Debuffs"] = "显示Debuff",
["Enable Durations On Blizzard Frames"] = "在暴雪栏显示冷却倒计时",
["Enable Durations On Foreign Frames"] = "在技能栏显示冷却倒计时",
["Enable Energy Ticks"] = "显示能量刻度", ["Enable Energy Ticks"] = "显示能量刻度",
["Enable Extended Guild Information"] = "公会信息扩展显示", ["Enable Extended Guild Information"] = "公会信息扩展显示",
["Enable Frame Shadow"] = "启用框架阴影", ["Enable Frame Shadow"] = "启用框架阴影",
["Enable Full-Text Search"] = "启用全文搜索",
["Enable Indicators"] = "启用指示器", ["Enable Indicators"] = "启用指示器",
["Enable Item Quality Color For Equipment Only"] = "仅在装备上显示品质颜色", ["Enable Item Quality Color For Equipment Only"] = "仅在装备上显示品质颜色",
["Enable \"Loot & Spam\" Chat Window"] = "启用[拾取、综合]聊天窗口", ["Enable \"Loot & Spam\" Chat Window"] = "启用[拾取、综合]聊天窗口",
@@ -290,7 +290,6 @@ pfUI_translation["zhCN"] = {
["Enable Mana Ticks"] = "显示法力值刻度", ["Enable Mana Ticks"] = "显示法力值刻度",
["Enable Micro Bar"] = "显示菜单栏", ["Enable Micro Bar"] = "显示菜单栏",
["Enable Mouselook With Right Click"] = "启动右键移动镜头", ["Enable Mouselook With Right Click"] = "启动右键移动镜头",
["Enable Mouseover Tooltip"] = "启用鼠标悬停工具提示",
["Enable Movable Bags"] = "启用可移动包裹", ["Enable Movable Bags"] = "启用可移动包裹",
["Enable Offscreen Frame Positions"] = "允许本插件所有框体移出屏幕边缘", ["Enable Offscreen Frame Positions"] = "允许本插件所有框体移出屏幕边缘",
["Enable Overlap"] = "叠加显示", ["Enable Overlap"] = "叠加显示",
@@ -311,6 +310,7 @@ pfUI_translation["zhCN"] = {
["Encode"] = "编码", ["Encode"] = "编码",
["Ended"] = "结束", ["Ended"] = "结束",
["Energy Color"] = "能量值颜色", ["Energy Color"] = "能量值颜色",
["Equipped"] = "已装备",
["Equipped Item Color"] = "已装备物品颜色", ["Equipped Item Color"] = "已装备物品颜色",
["Estimate Debuffs"] = "预估Debuffs", ["Estimate Debuffs"] = "预估Debuffs",
["Estimate Enemy Health Points"] = "预估敌人的生命值", ["Estimate Enemy Health Points"] = "预估敌人的生命值",
@@ -335,6 +335,7 @@ pfUI_translation["zhCN"] = {
["Font"] = "字体", ["Font"] = "字体",
["Font Options"] = "字体设置", ["Font Options"] = "字体设置",
["Font Padding"] = "字体偏移", ["Font Padding"] = "字体偏移",
["Font Size"] = nil,
["Font Style"] = "字体风格", ["Font Style"] = "字体风格",
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = "强制显示暴雪边框(|cffffaaaa测试功能|r)", ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = "强制显示暴雪边框(|cffffaaaa测试功能|r)",
["fps"] = "帧", ["fps"] = "帧",
@@ -369,7 +370,6 @@ pfUI_translation["zhCN"] = {
["Health"] = "生命值", ["Health"] = "生命值",
["Health - Auto"] = "动态生命值和百分比", ["Health - Auto"] = "动态生命值和百分比",
["Healthbar"] = "血条", ["Healthbar"] = "血条",
["Healthbar Animation Speed"] = "掉血动画速度",
["Health Bar Color"] = "血条颜色", ["Health Bar Color"] = "血条颜色",
["Healthbar Embedded"] = "血条上显示动态头像", ["Healthbar Embedded"] = "血条上显示动态头像",
["Healthbar Height"] = "血条高度", ["Healthbar Height"] = "血条高度",
@@ -394,7 +394,6 @@ pfUI_translation["zhCN"] = {
["Hide Channel Names"] = "隐藏频道名称", ["Hide Channel Names"] = "隐藏频道名称",
["Hide Chat When Bags Are Opened"] = "打开背包后隐藏聊天框", ["Hide Chat When Bags Are Opened"] = "打开背包后隐藏聊天框",
["Hide Combat Log"] = "隐藏战斗日志", ["Hide Combat Log"] = "隐藏战斗日志",
["Hide Foreign Cooldown Animations"] = "隐藏技能冷却动画",
["Hide Group Frames While In Raid"] = "在团队框架下隐藏小队框架", ["Hide Group Frames While In Raid"] = "在团队框架下隐藏小队框架",
["Hide Healthbar On Critters"] = "隐藏小动物血条", ["Hide Healthbar On Critters"] = "隐藏小动物血条",
["Hide Healthbar On Enemy NPCs"] = "隐藏敌方NPCs血条", ["Hide Healthbar On Enemy NPCs"] = "隐藏敌方NPCs血条",
@@ -403,6 +402,7 @@ pfUI_translation["zhCN"] = {
["Hide Healthbar On Friendly Players"] = "隐藏友好玩家血条", ["Hide Healthbar On Friendly Players"] = "隐藏友好玩家血条",
["Hide Healthbar On Neutral NPCs"] = "隐藏中立单位血条", ["Hide Healthbar On Neutral NPCs"] = "隐藏中立单位血条",
["Hide Healthbar On Totems"] = "隐藏图腾血条", ["Hide Healthbar On Totems"] = "隐藏图腾血条",
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = "超时隐藏", ["Hide Timeout"] = "超时隐藏",
["Hide When Entering Combat"] = "进入战斗时隐藏", ["Hide When Entering Combat"] = "进入战斗时隐藏",
["Highlight Equipped Items"] = "高亮已装备的物品", ["Highlight Equipped Items"] = "高亮已装备的物品",
@@ -431,7 +431,6 @@ pfUI_translation["zhCN"] = {
["Inherit Default Colors"] = "继承默认颜色", ["Inherit Default Colors"] = "继承默认颜色",
["Inputbox Height"] = "输入框高度", ["Inputbox Height"] = "输入框高度",
["Inputbox Width"] = "输入框宽度", ["Inputbox Width"] = "输入框宽度",
["Instant"] = "极快",
["Integrations"] = "整合", ["Integrations"] = "整合",
["Invert Health Bar"] = "血量反色显示", ["Invert Health Bar"] = "血量反色显示",
["is not allowed in profile name"] = "在配置文件名中不允许", ["is not allowed in profile name"] = "在配置文件名中不允许",
@@ -476,6 +475,7 @@ pfUI_translation["zhCN"] = {
["Look & Feel"] = "外观和风格", ["Look & Feel"] = "外观和风格",
["Loot"] = "拾取", ["Loot"] = "拾取",
["Loot & Spam"] = "拾取 & 聊天", ["Loot & Spam"] = "拾取 & 聊天",
["Loss Of Control"] = nil,
["Macro Text Color"] = "宏文本颜色", ["Macro Text Color"] = "宏文本颜色",
["Macro Text Size"] = "宏文本大小", ["Macro Text Size"] = "宏文本大小",
["Main Actionbar"] = "主动作条", ["Main Actionbar"] = "主动作条",
@@ -515,6 +515,7 @@ pfUI_translation["zhCN"] = {
["Name | Health Missing"] = "名字 | 失去的生命值", ["Name | Health Missing"] = "名字 | 失去的生命值",
["Name (Linebreak) -Health Missing"] = "名字 (换行符) -失去的生命值", ["Name (Linebreak) -Health Missing"] = "名字 (换行符) -失去的生命值",
["Nameplate Border Size"] = "姓名板边框尺寸", ["Nameplate Border Size"] = "姓名板边框尺寸",
["Nameplate Debuffs"] = nil,
["Nameplates"] = "姓名板", ["Nameplates"] = "姓名板",
["Nameplate Width"] = "姓名板宽度", ["Nameplate Width"] = "姓名板宽度",
["Name (Short)"] = "名字 (短)", ["Name (Short)"] = "名字 (短)",
@@ -553,6 +554,7 @@ pfUI_translation["zhCN"] = {
["On State Change"] = "状态改变时", ["On State Change"] = "状态改变时",
["Options"] = "设置", ["Options"] = "设置",
["Orientation"] = "方向", ["Orientation"] = "方向",
["Other Addons"] = nil,
["Other Panel: Minimap"] = "小地图面板", ["Other Panel: Minimap"] = "小地图面板",
["Outline"] = "轮廓", ["Outline"] = "轮廓",
["Outlines"] = "轮廓线", ["Outlines"] = "轮廓线",
@@ -568,6 +570,7 @@ pfUI_translation["zhCN"] = {
["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻击其它单位则变色", ["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻击其它单位则变色",
["Overwrite If Unit Is Attacking You"] = "如果单位正在攻击你则变色", ["Overwrite If Unit Is Attacking You"] = "如果单位正在攻击你则变色",
["Overwrite If Unit Is Casting"] = "如果单位正在施法则变色", ["Overwrite If Unit Is Casting"] = "如果单位正在施法则变色",
["Owner Name"] = nil,
["Pageable"] = "可分页", ["Pageable"] = "可分页",
["Paging Actionbar"] = "分页动作条", ["Paging Actionbar"] = "分页动作条",
["Panel"] = "面板", ["Panel"] = "面板",
@@ -580,6 +583,7 @@ pfUI_translation["zhCN"] = {
["Pixel"] = "像素", ["Pixel"] = "像素",
["Player"] = "玩家", ["Player"] = "玩家",
["Player Buff Bar"] = "玩家Buffs条", ["Player Buff Bar"] = "玩家Buffs条",
["Player Buffs"] = nil,
["Player Castbar"] = "玩家施法条", ["Player Castbar"] = "玩家施法条",
["Player Debuff Bar"] = "玩家Debuffs条", ["Player Debuff Bar"] = "玩家Debuffs条",
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["zhCN"] = {
["Portrait Alpha"] = "人偶透明度", ["Portrait Alpha"] = "人偶透明度",
["Portrait Height"] = "纵向高度", ["Portrait Height"] = "纵向高度",
["Portrait Position"] = "人偶头像位置", ["Portrait Position"] = "人偶头像位置",
["Portrait Style"] = nil,
["Portrait Width"] = "纵向宽度", ["Portrait Width"] = "纵向宽度",
["Powerbar"] = "能量(蓝)条", ["Powerbar"] = "能量(蓝)条",
["Power Bar Anchor"] = "能量条对齐方式(以血条为锚点)", ["Power Bar Anchor"] = "能量条对齐方式(以血条为锚点)",
@@ -615,6 +620,7 @@ pfUI_translation["zhCN"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = "团队填充", ["Raid Padding"] = "团队填充",
["Raid-Pet"] = nil,
["Random"] = "给随机玩家", ["Random"] = "给随机玩家",
["Random Roll Announcement Rarity"] = "随机Roll点稀有度", ["Random Roll Announcement Rarity"] = "随机Roll点稀有度",
["Random Rolling"] = "随机Roll点 物品:", ["Random Rolling"] = "随机Roll点 物品:",
@@ -644,6 +650,7 @@ pfUI_translation["zhCN"] = {
["Resting"] = "休息中", ["Resting"] = "休息中",
["Reveal Unexplored Areas"] = "展示未勘探的地区", ["Reveal Unexplored Areas"] = "展示未勘探的地区",
["Switch to current zone"] = nil, ["Switch to current zone"] = nil,
["Reverse Sweep On"] = nil,
["Right"] = "右边", ["Right"] = "右边",
["Right Actionbar"] = "右侧动作条", ["Right Actionbar"] = "右侧动作条",
["Right Anchor"] = "右锚点", ["Right Anchor"] = "右锚点",
@@ -665,8 +672,8 @@ pfUI_translation["zhCN"] = {
["Save & Reload"] = "保存并重载", ["Save & Reload"] = "保存并重载",
["Scale"] = "比例", ["Scale"] = "比例",
["Scale Border On HiDPI Displays"] = "缩放高DPI显示器上的边框", ["Scale Border On HiDPI Displays"] = "缩放高DPI显示器上的边框",
["Scale Font Size With Icon"] = nil,
["Scaling"] = "UI缩放", ["Scaling"] = "UI缩放",
["Scan Macros For Spells"] = "扫描宏命令中的法术",
["Screen Edge Glow Intensity"] = "屏幕边缘发光强度", ["Screen Edge Glow Intensity"] = "屏幕边缘发光强度",
["Screen Resolution"] = "屏幕分辨率", ["Screen Resolution"] = "屏幕分辨率",
["Screenshot"] = "屏幕截图", ["Screenshot"] = "屏幕截图",
@@ -702,6 +709,7 @@ pfUI_translation["zhCN"] = {
["Show Description"] = "显示描述", ["Show Description"] = "显示描述",
["Show Dispel Indicators"] = "显示驱散指示器", ["Show Dispel Indicators"] = "显示驱散指示器",
["Show Druid Mana Bar"] = "显示德鲁伊法力条", ["Show Druid Mana Bar"] = "显示德鲁伊法力条",
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "显示持续时间在Buff里面", ["Show Duration Inside Buff"] = "显示持续时间在Buff里面",
["Show Empty Buttons"] = "显示空按钮", ["Show Empty Buttons"] = "显示空按钮",
["Show FPS and Latency Colors"] = "显示帧数以及延迟颜色", ["Show FPS and Latency Colors"] = "显示帧数以及延迟颜色",
@@ -725,7 +733,7 @@ pfUI_translation["zhCN"] = {
["Show Loot Icon"] = "显示拾取权图标", ["Show Loot Icon"] = "显示拾取权图标",
["Show Macro Text"] = "显示宏的名字", ["Show Macro Text"] = "显示宏的名字",
["Show Meters By Default"] = "由默认显示其他接口表", ["Show Meters By Default"] = "由默认显示其他接口表",
["Show Milliseconds When Timer Runs Out"] = "当冷却即将结束时显示毫秒", ["Show Numbers On"] = nil,
["Show On Friendly Units"] = "显示友好单位姓名板", ["Show On Friendly Units"] = "显示友好单位姓名板",
["Show On Hostile Units"] = "显示敌对单位姓名板", ["Show On Hostile Units"] = "显示敌对单位姓名板",
["Show Procs Indicators"] = "显示触发效果计时器", ["Show Procs Indicators"] = "显示触发效果计时器",
@@ -739,13 +747,14 @@ pfUI_translation["zhCN"] = {
["Show Required Questitem Count"] = "显示所需的任务物品计数", ["Show Required Questitem Count"] = "显示所需的任务物品计数",
["Show Resting"] = "显示休息图标", ["Show Resting"] = "显示休息图标",
["Show Self In Group Frames"] = "在队伍框架中显示自己", ["Show Self In Group Frames"] = "在队伍框架中显示自己",
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = "显示技能图标", ["Show Spell Icon"] = "显示技能图标",
["Show Spell Name"] = "显示技能名称", ["Show Spell Name"] = "显示技能名称",
["Show Stacks"] = "显示堆叠", ["Show Stacks"] = "显示堆叠",
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = "显示文本", ["Show Text"] = "显示文本",
["Show Time Left"] = "显示剩余时间",
["Show Timer"] = "显示计时器", ["Show Timer"] = "显示计时器",
["Show Timer Animation"] = "显示计时器动画",
["Show Timer Text"] = "显示计时器文本", ["Show Timer Text"] = "显示计时器文本",
["Show Totems Indicators"] = "显示图腾指示器", ["Show Totems Indicators"] = "显示图腾指示器",
["Shrink & Return"] = "收缩 & 返回", ["Shrink & Return"] = "收缩 & 返回",
@@ -762,8 +771,10 @@ pfUI_translation["zhCN"] = {
["Soulshards"] = "灵魂碎片", ["Soulshards"] = "灵魂碎片",
["Spacing"] = "间距", ["Spacing"] = "间距",
["Special Recipient"] = "特殊指定角色", ["Special Recipient"] = "特殊指定角色",
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = "方块", ["Square"] = "方块",
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = "姿态动作条 1", ["Stance Bar 1"] = "姿态动作条 1",
["Stance Bar 2"] = "姿态动作条 2", ["Stance Bar 2"] = "姿态动作条 2",
["Stance Bar 3"] = "姿态动作条 3", ["Stance Bar 3"] = "姿态动作条 3",
@@ -798,7 +809,6 @@ pfUI_translation["zhCN"] = {
["Thistle Tea"] = "菊花茶", ["Thistle Tea"] = "菊花茶",
["Threshold To Trust Health Estimation"] = "信任生命值预估的阈值", ["Threshold To Trust Health Estimation"] = "信任生命值预估的阈值",
["Time"] = "时间", ["Time"] = "时间",
["Timer"] = "计时器",
["Time Remaining"] = "剩余时间", ["Time Remaining"] = "剩余时间",
["Timer In Minutes"] = "计时器(分钟)", ["Timer In Minutes"] = "计时器(分钟)",
["Timestamp Brackets"] = "时间戳括弧", ["Timestamp Brackets"] = "时间戳括弧",
@@ -809,6 +819,7 @@ pfUI_translation["zhCN"] = {
["Tiny (PixelPerfect)"] = "极小(像素完美)", ["Tiny (PixelPerfect)"] = "极小(像素完美)",
["Toggle as Tank"] = "切换成为坦克", ["Toggle as Tank"] = "切换成为坦克",
["Tooltip"] = "信息提示框", ["Tooltip"] = "信息提示框",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "信息提示框位置", ["Tooltip Position"] = "信息提示框位置",
["Tooltip Text Font"] = "鼠标提示框字体", ["Tooltip Text Font"] = "鼠标提示框字体",
["Tooltip Text Font Size"] ="鼠标提示框字体大小", ["Tooltip Text Font Size"] ="鼠标提示框字体大小",
@@ -816,14 +827,17 @@ pfUI_translation["zhCN"] = {
["Top Actionbar"] = "上方动作条", ["Top Actionbar"] = "上方动作条",
["Top Left"] = "左上方", ["Top Left"] = "左上方",
["Top Right"] = "右上方", ["Top Right"] = "右上方",
["Total"] = "总计",
["Total Gold"] = "总黄金", ["Total Gold"] = "总黄金",
["Totem Direction"] = "图腾方向", ["Totem Direction"] = "图腾方向",
["Totem Icons"] = "图腾图标", ["Totem Icons"] = "图腾图标",
["Totems"] = nil,
["Tracked Reputation"] = "被追踪的声望", ["Tracked Reputation"] = "被追踪的声望",
["Tracking Icon Size"] = "追踪图标大小", ["Tracking Icon Size"] = "追踪图标大小",
["Trigger Actions On Key Down"] = "按下即施法", ["Trigger Actions On Key Down"] = "按下即施法",
["UI-Scale"] = "UI缩放比例", ["UI-Scale"] = "UI缩放比例",
["Unbuffed"] = "该Buff缺失者", ["Unbuffed"] = "该Buff缺失者",
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "头像边框大小", ["Unit Frame Border Size"] = "头像边框大小",
["Unit Frame Layout"] = "头像框架样式", ["Unit Frame Layout"] = "头像框架样式",
["Unit Frames"] = "头像框架", ["Unit Frames"] = "头像框架",
@@ -850,7 +864,6 @@ pfUI_translation["zhCN"] = {
["Use Custom Color Power Bar Background"] = "使用自定义颜色显示能量值背景", ["Use Custom Color Power Bar Background"] = "使用自定义颜色显示能量值背景",
["Use Custom Font Settings"] = "使用自定义字体设置", ["Use Custom Font Settings"] = "使用自定义字体设置",
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = "使用动态字体大小",
["Use Item Rarity Color For Loot-Roll Timer"] = "为战利品Roll点计时框启用物品稀有颜色", ["Use Item Rarity Color For Loot-Roll Timer"] = "为战利品Roll点计时框启用物品稀有颜色",
["Use Original Game Fonts"] = "使用游戏原始字体", ["Use Original Game Fonts"] = "使用游戏原始字体",
["Use Raid Frames To Display Group Members"] = '使用团队框架显示小组成员', ["Use Raid Frames To Display Group Members"] = '使用团队框架显示小组成员',
@@ -868,7 +881,6 @@ pfUI_translation["zhCN"] = {
["Website"] = "网站", ["Website"] = "网站",
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "欢迎使用 |cff33ffccpf|cffffffffUI|r! \n\n这是第一次运行向导,将引导您完成一些基本配置。 如果你想跳过所有步骤\"使用默认\"按钮。 如果您再次运行此对话框,请转到设置并点击 \"Reset Firstrun\" 按钮。\n\n访问 |cff33ffcc%s|r 检查最新版本。", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "欢迎使用 |cff33ffccpf|cffffffffUI|r! \n\n这是第一次运行向导,将引导您完成一些基本配置。 如果你想跳过所有步骤\"使用默认\"按钮。 如果您再次运行此对话框,请转到设置并点击 \"Reset Firstrun\" 按钮。\n\n访问 |cff33ffcc%s|r 检查最新版本。",
["Whitelist"] = "白名单", ["Whitelist"] = "白名单",
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = "宽度", ["Width"] = "宽度",
["Wobble Zoom"] = "摆动变焦", ["Wobble Zoom"] = "摆动变焦",
["Won"] = "获胜", ["Won"] = "获胜",
+37 -25
View File
@@ -1,4 +1,6 @@
pfUI_translation["zhTW"] = { pfUI_translation["zhTW"] = {
["2D"] = nil,
["3D"] = nil,
["3D World Unit Font"] = nil, ["3D World Unit Font"] = nil,
["Abbreviate Numbers (4200 -> 4.2k)"] = "縮寫數位格式[4200為4.2K]", ["Abbreviate Numbers (4200 -> 4.2k)"] = "縮寫數位格式[4200為4.2K]",
["Abbreviate Unit Names"] = nil, ["Abbreviate Unit Names"] = nil,
@@ -6,6 +8,7 @@ pfUI_translation["zhTW"] = {
["Actionbar"] = "動作條", ["Actionbar"] = "動作條",
["Action Bar"] = nil, ["Action Bar"] = nil,
["Action Bar Border Size"] = "動作條邊框大小", ["Action Bar Border Size"] = "動作條邊框大小",
["Action Bars"] = nil,
["Active Addons"] = "啟動的外掛程式", ["Active Addons"] = "啟動的外掛程式",
["Add button to the frame"] = nil, ["Add button to the frame"] = nil,
["Added button"] = nil, ["Added button"] = nil,
@@ -27,12 +30,11 @@ pfUI_translation["zhTW"] = {
["Always Show Item Comparison"] = "始終顯示裝備比較", ["Always Show Item Comparison"] = "始終顯示裝備比較",
["Always Show On Target Units"] = nil, ["Always Show On Target Units"] = nil,
["Always Show On Units With Missing HP"] = nil, ["Always Show On Units With Missing HP"] = nil,
["Always Show Self In Raid Frames"] = nil,
["Always Use 2D Portraits"] = "始終使用2D頭像",
["Ammo Counter"] = "彈藥數量", ["Ammo Counter"] = "彈藥數量",
["Anchor Bags Above Chat"] = nil, ["Anchor Bags Above Chat"] = nil,
["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "pfUI的安裝內建有四種風格.點選以下讀取其一", ["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."] = "pfUI的安裝內建有四種風格.點選以下讀取其一",
["A new version is available"] = nil, ["A new version is available"] = nil,
["Animate Health And Power Bars"] = nil,
["Appearance"] = "外觀設置", ["Appearance"] = "外觀設置",
["Ascending"] = "下移", ["Ascending"] = "下移",
["Author"] = nil, ["Author"] = nil,
@@ -52,10 +54,12 @@ pfUI_translation["zhTW"] = {
["Auto Sell Grey Items"] = "自動販賣灰色物品", ["Auto Sell Grey Items"] = "自動販賣灰色物品",
["Average Per Hour"] = "平均每小時", ["Average Per Hour"] = "平均每小時",
["Background Color"] = "背景顏色", ["Background Color"] = "背景顏色",
["Bags"] = "背包",
["Bags & Bank"] = "背包和銀行", ["Bags & Bank"] = "背包和銀行",
["Bags Border Size"] = "背包邊框大小", ["Bags Border Size"] = "背包邊框大小",
["Bagslots Per Row"] = "每行包裹槽數量", ["Bagslots Per Row"] = "每行包裹槽數量",
["Bagspace"] = "背包空間", ["Bagspace"] = "背包空間",
["Bank"] = "銀行",
["Banker"] = "工會銀行角色", ["Banker"] = "工會銀行角色",
["Bankslots Per Row"] = "每行銀行槽數量", ["Bankslots Per Row"] = "每行銀行槽數量",
["Bar Background"] = nil, ["Bar Background"] = nil,
@@ -77,7 +81,7 @@ pfUI_translation["zhTW"] = {
["Buffbar Width"] = "Buff寬度", ["Buffbar Width"] = "Buff寬度",
["Buff/Debuff Icons"] = nil, ["Buff/Debuff Icons"] = nil,
["Buff/Debuff Indicators"] = nil, ["Buff/Debuff Indicators"] = nil,
["Buff Font Size"] = "Buff字體大小", ["Buff Indicators"] = nil,
["Buff Limit"] = "Buff總數量", ["Buff Limit"] = "Buff總數量",
["Buff Position"] = "Buff顯示的位置", ["Buff Position"] = "Buff顯示的位置",
["Buffs"] = "Buff(增益)", ["Buffs"] = "Buff(增益)",
@@ -119,11 +123,16 @@ pfUI_translation["zhTW"] = {
["Chat Bubble Transparency"] = "聊天框氣泡效果透明度", ["Chat Bubble Transparency"] = "聊天框氣泡效果透明度",
["Chat Default Brackets"] = "聊天框默認括弧", ["Chat Default Brackets"] = "聊天框默認括弧",
["Class"] = "職業", ["Class"] = "職業",
["Class Icon (Round)"] = nil,
["Class Icon (Square)"] = nil,
["Clear Rolls"] = "清除Roll點", ["Clear Rolls"] = "清除Roll點",
["Click Action"] = "點擊操作", ["Click Action"] = "點擊操作",
["Click Casting"] = nil, ["Click Casting"] = nil,
["Click to undress"] = nil,
["Undress"] = nil,
["Clock"] = "時間", ["Clock"] = "時間",
["Close"] = "關閉", ["Close"] = "關閉",
["Collapse Empty Slots"] = nil,
["Color"] = nil, ["Color"] = nil,
["Color Buff Stacks"] = nil, ["Color Buff Stacks"] = nil,
["Color Debuff Stacks"] = nil, ["Color Debuff Stacks"] = nil,
@@ -143,21 +152,16 @@ pfUI_translation["zhTW"] = {
["Configuration"] = "配置", ["Configuration"] = "配置",
["Configure"] = "設置", ["Configure"] = "設置",
["Cooldown"] = "冷卻時間", ["Cooldown"] = "冷卻時間",
["Cooldown Color (5 Seconds Or Less)"] = nil,
["Cooldown Color (Days)"] = "技能冷卻時間顏色[天]", ["Cooldown Color (Days)"] = "技能冷卻時間顏色[天]",
["Cooldown Color (Hours)"] = "技能冷卻時間顏色[時]", ["Cooldown Color (Hours)"] = "技能冷卻時間顏色[時]",
["Cooldown Color (Less than 3 Sec)"] = "技能冷卻時間顏色[少於3秒]",
["Cooldown Color (Minutes)"] = "技能冷卻時間顏色[分]", ["Cooldown Color (Minutes)"] = "技能冷卻時間顏色[分]",
["Cooldown Color (Seconds)"] = "技能冷卻時間顏色[秒]", ["Cooldown Color (Seconds)"] = "技能冷卻時間顏色[秒]",
["Cooldown / Durations"] = nil, ["Cooldown / Durations"] = nil,
["Cooldown Text Font"] = nil,
["Cooldown Text Font Size"] = "技能冷卻時間文字大小",
["Cooldown Text Font Size (Blizzard Frames)"] = nil,
["Cooldown Text Font Size (Foreign Frames)"] = nil,
["Cooldown Text Size"] = nil,
["Cooldown Text Threshold"] = nil, ["Cooldown Text Threshold"] = nil,
["Cooldown Text Time Threshold"] = "技能冷卻時間文字臨界值",
["Coordinates Location"] = "座標位置", ["Coordinates Location"] = "座標位置",
["Coordinates On Minimap"] = "小地圖上的座標", ["Coordinates On Minimap"] = "小地圖上的座標",
["Copied to clipboard"] = nil,
["Count"] = "計數器", ["Count"] = "計數器",
["Create Profile"] = "新建配置", ["Create Profile"] = "新建配置",
["Ctrl-Click"] = "CTRL點擊", ["Ctrl-Click"] = "CTRL點擊",
@@ -198,7 +202,6 @@ pfUI_translation["zhTW"] = {
["Description Font"] = nil, ["Description Font"] = nil,
["Description Font Size"] = nil, ["Description Font Size"] = nil,
["Detailed Random Roll Announcement"] = "通告詳細隨機Roll點", ["Detailed Random Roll Announcement"] = "通告詳細隨機Roll點",
["Detect Enemy Buffs"] = nil,
["Disable"] = "禁用", ["Disable"] = "禁用",
["Disable Blizzard Castbar"] = "隱藏暴雪施法條", ["Disable Blizzard Castbar"] = "隱藏暴雪施法條",
["Disabled"] = "不顯示", ["Disabled"] = "不顯示",
@@ -275,12 +278,9 @@ pfUI_translation["zhTW"] = {
["Enable Custom Incoming Whispers Layout"] = "啟用私聊樣式", ["Enable Custom Incoming Whispers Layout"] = "啟用私聊樣式",
["Enable Debuff Display"] = "啟用Debuff顯示", ["Enable Debuff Display"] = "啟用Debuff顯示",
["Enable Debuffs"] = "顯示Debuff", ["Enable Debuffs"] = "顯示Debuff",
["Enable Durations On Blizzard Frames"] = "啟用持續時間在暴雪框架上",
["Enable Durations On Foreign Frames"] = "啟用持續時間在外來框架上",
["Enable Energy Ticks"] = "顯示能量刻度", ["Enable Energy Ticks"] = "顯示能量刻度",
["Enable Extended Guild Information"] = "公會資訊擴展顯示", ["Enable Extended Guild Information"] = "公會資訊擴展顯示",
["Enable Frame Shadow"] = "啟用框架陰影", ["Enable Frame Shadow"] = "啟用框架陰影",
["Enable Full-Text Search"] = nil,
["Enable Indicators"] = nil, ["Enable Indicators"] = nil,
["Enable Item Quality Color For Equipment Only"] = "僅在裝備上顯示品質顏色", ["Enable Item Quality Color For Equipment Only"] = "僅在裝備上顯示品質顏色",
["Enable \"Loot & Spam\" Chat Window"] = "啟用[拾取、綜合]聊天視窗", ["Enable \"Loot & Spam\" Chat Window"] = "啟用[拾取、綜合]聊天視窗",
@@ -290,7 +290,6 @@ pfUI_translation["zhTW"] = {
["Enable Mana Ticks"] = nil, ["Enable Mana Ticks"] = nil,
["Enable Micro Bar"] = "顯示功能表列", ["Enable Micro Bar"] = "顯示功能表列",
["Enable Mouselook With Right Click"] = "啟動右鍵移動鏡頭", ["Enable Mouselook With Right Click"] = "啟動右鍵移動鏡頭",
["Enable Mouseover Tooltip"] = "啟用滑鼠懸停工具提示",
["Enable Movable Bags"] = "啟用可移動包裹", ["Enable Movable Bags"] = "啟用可移動包裹",
["Enable Offscreen Frame Positions"] = "啟用螢幕框架固定", ["Enable Offscreen Frame Positions"] = "啟用螢幕框架固定",
["Enable Overlap"] = "疊加顯示", ["Enable Overlap"] = "疊加顯示",
@@ -311,6 +310,7 @@ pfUI_translation["zhTW"] = {
["Encode"] = "編碼", ["Encode"] = "編碼",
["Ended"] = nil, ["Ended"] = nil,
["Energy Color"] = nil, ["Energy Color"] = nil,
["Equipped"] = "已裝備",
["Equipped Item Color"] = nil, ["Equipped Item Color"] = nil,
["Estimate Debuffs"] = nil, ["Estimate Debuffs"] = nil,
["Estimate Enemy Health Points"] = nil, ["Estimate Enemy Health Points"] = nil,
@@ -335,6 +335,7 @@ pfUI_translation["zhTW"] = {
["Font"] = nil, ["Font"] = nil,
["Font Options"] = nil, ["Font Options"] = nil,
["Font Padding"] = nil, ["Font Padding"] = nil,
["Font Size"] = nil,
["Font Style"] = nil, ["Font Style"] = nil,
["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil, ["Force Blizzard Borders (|cffffaaaaExperimental|r)"] = nil,
["fps"] = "幀", ["fps"] = "幀",
@@ -369,7 +370,6 @@ pfUI_translation["zhTW"] = {
["Health"] = nil, ["Health"] = nil,
["Health - Auto"] = "動態生命值和百分比", ["Health - Auto"] = "動態生命值和百分比",
["Healthbar"] = "生命條", ["Healthbar"] = "生命條",
["Healthbar Animation Speed"] = "掉血動畫速度",
["Health Bar Color"] = nil, ["Health Bar Color"] = nil,
["Healthbar Embedded"] = "血條上顯示動態頭像", ["Healthbar Embedded"] = "血條上顯示動態頭像",
["Healthbar Height"] = "生命條高度", ["Healthbar Height"] = "生命條高度",
@@ -394,7 +394,6 @@ pfUI_translation["zhTW"] = {
["Hide Channel Names"] = "隱藏頻道名稱", ["Hide Channel Names"] = "隱藏頻道名稱",
["Hide Chat When Bags Are Opened"] = "打開背包後隱藏聊天框", ["Hide Chat When Bags Are Opened"] = "打開背包後隱藏聊天框",
["Hide Combat Log"] = "隱藏戰鬥日誌", ["Hide Combat Log"] = "隱藏戰鬥日誌",
["Hide Foreign Cooldown Animations"] = nil,
["Hide Group Frames While In Raid"] = "在團隊框架下隱藏小隊框架", ["Hide Group Frames While In Raid"] = "在團隊框架下隱藏小隊框架",
["Hide Healthbar On Critters"] = nil, ["Hide Healthbar On Critters"] = nil,
["Hide Healthbar On Enemy NPCs"] = nil, ["Hide Healthbar On Enemy NPCs"] = nil,
@@ -403,6 +402,7 @@ pfUI_translation["zhTW"] = {
["Hide Healthbar On Friendly Players"] = nil, ["Hide Healthbar On Friendly Players"] = nil,
["Hide Healthbar On Neutral NPCs"] = nil, ["Hide Healthbar On Neutral NPCs"] = nil,
["Hide Healthbar On Totems"] = nil, ["Hide Healthbar On Totems"] = nil,
["Hide Numbers On Spell Cooldowns Up To (Seconds)"] = nil,
["Hide Timeout"] = nil, ["Hide Timeout"] = nil,
["Hide When Entering Combat"] = nil, ["Hide When Entering Combat"] = nil,
["Highlight Equipped Items"] = nil, ["Highlight Equipped Items"] = nil,
@@ -431,7 +431,6 @@ pfUI_translation["zhTW"] = {
["Inherit Default Colors"] = nil, ["Inherit Default Colors"] = nil,
["Inputbox Height"] = "輸入框高度", ["Inputbox Height"] = "輸入框高度",
["Inputbox Width"] = "輸入框寬度", ["Inputbox Width"] = "輸入框寬度",
["Instant"] = "極快",
["Integrations"] = nil, ["Integrations"] = nil,
["Invert Health Bar"] = "血量反色顯示", ["Invert Health Bar"] = "血量反色顯示",
["is not allowed in profile name"] = "在設定檔名中不允許", ["is not allowed in profile name"] = "在設定檔名中不允許",
@@ -476,6 +475,7 @@ pfUI_translation["zhTW"] = {
["Look & Feel"] = nil, ["Look & Feel"] = nil,
["Loot"] = "拾取", ["Loot"] = "拾取",
["Loot & Spam"] = "拾取 & 聊天", ["Loot & Spam"] = "拾取 & 聊天",
["Loss Of Control"] = nil,
["Macro Text Color"] = nil, ["Macro Text Color"] = nil,
["Macro Text Size"] = nil, ["Macro Text Size"] = nil,
["Main Actionbar"] = nil, ["Main Actionbar"] = nil,
@@ -515,6 +515,7 @@ pfUI_translation["zhTW"] = {
["Name | Health Missing"] = nil, ["Name | Health Missing"] = nil,
["Name (Linebreak) -Health Missing"] = nil, ["Name (Linebreak) -Health Missing"] = nil,
["Nameplate Border Size"] = nil, ["Nameplate Border Size"] = nil,
["Nameplate Debuffs"] = nil,
["Nameplates"] = "姓名板", ["Nameplates"] = "姓名板",
["Nameplate Width"] = "姓名板高度", ["Nameplate Width"] = "姓名板高度",
["Name (Short)"] = "名字 (短)", ["Name (Short)"] = "名字 (短)",
@@ -553,6 +554,7 @@ pfUI_translation["zhTW"] = {
["On State Change"] = nil, ["On State Change"] = nil,
["Options"] = nil, ["Options"] = nil,
["Orientation"] = nil, ["Orientation"] = nil,
["Other Addons"] = nil,
["Other Panel: Minimap"] = "小地圖面板", ["Other Panel: Minimap"] = "小地圖面板",
["Outline"] = nil, ["Outline"] = nil,
["Outlines"] = nil, ["Outlines"] = nil,
@@ -568,6 +570,7 @@ pfUI_translation["zhTW"] = {
["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻擊其它单位則覆蓋", ["Overwrite If Unit Is Attacking Others"] = "如果单位正在攻擊其它单位則覆蓋",
["Overwrite If Unit Is Attacking You"] = "如果单位正在攻擊你則覆蓋", ["Overwrite If Unit Is Attacking You"] = "如果单位正在攻擊你則覆蓋",
["Overwrite If Unit Is Casting"] = "如果单位正在施法則覆蓋", ["Overwrite If Unit Is Casting"] = "如果单位正在施法則覆蓋",
["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
["Panel"] = "面板", ["Panel"] = "面板",
@@ -580,6 +583,7 @@ pfUI_translation["zhTW"] = {
["Pixel"] = nil, ["Pixel"] = nil,
["Player"] = "玩家", ["Player"] = "玩家",
["Player Buff Bar"] = nil, ["Player Buff Bar"] = nil,
["Player Buffs"] = nil,
["Player Castbar"] = nil, ["Player Castbar"] = nil,
["Player Debuff Bar"] = nil, ["Player Debuff Bar"] = nil,
["Player SP/Haste Display"] = nil, ["Player SP/Haste Display"] = nil,
@@ -590,6 +594,7 @@ pfUI_translation["zhTW"] = {
["Portrait Alpha"] = "人偶透明度", ["Portrait Alpha"] = "人偶透明度",
["Portrait Height"] = "纵向高度", ["Portrait Height"] = "纵向高度",
["Portrait Position"] = "人偶頭像位置", ["Portrait Position"] = "人偶頭像位置",
["Portrait Style"] = nil,
["Portrait Width"] = "纵向宽度", ["Portrait Width"] = "纵向宽度",
["Powerbar"] = "能量(藍)條", ["Powerbar"] = "能量(藍)條",
["Power Bar Anchor"] = "能量條對齊方式(以血條為錨點)", ["Power Bar Anchor"] = "能量條對齊方式(以血條為錨點)",
@@ -615,6 +620,7 @@ pfUI_translation["zhTW"] = {
["Raid Mark X-Offset"] = nil, ["Raid Mark X-Offset"] = nil,
["Raid Mark Y-Offset"] = nil, ["Raid Mark Y-Offset"] = nil,
["Raid Padding"] = nil, ["Raid Padding"] = nil,
["Raid-Pet"] = nil,
["Random"] = "給隨機玩家", ["Random"] = "給隨機玩家",
["Random Roll Announcement Rarity"] = "隨機Roll點公示稀有度", ["Random Roll Announcement Rarity"] = "隨機Roll點公示稀有度",
["Random Rolling"] = "隨機Roll點 物品:", ["Random Rolling"] = "隨機Roll點 物品:",
@@ -644,6 +650,7 @@ pfUI_translation["zhTW"] = {
["Resting"] = "休息中", ["Resting"] = "休息中",
["Reveal Unexplored Areas"] = "展示未勘探的地區", ["Reveal Unexplored Areas"] = "展示未勘探的地區",
["Switch to current zone"] = nil, ["Switch to current zone"] = nil,
["Reverse Sweep On"] = nil,
["Right"] = "右邊", ["Right"] = "右邊",
["Right Actionbar"] = nil, ["Right Actionbar"] = nil,
["Right Anchor"] = nil, ["Right Anchor"] = nil,
@@ -665,8 +672,8 @@ pfUI_translation["zhTW"] = {
["Save & Reload"] = nil, ["Save & Reload"] = nil,
["Scale"] = "比例", ["Scale"] = "比例",
["Scale Border On HiDPI Displays"] = nil, ["Scale Border On HiDPI Displays"] = nil,
["Scale Font Size With Icon"] = nil,
["Scaling"] = nil, ["Scaling"] = nil,
["Scan Macros For Spells"] = nil,
["Screen Edge Glow Intensity"] = nil, ["Screen Edge Glow Intensity"] = nil,
["Screen Resolution"] = "螢幕解析度", ["Screen Resolution"] = "螢幕解析度",
["Screenshot"] = nil, ["Screenshot"] = nil,
@@ -702,6 +709,7 @@ pfUI_translation["zhTW"] = {
["Show Description"] = nil, ["Show Description"] = nil,
["Show Dispel Indicators"] = nil, ["Show Dispel Indicators"] = nil,
["Show Druid Mana Bar"] = nil, ["Show Druid Mana Bar"] = nil,
["Show Druid Mana Bar Text"] = nil,
["Show Duration Inside Buff"] = "顯示持續時間在Buff裏面", ["Show Duration Inside Buff"] = "顯示持續時間在Buff裏面",
["Show Empty Buttons"] = nil, ["Show Empty Buttons"] = nil,
["Show FPS and Latency Colors"] = nil, ["Show FPS and Latency Colors"] = nil,
@@ -724,7 +732,7 @@ pfUI_translation["zhTW"] = {
["Show Loot Icon"] = nil, ["Show Loot Icon"] = nil,
["Show Macro Text"] = "顯示巨集的名字", ["Show Macro Text"] = "顯示巨集的名字",
["Show Meters By Default"] = "由默認顯示其他介面表", ["Show Meters By Default"] = "由默認顯示其他介面表",
["Show Milliseconds When Timer Runs Out"] = nil, ["Show Numbers On"] = nil,
["Show On Friendly Units"] = nil, ["Show On Friendly Units"] = nil,
["Show On Hostile Units"] = nil, ["Show On Hostile Units"] = nil,
["Show Procs Indicators"] = nil, ["Show Procs Indicators"] = nil,
@@ -738,13 +746,14 @@ pfUI_translation["zhTW"] = {
["Show Required Questitem Count"] = nil, ["Show Required Questitem Count"] = nil,
["Show Resting"] = nil, ["Show Resting"] = nil,
["Show Self In Group Frames"] = nil, ["Show Self In Group Frames"] = nil,
["Show Self In Raid Frames When Solo"] = nil,
["Show Spell Icon"] = nil, ["Show Spell Icon"] = nil,
["Show Spell Name"] = nil, ["Show Spell Name"] = nil,
["Show Stacks"] = nil, ["Show Stacks"] = nil,
["Show Sweep On"] = nil,
["Show Tenths Below 5 Seconds"] = nil,
["Show Text"] = nil, ["Show Text"] = nil,
["Show Time Left"] = nil,
["Show Timer"] = nil, ["Show Timer"] = nil,
["Show Timer Animation"] = nil,
["Show Timer Text"] = nil, ["Show Timer Text"] = nil,
["Show Totems Indicators"] = nil, ["Show Totems Indicators"] = nil,
["Shrink & Return"] = nil, ["Shrink & Return"] = nil,
@@ -761,8 +770,10 @@ pfUI_translation["zhTW"] = {
["Soulshards"] = "靈魂碎片", ["Soulshards"] = "靈魂碎片",
["Spacing"] = nil, ["Spacing"] = nil,
["Special Recipient"] = "特殊指定角色", ["Special Recipient"] = "特殊指定角色",
["Spellbook And Character"] = nil,
["Spell Power Color"] = nil, ["Spell Power Color"] = nil,
["Square"] = "方形", ["Square"] = "方形",
["Stack Count Font Size"] = nil,
["Stance Bar 1"] = nil, ["Stance Bar 1"] = nil,
["Stance Bar 2"] = nil, ["Stance Bar 2"] = nil,
["Stance Bar 3"] = nil, ["Stance Bar 3"] = nil,
@@ -797,7 +808,6 @@ pfUI_translation["zhTW"] = {
["Thistle Tea"] = nil, ["Thistle Tea"] = nil,
["Threshold To Trust Health Estimation"] = nil, ["Threshold To Trust Health Estimation"] = nil,
["Time"] = "計時器", ["Time"] = "計時器",
["Timer"] = nil,
["Time Remaining"] = "剩餘時間", ["Time Remaining"] = "剩餘時間",
["Timer In Minutes"] = nil, ["Timer In Minutes"] = nil,
["Timestamp Brackets"] = "時間戳括弧", ["Timestamp Brackets"] = "時間戳括弧",
@@ -808,6 +818,7 @@ pfUI_translation["zhTW"] = {
["Tiny (PixelPerfect)"] = "極小(像素完美)", ["Tiny (PixelPerfect)"] = "極小(像素完美)",
["Toggle as Tank"] = "切換成為坦克", ["Toggle as Tank"] = "切換成為坦克",
["Tooltip"] = "滑鼠提示框", ["Tooltip"] = "滑鼠提示框",
["Tooltip Auras"] = nil,
["Tooltip Position"] = "滑鼠提示框位置", ["Tooltip Position"] = "滑鼠提示框位置",
["Tooltip Text Font"] = nil, ["Tooltip Text Font"] = nil,
["Tooltip Text Font Size"] = nil, ["Tooltip Text Font Size"] = nil,
@@ -815,14 +826,17 @@ pfUI_translation["zhTW"] = {
["Top Actionbar"] = nil, ["Top Actionbar"] = nil,
["Top Left"] = "左上方", ["Top Left"] = "左上方",
["Top Right"] = "右上方", ["Top Right"] = "右上方",
["Total"] = "全部",
["Total Gold"] = "總金量", ["Total Gold"] = "總金量",
["Totem Direction"] = nil, ["Totem Direction"] = nil,
["Totem Icons"] = nil, ["Totem Icons"] = nil,
["Totems"] = nil,
["Tracked Reputation"] = nil, ["Tracked Reputation"] = nil,
["Tracking Icon Size"] = "追蹤圖示大小", ["Tracking Icon Size"] = "追蹤圖示大小",
["Trigger Actions On Key Down"] = nil, ["Trigger Actions On Key Down"] = nil,
["UI-Scale"] = "UI縮放比例", ["UI-Scale"] = "UI縮放比例",
["Unbuffed"] = "該Buff缺失者", ["Unbuffed"] = "該Buff缺失者",
["Unit Frame Auras"] = nil,
["Unit Frame Border Size"] = "頭像邊框大小", ["Unit Frame Border Size"] = "頭像邊框大小",
["Unit Frame Layout"] = "頭像框架樣式", ["Unit Frame Layout"] = "頭像框架樣式",
["Unit Frames"] = "頭像框架", ["Unit Frames"] = "頭像框架",
@@ -849,7 +863,6 @@ pfUI_translation["zhTW"] = {
["Use Custom Color Power Bar Background"] = nil, ["Use Custom Color Power Bar Background"] = nil,
["Use Custom Font Settings"] = nil, ["Use Custom Font Settings"] = nil,
["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil, ["Use Custom Spell Power Color (unchecked = biggest school color)"] = nil,
["Use Dynamic Font Size"] = nil,
["Use Item Rarity Color For Loot-Roll Timer"] = "為戰利品Roll點計時框啟用物品稀有顏色", ["Use Item Rarity Color For Loot-Roll Timer"] = "為戰利品Roll點計時框啟用物品稀有顏色",
["Use Original Game Fonts"] = nil, ["Use Original Game Fonts"] = nil,
["Use Raid Frames To Display Group Members"] = '使用團隊框架顯示小組成員', ["Use Raid Frames To Display Group Members"] = '使用團隊框架顯示小組成員',
@@ -867,7 +880,6 @@ pfUI_translation["zhTW"] = {
["Website"] = nil, ["Website"] = nil,
["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "歡迎使用 |cff33ffccpf|cffffffffUI|r! \n\n這是第一次運行嚮導,將引導您完成一些基本配置。 如果你想跳過所有步驟\"使用預設\"按鈕。 如果您再次運行此對話方塊,請轉到設置並點擊 \"Reset Firstrun\" 按鈕。\n\n訪問 |cff33ffcc%s|r 檢查最新版本。", ["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."] = "歡迎使用 |cff33ffccpf|cffffffffUI|r! \n\n這是第一次運行嚮導,將引導您完成一些基本配置。 如果你想跳過所有步驟\"使用預設\"按鈕。 如果您再次運行此對話方塊,請轉到設置並點擊 \"Reset Firstrun\" 按鈕。\n\n訪問 |cff33ffcc%s|r 檢查最新版本。",
["Whitelist"] = "白名單", ["Whitelist"] = "白名單",
["Who Search Unknown Classes (|cffffaaaaExperimental|r)"] = nil,
["Width"] = nil, ["Width"] = nil,
["Wobble Zoom"] = nil, ["Wobble Zoom"] = nil,
["Won"] = nil, ["Won"] = nil,
+2
View File
@@ -1,6 +1,8 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\api\api.lua"/> <Include file="..\api\api.lua"/>
<Include file="..\api\cooldown.lua"/>
<Include file="..\api\config.lua"/> <Include file="..\api\config.lua"/>
<Include file="..\api\ui-widgets.lua"/> <Include file="..\api\ui-widgets.lua"/>
<Include file="..\api\ui-widgets.xml"/>
<Include file="..\api\unitframes.lua"/> <Include file="..\api\unitframes.lua"/>
</Ui> </Ui>
-9
View File
@@ -1,13 +1,4 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\env\locales_enUS.lua"/>
<Include file="..\env\locales_koKR.lua"/>
<Include file="..\env\locales_frFR.lua"/>
<Include file="..\env\locales_deDE.lua"/>
<Include file="..\env\locales_zhCN.lua"/>
<Include file="..\env\locales_esES.lua"/>
<Include file="..\env\locales_ruRU.lua"/>
<Include file="..\env\tables.lua"/>
<Include file="..\env\profiles.lua"/> <Include file="..\env\profiles.lua"/>
<Include file="..\env\translations_enUS.lua"/> <Include file="..\env\translations_enUS.lua"/>
-2
View File
@@ -1,8 +1,6 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\libs\libtipscan.lua"/>
<Include file="..\libs\libspell.lua"/> <Include file="..\libs\libspell.lua"/>
<Include file="..\libs\libdebuff.lua"/> <Include file="..\libs\libdebuff.lua"/>
<Include file="..\libs\librange.lua"/>
<Include file="..\libs\libunitscan.lua"/> <Include file="..\libs\libunitscan.lua"/>
<Include file="..\libs\libhealth.lua"/> <Include file="..\libs\libhealth.lua"/>
<Include file="..\libs\libthrottle.lua"/> <Include file="..\libs\libthrottle.lua"/>
+6 -3
View File
@@ -7,6 +7,8 @@
<Include file="..\modules\gryphons.lua"/> <Include file="..\modules\gryphons.lua"/>
<Include file="..\modules\hunterbar.lua"/> <Include file="..\modules\hunterbar.lua"/>
<Include file="..\modules\chat.lua"/> <Include file="..\modules\chat.lua"/>
<Include file="..\modules\combatlog.lua"/>
<Include file="..\modules\combatlog_config.lua"/>
<Include file="..\modules\whisperproxy.lua"/> <Include file="..\modules\whisperproxy.lua"/>
<Include file="..\modules\chatcopy.lua"/> <Include file="..\modules\chatcopy.lua"/>
<Include file="..\modules\bubbles.lua"/> <Include file="..\modules\bubbles.lua"/>
@@ -32,7 +34,6 @@
<Include file="..\modules\autovendor.lua"/> <Include file="..\modules\autovendor.lua"/>
<Include file="..\modules\bags.lua"/> <Include file="..\modules\bags.lua"/>
<Include file="..\modules\itemclick.lua"/> <Include file="..\modules\itemclick.lua"/>
<Include file="..\modules\cooldown.lua"/>
<Include file="..\modules\tooltip.lua"/> <Include file="..\modules\tooltip.lua"/>
<Include file="..\modules\questitem.lua"/> <Include file="..\modules\questitem.lua"/>
<Include file="..\modules\thirdparty.lua"/> <Include file="..\modules\thirdparty.lua"/>
@@ -70,8 +71,7 @@
<Include file="..\modules\addoncompat.lua"/> <Include file="..\modules\addoncompat.lua"/>
<Include file="..\modules\energytick.lua"/> <Include file="..\modules\energytick.lua"/>
<Include file="..\modules\totems.lua"/> <Include file="..\modules\totems.lua"/>
<Include file="..\modules\macrotweak.lua"/> <Include file="..\modules\macroicons.lua"/>
<Include file="..\modules\turtle-wow.lua"/>
<Include file="..\modules\superwow.lua"/> <Include file="..\modules\superwow.lua"/>
<Include file="..\modules\innervatecall.lua"/> <Include file="..\modules\innervatecall.lua"/>
<Include file="..\modules\nampower.lua"/> <Include file="..\modules\nampower.lua"/>
@@ -80,4 +80,7 @@
<Include file="..\modules\equipmentmanager.lua"/> <Include file="..\modules\equipmentmanager.lua"/>
<Include file="..\modules\loothistory.lua"/> <Include file="..\modules\loothistory.lua"/>
<Include file="..\modules\newitem.lua"/> <Include file="..\modules\newitem.lua"/>
<Include file="..\modules\friendnotes.lua"/>
<Include file="..\modules\lossofcontrol.lua"/>
<Include file="..\modules\radar.lua"/>
</Ui> </Ui>
+2 -9
View File
@@ -30,19 +30,12 @@
<Include file="..\skins\blizzard\options-sound.lua"/> <Include file="..\skins\blizzard\options-sound.lua"/>
<Include file="..\skins\blizzard\options-video.lua"/> <Include file="..\skins\blizzard\options-video.lua"/>
<Include file="..\skins\blizzard\options-new.lua"/> <Include file="..\skins\blizzard\options-new.lua"/>
<Include file="..\skins\blizzard\options-interface.lua"/>
<Include file="..\skins\blizzard\petition.lua"/> <Include file="..\skins\blizzard\petition.lua"/>
<Include file="..\skins\blizzard\taxi.lua"/> <Include file="..\skins\blizzard\taxi.lua"/>
<Include file="..\skins\blizzard\tooltips.lua"/> <Include file="..\skins\blizzard\tooltips.lua"/>
<Include file="..\skins\blizzard\tabard.lua"/> <Include file="..\skins\blizzard\tabard.lua"/>
<Include file="..\skins\blizzard\itemtext.lua"/> <Include file="..\skins\blizzard\itemtext.lua"/>
<Include file="..\skins\blizzard\lft.lua"/>
<Include file="..\skins\blizzard\turtle_shop.lua"/>
<!-- Turtle WoW -->
<Include file="..\skins\blizzard\barbershop.lua"/>
<Include file="..\skins\blizzard\transmog.lua"/>
<Include file="..\skins\blizzard\custom_merchant.lua"/>
<Include file="..\skins\blizzard\arena_score.lua"/>
<Include file="..\skins\blizzard\ebc.lua"/>
<!-- Turtle WoW skins live in init\turtle.xml (pfUI_Turtle.toc only). -->
</Ui> </Ui>
+1 -1
View File
@@ -1,3 +1,3 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/"> <Ui xmlns="http://www.blizzard.com/wow/ui/">
<Include file="..\compat\vanilla.lua"/> <Include file="..\env\tables_stock.lua"/>
</Ui> </Ui>
+14
View File
@@ -0,0 +1,14 @@
<Ui xmlns="http://www.blizzard.com/wow/ui/">
<!-- Turtle WoW only: pulled in by pfUI_Turtle.toc, which ClassicAPI selects
when it detects a Turtle client. Everything in here targets frames that
only a Turtle client ever creates. -->
<Include file="..\env\tables_turtle.lua"/>
<Include file="..\skins\blizzard\lft.lua"/>
<Include file="..\skins\blizzard\turtle_shop.lua"/>
<Include file="..\skins\blizzard\barbershop.lua"/>
<Include file="..\skins\blizzard\transmog.lua"/>
<Include file="..\skins\blizzard\ebc.lua"/>
<Include file="..\modules\turtle-wow.lua"/>
</Ui>
+76 -19
View File
@@ -18,12 +18,7 @@ local ItemQuality = Enum.ItemQuality
local function SortCategoryPrefix(itemId, classID, quality) local function SortCategoryPrefix(itemId, classID, quality)
if itemId == HEARTHSTONE_ITEM_ID then return "00" end if itemId == HEARTHSTONE_ITEM_ID then return "00" end
if quality == ItemQuality.Poor then return "13" end -- gray always last if quality == ItemQuality.Poor then return "13" end -- gray always last
if classID == ItemClass.Weapon or classID == ItemClass.Armor then if classID == ItemClass.Weapon or classID == ItemClass.Armor then return "01" end
if quality and quality >= ItemQuality.Epic then return "01" end -- Epic+ gear
if quality == ItemQuality.Rare then return "02" end -- Rare gear
if quality == ItemQuality.Uncommon then return "03" end -- Uncommon gear
return "04" -- Common/poor gear
end
if classID == ItemClass.Consumable then return "05" end if classID == ItemClass.Consumable then return "05" end
if classID == ItemClass.Reagent then return "06" end if classID == ItemClass.Reagent then return "06" end
if classID == ItemClass.Tradegoods then return "07" end if classID == ItemClass.Tradegoods then return "07" end
@@ -42,21 +37,59 @@ local function SortCountSuffix(count)
return string.sub(s, -6) return string.sub(s, -6)
end end
local function SortKey(itemId, name, classID, subClassID, quality, count) -- Gear's slot order, keyed by the equipLoc token (INVTYPE_*). Not the
-- Zero-pad the class/subclass so the secondary grouping sorts numerically -- token's alphabetical order, which puts chest before head, and not its
-- (as a string, "10" would otherwise precede "2"). -- INVTYPE number, which parts robe (20) from chest (5). Same order as
return SortCategoryPrefix(itemId, classID, quality) -- ClassicAPI's C_Container.SortBags, taken from Baganator: weapons by hand,
.. string.format("%02d|%02d|", classID or 99, subClassID or 99) -- ranged and ammo, then armor with shields and off-hands first, head to
.. (name or "zzz") .. "|" .. SortCountSuffix(count) -- feet, then jewelry, shirt and tabard.
local SLOT_ORDER = {
"INVTYPE_2HWEAPON", "INVTYPE_WEAPON", "INVTYPE_WEAPONMAINHAND",
"INVTYPE_SHIELD", "INVTYPE_HOLDABLE", "INVTYPE_RANGEDRIGHT",
"INVTYPE_WEAPONOFFHAND", "INVTYPE_RANGED", "INVTYPE_THROWN",
"INVTYPE_AMMO", "INVTYPE_QUIVER", "INVTYPE_RELIC",
"INVTYPE_HEAD", "INVTYPE_SHOULDER", "INVTYPE_CLOAK", "INVTYPE_CHEST",
"INVTYPE_ROBE", "INVTYPE_WRIST", "INVTYPE_HAND", "INVTYPE_WAIST",
"INVTYPE_LEGS", "INVTYPE_FEET",
"INVTYPE_NECK", "INVTYPE_FINGER", "INVTYPE_TRINKET", "INVTYPE_BODY",
"INVTYPE_TABARD", "INVTYPE_BAG",
}
local SLOT_RANK = {}
for i, token in ipairs(SLOT_ORDER) do SLOT_RANK[token] = i end
local function SortKey(itemId, name, classID, subClassID, quality, count, equipLoc)
-- Zero-pad the numeric fields so they sort numerically as strings ("10"
-- would otherwise precede "2").
local key = SortCategoryPrefix(itemId, classID, quality)
.. string.format("%02d|", classID or 99)
if classID == ItemClass.Weapon or classID == ItemClass.Armor then
-- Gear: slot, then subtype, then best quality first, so all helms sit
-- together, then all shoulders.
key = key .. string.format("%02d|%02d|%d|",
SLOT_RANK[equipLoc] or 99, subClassID or 99, 9 - (quality or 0))
else
key = key .. string.format("%02d|", subClassID or 99)
end
return key .. (name or "zzz") .. "|" .. SortCountSuffix(count)
end end
local function ClearSortData() local function ClearSortData()
libbagsort.itemGrid = {} libbagsort.itemGrid = {}
libbagsort.bagList = nil libbagsort.bagList = nil
libbagsort.opts = nil
libbagsort:UnregisterEvent("BAG_UPDATE_DELAYED") libbagsort:UnregisterEvent("BAG_UPDATE_DELAYED")
libbagsort:SetScript("OnEvent", nil) libbagsort:SetScript("OnEvent", nil)
end end
local function ReverseArray(t)
local i, j = 1, table.getn(t)
while i < j do
t[i], t[j] = t[j], t[i]
i = i + 1
j = j - 1
end
end
-- Two-pointer consolidation: sorts stacks largest-first, then merges from -- Two-pointer consolidation: sorts stacks largest-first, then merges from
-- both ends toward the middle. n is set explicitly so table.getn / table.sort -- both ends toward the middle. n is set explicitly so table.getn / table.sort
-- work correctly in Lua 5.0. -- work correctly in Lua 5.0.
@@ -158,10 +191,10 @@ local function BuildSortGrid()
-- sit at positions 12/13. We categorize on those numeric class IDs -- sit at positions 12/13. We categorize on those numeric class IDs
-- rather than the localized itemType/itemSubType strings. (pfUI's -- rather than the localized itemType/itemSubType strings. (pfUI's
-- shimmed global GetItemInfo is only 10 fields and lacks them.) -- shimmed global GetItemInfo is only 10 fields and lacks them.)
local name, _, quality, _, _, _, _, _, _, _, _, classID, subClassID = C_Item.GetItemInfo(itemId) local name, _, quality, _, _, _, _, _, equipLoc, _, _, classID, subClassID = C_Item.GetItemInfo(itemId)
local _, count = GetContainerItemInfo(bag, slot) local _, count = GetContainerItemInfo(bag, slot)
local item = { local item = {
key = SortKey(itemId, name, classID, subClassID, quality, count), key = SortKey(itemId, name, classID, subClassID, quality, count, equipLoc),
-- vanilla items carry at most one family bit, so equality -- vanilla items carry at most one family bit, so equality
-- against a bag family suffices (no bit.band needed). -- against a bag family suffices (no bit.band needed).
family = C_Item.GetItemFamily(itemId) or 0, family = C_Item.GetItemFamily(itemId) or 0,
@@ -181,10 +214,28 @@ local function BuildSortGrid()
end end
end end
table.sort(normalItems, function(a, b) return a.key < b.key end) local opts = libbagsort.opts or {}
-- Sort poor items descending so they read in ascending order when placed local reverse = opts.reverse
-- back-to-front (last poor item lands on the last slot). local reversePrio = opts.reversePrio
table.sort(poorItems, function(a, b) return a.key > b.key end)
if reverse then
ReverseArray(generalCells)
for _, cells in pairs(specialtyCells) do
ReverseArray(cells)
end
end
if reversePrio then
table.sort(normalItems, function(a, b) return a.key > b.key end)
else
table.sort(normalItems, function(a, b) return a.key < b.key end)
end
if reverse then
table.sort(poorItems, function(a, b) return a.key < b.key end)
else
table.sort(poorItems, function(a, b) return a.key > b.key end)
end
-- Forward pass: route each normal item into the next free cell that -- Forward pass: route each normal item into the next free cell that
-- accepts it -- a matching specialty bag first, overflowing to general. -- accepts it -- a matching specialty bag first, overflowing to general.
@@ -274,9 +325,15 @@ end
-- BAG_UPDATE_DELAYED cycle), then place items by category/name/quality. -- BAG_UPDATE_DELAYED cycle), then place items by category/name/quality.
-- e.g. `libbagsort:Sort({0, 1, 2, 3, 4})` for the main bags; -- e.g. `libbagsort:Sort({0, 1, 2, 3, 4})` for the main bags;
-- `{-1, 5, 6, 7, 8, 9, 10}` for the bank. -- `{-1, 5, 6, 7, 8, 9, 10}` for the bank.
function libbagsort:Sort(bagList) --
-- opts (optional): { reverse = bool, reversePrio = bool }
-- reverse - place the first-ranked item into the last slot of the last
-- bag (junk fills from the opposite end).
-- reversePrio - flip the category ranking (e.g. hearthstone sorts last).
function libbagsort:Sort(bagList, opts)
ClearSortData() ClearSortData()
self.bagList = bagList self.bagList = bagList
self.opts = opts
-- Phase 1: fire every consolidation op in a single batch. -- Phase 1: fire every consolidation op in a single batch.
local ops = BuildConsolidateOps(bagList) local ops = BuildConsolidateOps(bagList)
+61 -1660
View File
File diff suppressed because it is too large Load Diff
+2 -2
View File
@@ -10,8 +10,8 @@ local libhealth = CreateFrame("Frame")
libhealth.enabled = true libhealth.enabled = true
libhealth.reqhit = 4 libhealth.reqhit = 4
libhealth.reqdmg = 5 libhealth.reqdmg = 5
libhealth:RegisterEvent("UNIT_HEALTH") libhealth:RegisterUnitEvent("UNIT_HEALTH", "target")
libhealth:RegisterEvent("UNIT_COMBAT") libhealth:RegisterUnitEvent("UNIT_COMBAT", "target")
libhealth:RegisterEvent("PLAYER_TARGET_CHANGED") libhealth:RegisterEvent("PLAYER_TARGET_CHANGED")
libhealth:RegisterEvent("PLAYER_ENTERING_WORLD") libhealth:RegisterEvent("PLAYER_ENTERING_WORLD")
libhealth:SetScript("OnEvent", function() libhealth:SetScript("OnEvent", function()
+223 -370
View File
@@ -2,47 +2,39 @@
setfenv(1, pfUI:GetEnvironment()) setfenv(1, pfUI:GetEnvironment())
--[[ libpredict ]]-- --[[ libpredict ]]--
-- A pfUI library that detects, receives and sends heal and resurrection predictions. -- A pfUI library that detects, receives and sends heal predictions.
-- Healing predictions are done by caching the last known "normal" heal value of the -- Healing predictions are done by caching the last known "normal" heal value of the
-- spell when last being used. Those chaches are cleared when new talents are detected. -- spell when last being used. Those chaches are cleared when new talents are detected.
-- The API provides function calls similar to later WoW expansions such as: -- The API provides function calls similar to later WoW expansions such as:
-- UnitGetIncomingHeals(unit) -- UnitGetIncomingHeals(unit)
-- UnitHasIncomingResurrection(unit) -- UnitHasResurrection(unit)
-- --
-- The library is able to receive and send compatible messages to HealComm -- UnitHasResurrection extends ClassicAPI's UnitHasIncomingResurrection, which
-- including resurrections. It has an option to disable the sending of those -- ends with the cast, to a resurrection that landed and waits for the target
-- messages in case HealComm is already active. -- to accept it.
-- --
-- HOT TRACKING INTEGRATION (NEW): -- The library is able to receive and send compatible messages to HealComm,
-- With Nampower enabled, HoT tracking now primarily uses libdebuff's AURA_CAST -- and announces the player's resurrections to HealComm and CTRA. It has an
-- event system for accurate server-side buff/debuff tracking with full rank -- option to disable the sending of those messages in case HealComm is
-- protection. GetHotDuration() first checks libdebuff, then falls back to the -- already active.
-- legacy prediction system for backwards compatibility with non-Nampower clients. --
-- This provides: -- Casts are read from ClassicAPI's UNIT_SPELLCAST_* events and heal amounts
-- - Accurate duration from server (no prediction needed) -- from COMBAT_LOG_EVENT_UNFILTERED. GetHotDuration() reads live HoT timers
-- - Automatic rank protection (lower ranks won't overwrite higher ranks) -- from C_UnitAuras (via libdebuff) and falls back to the HealComm-fed table.
-- - Support for multiple casters of same HoT on one target
-- - Zero event overhead (libdebuff already tracks all auras)
-- return instantly when another libpredict is already active -- return instantly when another libpredict is already active
if pfUI.api.libpredict then return end if pfUI.api.libpredict then return end
-- Check if libdebuff integration is available local heals, events, hots = {}, {}, {}
local libdebuff_available = (pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast) and true or false
-- Check if Nampower is available for SPELL_FAILED events
local senttarget
local heals, ress, events, hots = {}, {}, {}, {}
local spell_queue = { "DUMMY", "DUMMYRank 9", "TARGET" } local spell_queue = { "DUMMY", "DUMMYRank 9", "TARGET" }
local player = UnitName("player") local player = UnitName("player")
local cache, gear_string = {}, "" local cache, gear_string = {}, ""
local foreignCache = {} -- [casterName][spellKey] = amount, in-memory cache for other healers local foreignCache = {} -- [casterName][spellKey] = amount, in-memory cache for other healers
local rejuvDuration, renewDuration = 12, 15 --default durations local rejuvDuration, renewDuration = 12, 15 --default durations
local ressGuidToName = {} -- [casterGuid] = casterName, for SPELL_FAILED_OTHER cleanup local healGuidToName = {} -- [casterGuid] = casterName, for interrupted-cast cleanup
local healGuidToName = {} -- [casterGuid] = casterName, for SPELL_FAILED_OTHER cleanup local sentTargets = {} -- [castGUID] = target name of an own cast, from UNIT_SPELLCAST_SENT
local ress_timers = {} -- [target][sender] = expiry_timestamp (60s rez window) local resOffers = {} -- [guid] = expiry of a landed resurrection the target has yet to accept
local RESS_TIMEOUT = 60 -- Vanilla: rez offer expires after 60s local RES_OFFER_TIMEOUT = 60 -- the target's resurrect popup declines itself after 60s
-- Localized spell names resolved once from canonical rank-1 spellIDs. -- Localized spell names resolved once from canonical rank-1 spellIDs.
-- Every rank shares the same name, so per-rank comparisons elsewhere can -- Every rank shares the same name, so per-rank comparisons elsewhere can
@@ -53,7 +45,6 @@ local RENEW = C_Spell.GetSpellName(139) -- Renew (Rank 1)
local REGROWTH = C_Spell.GetSpellName(8936) -- Regrowth (Rank 1) local REGROWTH = C_Spell.GetSpellName(8936) -- Regrowth (Rank 1)
local libpredict = CreateFrame("Frame") local libpredict = CreateFrame("Frame")
libpredict:RegisterEvent("UNIT_HEALTH")
libpredict:RegisterEvent("CHAT_MSG_ADDON") libpredict:RegisterEvent("CHAT_MSG_ADDON")
libpredict:RegisterEvent("PLAYER_TARGET_CHANGED") libpredict:RegisterEvent("PLAYER_TARGET_CHANGED")
libpredict:RegisterEvent("PLAYER_LOGOUT") libpredict:RegisterEvent("PLAYER_LOGOUT")
@@ -66,13 +57,8 @@ libpredict:SetScript("OnEvent", function()
return return
end end
if event == "CHAT_MSG_ADDON" and (arg1 == "HealComm" or arg1 == "CTRA") then if event == "CHAT_MSG_ADDON" and arg1 == "HealComm" then
this:ParseChatMessage(arg4, arg2, arg1) this:ParseChatMessage(arg4, arg2)
elseif event == "UNIT_HEALTH" then
local name = UnitName(arg1)
if name and ress[name] and not UnitIsDeadOrGhost(arg1) then
ress[name] = nil
end
end end
end) end)
@@ -106,61 +92,34 @@ local function cacheRaidNames()
if pguid then guidNameCache[pguid] = UnitName("player") end if pguid then guidNameCache[pguid] = UnitName("player") end
end end
local function isRezSpell(spellId)
if not L["resurrections"] then return false end
local spellName = C_Spell.GetSpellName(spellId)
return spellName and L["resurrections"][spellName]
end
-- Build cache on world enter -- Build cache on world enter
libpredict:RegisterEvent("PLAYER_ENTERING_WORLD") libpredict:RegisterEvent("PLAYER_ENTERING_WORLD")
libpredict:RegisterEvent("RAID_ROSTER_UPDATE") libpredict:RegisterEvent("RAID_ROSTER_UPDATE")
libpredict:RegisterEvent("PARTY_MEMBERS_CHANGED") libpredict:RegisterEvent("PARTY_MEMBERS_CHANGED")
local origOnEvent = libpredict:GetScript("OnEvent") libpredict:HookScript("OnEvent", function()
libpredict:SetScript("OnEvent", function()
if event == "PLAYER_ENTERING_WORLD" or event == "RAID_ROSTER_UPDATE" or event == "PARTY_MEMBERS_CHANGED" then if event == "PLAYER_ENTERING_WORLD" or event == "RAID_ROSTER_UPDATE" or event == "PARTY_MEMBERS_CHANGED" then
cacheRaidNames() cacheRaidNames()
end end
if origOnEvent then origOnEvent() end
end) end)
-- SPELL_START_SELF: own cast started (heals + rez) -- Own cast-time spell started (heals + rez)
pfUI.libdebuff_spell_start_self_hooks = pfUI.libdebuff_spell_start_self_hooks or {} local function OnOwnCastStart(spellId, castGUID)
pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
local spellName = C_Spell.GetSpellName(spellId) local spellName = C_Spell.GetSpellName(spellId)
if not spellName then return end if not spellName then return end
local pendingTarget = nil -- SENT names the unit the cast went out at; self and no-target casts
local pendingTargetGuid = nil -- carry none, so fall back to what the cast hooks recorded
local pending = pfUI.libpredict_pending_cast local target = sentTargets[castGUID] or spell_queue[3]
if pending and pending.spellName == spellName and pending.targetGuid local _, _, _, startMs, endMs = C_Spell.CastingInfo()
and pending.time and (GetTime() - pending.time) < 1 then local castTime = startMs and endMs - startMs or 0
-- If SPELL_CAST_EVENT target differs from SPELL_START_SELF target,
-- the client redirected the cast (e.g. offline target → selfcast).
-- Discard pending and trust the actual targetGuid from SPELL_START_SELF.
if pending.targetGuid == targetGuid then
local name = UnitName(pending.targetGuid)
if name and name ~= UNKNOWNOBJECT and name ~= UKNOWNBEING then
pendingTarget = name
pendingTargetGuid = pending.targetGuid
end
end
pending.spellId = nil
pending.spellName = nil
pending.targetGuid = nil
pending.time = nil
end
local target = pendingTarget or resolveNameFromGuid(targetGuid) or senttarget or spell_queue[3]
-- resolved GUID: prefer pendingTargetGuid (mouseover/click-to-cast), fall back to targetGuid
local resolvedTargetGuid = pendingTargetGuid or targetGuid
libpredict.sender.castGUID = castGUID
libpredict.sender.delayMs = 0
libpredict.sender.current_cast = spellName libpredict.sender.current_cast = spellName
libpredict.sender.current_cast_target = target libpredict.sender.current_cast_target = target
if L["resurrections"][spellName] then if L["resurrections"][spellName] then
if target then if target then
libpredict:Ress(player, target, casterGuid)
libpredict.sender:SendHealCommMsg("Resurrection/" .. target .. "/start/") libpredict.sender:SendHealCommMsg("Resurrection/" .. target .. "/start/")
libpredict.sender:SendResCommMsg("RES " .. target) libpredict.sender:SendResCommMsg("RES " .. target)
libpredict.sender.resurrecting = true libpredict.sender.resurrecting = true
@@ -168,6 +127,9 @@ pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGu
return return
end end
spell_queue[1] = spellName
spell_queue[2] = spellName .. (C_Spell.GetSpellSubtext(spellId) or "")
if spell_queue[1] == spellName and cache[spell_queue[2]] then if spell_queue[1] == spellName and cache[spell_queue[2]] then
local amount = cache[spell_queue[2]][1] local amount = cache[spell_queue[2]][1]
local casttime = castTime local casttime = castTime
@@ -232,27 +194,17 @@ pfUI.libdebuff_spell_start_self_hooks["libpredict"] = function(spellId, casterGu
return -- skip the generic Heal call below return -- skip the generic Heal call below
end end
-- If the resolved heal target is itself hostile (e.g. self-cast heal while targeting an enemy), libpredict:Heal(player, target, amount, casttime)
-- store the heal under the player so the player frame shows the prediction. libpredict.sender:SendHealCommMsg("Heal/" .. (target or "") .. "/" .. amount .. "/" .. casttime .. "/")
-- Use resolvedTargetGuid (prefers pendingTargetGuid from mouseover/click-to-cast) so we
-- don't wrongly fall back to player when healing a friend via mouseover with a foe in target.
local healTarget = target
local unitTargetGuid = UnitGUID and UnitGUID("target")
local healTargetIsHostile = resolvedTargetGuid and unitTargetGuid
and resolvedTargetGuid == unitTargetGuid
and UnitExists("target")
and (UnitCanAttack("player", "target") or not UnitIsFriend("player", "target"))
if healTargetIsHostile then
healTarget = player
end
libpredict:Heal(player, healTarget, amount, casttime)
libpredict.sender:SendHealCommMsg("Heal/" .. (healTarget or "") .. "/" .. amount .. "/" .. casttime .. "/")
libpredict.sender.healing = true libpredict.sender.healing = true
end end
end end
-- SPELL_GO_SELF: own cast landed (HealStop + Regrowth timer) -- Own cast landed: HealStop, Regrowth timer, instant HoTs
pfUI.libdebuff_spell_go_hooks["libpredict_sender"] = function(spellId) local function OnOwnCastSucceeded(spellId, castGUID)
local target = sentTargets[castGUID] or spell_queue[3]
sentTargets[castGUID] = nil
libpredict:HealStop(player) libpredict:HealStop(player)
local spellName = C_Spell.GetSpellName(spellId) local spellName = C_Spell.GetSpellName(spellId)
if spellName == REGROWTH then if spellName == REGROWTH then
@@ -264,34 +216,48 @@ pfUI.libdebuff_spell_go_hooks["libpredict_sender"] = function(spellId)
end end
libpredict.sender.regrowth_timer = now + 0.1 libpredict.sender.regrowth_timer = now + 0.1
end end
libpredict.sender.castGUID = nil
libpredict.sender.current_cast = nil libpredict.sender.current_cast = nil
libpredict.sender.current_cast_target = nil libpredict.sender.current_cast_target = nil
if not target then return end
-- Instant HoTs — classify by name (rank-independent) instead of a
-- hardcoded per-rank ID table.
local hotType
if spellName == REJUVENATION then hotType = "Reju"
elseif spellName == RENEW then hotType = "Renew"
end
if hotType then
local duration = hotType == "Reju" and rejuvDuration or renewDuration
local rank = 0
local rankSub = C_Spell.GetSpellSubtext(spellId)
if rankSub and rankSub ~= "" then
rank = tonumber((string.gsub(rankSub, "Rank ", ""))) or 0
end
libpredict:Hot(player, target, hotType, duration, nil, "UNIT_SPELLCAST_SUCCEEDED", rank)
libpredict.sender:SendHealCommMsg(hotType .. "/" .. target .. "/" .. duration .. "/" .. rank .. "/")
end
end end
-- SPELL_START_OTHER: foreign cast started (heals + rez) -- Foreign cast-time heal started
-- Signature: fn(spellId, casterGuid, targetGuid, castTime) local function OnOtherCastStart(unit, spellId)
pfUI.libdebuff_spell_start_other_hooks = pfUI.libdebuff_spell_start_other_hooks or {}
pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterGuid, targetGuid, castTime)
local spellName = C_Spell.GetSpellName(spellId) local spellName = C_Spell.GetSpellName(spellId)
if not spellName then return end if not spellName then return end
local casterGuid = UnitGUID(unit)
local casterName = resolveNameFromGuid(casterGuid) local casterName = resolveNameFromGuid(casterGuid)
if not casterName then return end if not casterName then return end
-- Resurrection cast local targetName = UnitSpellTargetName(unit)
if L["resurrections"][spellName] then
local targetName = resolveNameFromGuid(targetGuid)
if targetName then
libpredict:Ress(casterName, targetName, casterGuid)
end
return
end
-- Heal cast: look up cached amount from a previous cast by this healer
local targetName = resolveNameFromGuid(targetGuid)
if not targetName then return end if not targetName then return end
local rankStr = GetSpellRecField and GetSpellRecField(spellId, "rank") or "" -- Heal cast: look up cached amount from a previous cast by this healer
local _, _, _, startMs, endMs = C_Spell.UnitCastingInfo(unit)
if not startMs then return end
local castTime = endMs - startMs
local rankStr = C_Spell.GetSpellSubtext(spellId) or ""
local spellKey = spellName .. (rankStr or "") local spellKey = spellName .. (rankStr or "")
local amount = foreignCache[casterName] and foreignCache[casterName][spellKey] local amount = foreignCache[casterName] and foreignCache[casterName][spellKey]
@@ -335,88 +301,31 @@ pfUI.libdebuff_spell_start_other_hooks["libpredict"] = function(spellId, casterG
libpredict:Heal(casterName, targetName, amount, castTime, casterGuid) libpredict:Heal(casterName, targetName, amount, castTime, casterGuid)
end end
-- SPELL_GO_SELF: own cast landed - HoTs + own rez timer -- Foreign cast landed: the predicted heal is fulfilled
-- Signature: fn(spellId, arg1, arg2, arg3, arg4, arg5, arg6, arg7) local function OnOtherCastSucceeded(unit)
pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {} local casterName = resolveNameFromGuid(UnitGUID(unit))
pfUI.libdebuff_spell_go_hooks["libpredict"] = function(spellId, a1, a2, a3, a4, a5, a6, a7)
-- Instant HoTs — classify by name (rank-independent) instead of a
-- hardcoded per-rank ID table.
local spellName = C_Spell.GetSpellName(spellId)
local hotType
if spellName == REJUVENATION then hotType = "Reju"
elseif spellName == RENEW then hotType = "Renew"
end
if hotType then
local targetGuid = a4
local targetName = resolveNameFromGuid(targetGuid)
if targetName then
local duration
if hotType == "Reju" then duration = rejuvDuration or 12
elseif hotType == "Renew" then duration = renewDuration or 15
end
local rank = 0
if GetSpellRecField then
local rankStr = GetSpellRecField(spellId, "rank")
if rankStr and rankStr ~= "" then
rank = tonumber((string.gsub(rankStr, "Rank ", ""))) or 0
end
end
local playerName = UnitName("player")
libpredict:Hot(playerName, targetName, hotType, duration, nil, "SPELL_GO_SELF", rank)
local rankStr = tostring(rank)
if libpredict.sender and libpredict.sender.SendHealCommMsg then
libpredict.sender:SendHealCommMsg(hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/")
elseif IsInRaid() then
SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "RAID")
elseif IsInGroup() then
SendAddonMessage("HealComm", hotType .. "/" .. targetName .. "/" .. duration .. "/" .. rankStr .. "/", "PARTY")
end
end
end
-- Own rez landed: set timer
if isRezSpell(spellId) then
local targetGuid = a4
local targetName = resolveNameFromGuid(targetGuid)
local playerName = UnitName("player")
if playerName and targetName then
libpredict:RessSetTimer(playerName, targetName)
end
end
end
-- SPELL_GO_OTHER: foreign cast landed - rez timer + HealStop
-- Signature: fn(spellId, casterGuid, targetGuid)
pfUI.libdebuff_spell_go_other_hooks = pfUI.libdebuff_spell_go_other_hooks or {}
pfUI.libdebuff_spell_go_other_hooks["libpredict"] = function(spellId, casterGuid, targetGuid)
local casterName = resolveNameFromGuid(casterGuid)
if not casterName then return end if not casterName then return end
if isRezSpell(spellId) then
local targetName = resolveNameFromGuid(targetGuid)
if targetName then
libpredict:RessSetTimer(casterName, targetName)
end
return
end
-- Heal landed → prediction fulfilled, clean up
libpredict:HealStop(casterName) libpredict:HealStop(casterName)
end end
-- SPELL_FAILED_OTHER: remove cancelled resses/heals -- Foreign cast interrupted: remove cancelled heals
-- Signature: fn(casterGuid, spellId) local function OnOtherCastInterrupted(unit)
pfUI.libdebuff_spell_failed_other_hooks = pfUI.libdebuff_spell_failed_other_hooks or {} local casterGuid = UnitGUID(unit)
pfUI.libdebuff_spell_failed_other_hooks["libpredict"] = function(casterGuid, spellId)
if not casterGuid then return end if not casterGuid then return end
local ressName = ressGuidToName[casterGuid]
if ressName then
libpredict:RessStop(ressName)
end
local healName = healGuidToName[casterGuid] local healName = healGuidToName[casterGuid]
if healName then libpredict:HealStop(healName) end if healName then libpredict:HealStop(healName) end
end end
-- Flag the unit frames showing `guid` to redraw their resurrection icon
local function RefreshResFrames(guid)
for _, frame in pairs(pfUI.uf.frames) do
if frame.unitstr and UnitGUID(frame.unitstr) == guid then
frame.update_indicators = true
end
end
end
libpredict:SetScript("OnUpdate", function() libpredict:SetScript("OnUpdate", function()
-- throttle cleanup - no need to check every frame -- throttle cleanup - no need to check every frame
local now = pfUI.uf.now or GetTime() local now = pfUI.uf.now or GetTime()
@@ -430,13 +339,12 @@ libpredict:SetScript("OnUpdate", function()
end end
end end
-- Rez timeout: remove offer after 60s if player doesn't accept -- drop resurrection offers the target accepted or let run out
for target, senders in pairs(ress_timers) do for guid, expiry in pairs(resOffers) do
for sender, expiry in pairs(senders) do local unit = UnitTokenFromGUID(guid)
if now >= expiry then if now >= expiry or not (unit and UnitIsDeadOrGhost(unit)) then
senders[sender] = nil resOffers[guid] = nil
if ress[target] then ress[target][sender] = nil end RefreshResFrames(guid)
end
end end
end end
end) end)
@@ -450,8 +358,6 @@ function libpredict:ParseComm(sender, msg)
if libpredict.debug then if libpredict.debug then
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[libpredict RX]|r HealStop from " .. tostring(sender)) DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[libpredict RX]|r HealStop from " .. tostring(sender))
end end
elseif msg == "Resurrection/stop/" then
msgtype = "RessStop"
elseif msg then elseif msg then
local msgobj = {strsplit("/", msg)} local msgobj = {strsplit("/", msg)}
@@ -461,10 +367,6 @@ function libpredict:ParseComm(sender, msg)
msgtype, time = "Delay", msgobj[2] msgtype, time = "Delay", msgobj[2]
end end
if msgobj[1] and msgobj[1] == "Resurrection" and msgobj[2] then
msgtype, target = "Ress", msgobj[2]
end
if msgobj[1] == "Heal" and msgobj[2] then if msgobj[1] == "Heal" and msgobj[2] then
msgtype, target, heal, time = "Heal", msgobj[2], msgobj[3], msgobj[4] msgtype, target, heal, time = "Heal", msgobj[2], msgobj[3], msgobj[4]
end end
@@ -536,25 +438,12 @@ end
local recentHots = {} local recentHots = {}
local DUPLICATE_WINDOW = 0.5 -- Ignoriere gleiche Nachricht innerhalb 0.5s local DUPLICATE_WINDOW = 0.5 -- Ignoriere gleiche Nachricht innerhalb 0.5s
function libpredict:ParseChatMessage(sender, msg, comm) function libpredict:ParseChatMessage(sender, msg)
local msgtype, target, heal, time, rank local msgtype, target, heal, time, rank = libpredict:ParseComm(sender, msg)
if comm == "HealComm" then
msgtype, target, heal, time, rank = libpredict:ParseComm(sender, msg)
elseif comm == "CTRA" then
local _, _, cmd, ctratarget = string.find(msg, "(%a+)%s?([^#]*)")
if cmd and ctratarget and cmd == "RES" and ctratarget ~= "" and ctratarget ~= UNKNOWN then
msgtype = "Ress"
target = ctratarget
end
end
if msgtype == "Stop" and sender then if msgtype == "Stop" and sender then
libpredict:HealStop(sender) libpredict:HealStop(sender)
return return
elseif ( msg == "RessStop" or msg == "RESNO" ) and sender then
libpredict:RessStop(sender)
return
elseif msgtype == "Delay" and time then elseif msgtype == "Delay" and time then
libpredict:HealDelay(sender, time) libpredict:HealDelay(sender, time)
elseif msgtype == "Heal" and target and heal and time then elseif msgtype == "Heal" and target and heal and time then
@@ -565,29 +454,6 @@ function libpredict:ParseChatMessage(sender, msg, comm)
else else
libpredict:Heal(sender, target, heal, time) libpredict:Heal(sender, target, heal, time)
end end
elseif msgtype == "Ress" then
-- HealComm: only for other players (own resses tracked via SPELL_START_SELF hook)
local playerName = UnitName("player")
if sender ~= playerName then
local senderGuid
for i = 1, GetNumRaidMembers() do
local unit = "raid" .. i
if UnitName(unit) == sender then
senderGuid = UnitGUID(unit)
break
end
end
if not senderGuid then
for i = 1, GetNumPartyMembers() do
local unit = "party" .. i
if UnitName(unit) == sender then
senderGuid = UnitGUID(unit)
break
end
end
end
libpredict:Ress(sender, target, senderGuid)
end
elseif msgtype == "Hot" then elseif msgtype == "Hot" then
-- Duplicate check: ignore same sender+target+spell within DUPLICATE_WINDOW -- Duplicate check: ignore same sender+target+spell within DUPLICATE_WINDOW
local now = pfUI.uf.now or GetTime() local now = pfUI.uf.now or GetTime()
@@ -736,41 +602,6 @@ function libpredict:HealDelay(sender, delay)
end end
end end
function libpredict:Ress(sender, target, senderGuid)
ress[target] = ress[target] or {}
ress[target][sender] = true
if senderGuid then ressGuidToName[senderGuid] = sender end
-- no timer here - timer is only set once the cast actually completes
end
function libpredict:RessSetTimer(sender, target)
ress_timers[target] = ress_timers[target] or {}
local existing = ress_timers[target][sender]
if not existing or GetTime() >= existing then
ress_timers[target][sender] = GetTime() + RESS_TIMEOUT
else
end
end
function libpredict:RessStop(sender)
local now = GetTime()
for ttarget, t in pairs(ress) do
for tsender in pairs(ress[ttarget]) do
if sender == tsender then
local expiry = ress_timers[ttarget] and ress_timers[ttarget][tsender]
if not expiry or now >= expiry then
ress[ttarget][tsender] = nil
if ress_timers[ttarget] then ress_timers[ttarget][tsender] = nil end
else
end
end
end
end
for guid, name in pairs(ressGuidToName) do
if name == sender then ressGuidToName[guid] = nil end
end
end
function libpredict:UnitGetIncomingHeals(unit) function libpredict:UnitGetIncomingHeals(unit)
if not unit then return 0 end if not unit then return 0 end
local name = UnitName(unit) local name = UnitName(unit)
@@ -793,26 +624,35 @@ function libpredict:UnitGetIncomingHeals(unit)
return sumheal return sumheal
end end
function libpredict:UnitHasIncomingResurrection(unit) -- Whether a resurrection is being cast at the unit, or landed and waits for
if not unit then return nil end -- the unit to accept it
local name = UnitName(unit) function libpredict:UnitHasResurrection(unit)
if not name then return nil end return UnitHasIncomingResurrection(unit) or resOffers[UnitGUID(unit)] ~= nil
if not ress[name] then
return nil
else
for sender, val in pairs(ress[name]) do
if val == true then
return val
end
end
end
return nil
end end
local realm = GetRealmName() local realm = GetRealmName()
local resetcache = CreateFrame("Frame") local resetcache = CreateFrame("Frame")
local hotsetbonus = libtipscan:GetScanner("hotsetbonus")
-- set bonus spells that lengthen a HoT
local REJUVENATION_SET_BONUS = 21871 -- Stormrage Raiment (8)
local RENEW_SET_BONUS = 26171 -- Garments of the Oracle (5)
-- the set bonus spells the equipped gear grants
local function GetActiveSetBonuses()
local pieces = {}
for slot = 1, 19 do
local setID = C_Item.GetItemSetID({ equipmentSlotIndex = slot })
if setID then pieces[setID] = (pieces[setID] or 0) + 1 end
end
local active = {}
for setID, count in pairs(pieces) do
for _, bonus in ipairs(C_Item.GetItemSetInfo(setID).bonuses) do
if count >= bonus.threshold then active[bonus.spellID] = true end
end
end
return active
end
resetcache:RegisterEvent("PLAYER_ENTERING_WORLD") resetcache:RegisterEvent("PLAYER_ENTERING_WORLD")
resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB") resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB")
resetcache:RegisterEvent("CHARACTER_POINTS_CHANGED") resetcache:RegisterEvent("CHARACTER_POINTS_CHANGED")
@@ -837,19 +677,9 @@ resetcache:SetScript("OnEvent", function()
if gear == gear_string then return end if gear == gear_string then return end
gear_string = gear gear_string = gear
local setBonusCounter local bonuses = GetActiveSetBonuses()
setBonusCounter = 0 rejuvDuration = bonuses[REJUVENATION_SET_BONUS] and 15 or 12
for i=1,10 do --there is no need to check slots above 10 renewDuration = bonuses[RENEW_SET_BONUS] and 18 or 15
hotsetbonus:SetInventoryItem("player", i)
if hotsetbonus:Find(L["healduration"]["Rejuvenation"]) then setBonusCounter = setBonusCounter + 1 end
end
rejuvDuration = setBonusCounter == 8 and 15 or 12
setBonusCounter = 0
for i =1,10 do
hotsetbonus:SetInventoryItem("player", i)
if hotsetbonus:Find(L["healduration"]["Renew"]) then setBonusCounter = setBonusCounter + 1 end
end
renewDuration = setBonusCounter == 5 and 18 or 15
end end
-- flag all cached heals for renewal -- flag all cached heals for renewal
@@ -898,7 +728,6 @@ local pendingHots = {}
-- Gather Data by User Actions -- Gather Data by User Actions
hooksecurefunc("CastSpell", function(id, bookType) hooksecurefunc("CastSpell", function(id, bookType)
if not libpredict.sender.enabled then return end
local effect, rank = libspell.GetSpellInfo(id, bookType) local effect, rank = libspell.GetSpellInfo(id, bookType)
if not effect then return end if not effect then return end
spell_queue[1] = effect spell_queue[1] = effect
@@ -911,7 +740,7 @@ hooksecurefunc("CastSpell", function(id, bookType)
rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil
end end
-- Instant HoTs: libdebuff/Nampower via GetHotDuration, hook method as fallback -- Instant HoTs: UNIT_SPELLCAST_SUCCEEDED and C_UnitAuras, hook method as fallback
if effect == REJUVENATION then if effect == REJUVENATION then
local target = spell_queue[3] local target = spell_queue[3]
@@ -951,7 +780,6 @@ hooksecurefunc("CastSpell", function(id, bookType)
end) end)
hooksecurefunc("CastSpellByName", function(effect, target) hooksecurefunc("CastSpellByName", function(effect, target)
if not libpredict.sender.enabled then return end
local effect, rank = libspell.GetSpellInfo(effect) local effect, rank = libspell.GetSpellInfo(effect)
if not effect then return end if not effect then return end
@@ -975,7 +803,7 @@ hooksecurefunc("CastSpellByName", function(effect, target)
spell_queue[3] = target or default spell_queue[3] = target or default
end end
-- Instant HoTs: libdebuff/Nampower via GetHotDuration, hook method as fallback -- Instant HoTs: UNIT_SPELLCAST_SUCCEEDED and C_UnitAuras, hook method as fallback
if effect == REJUVENATION then if effect == REJUVENATION then
local hotTarget = target or default local hotTarget = target or default
@@ -1015,7 +843,6 @@ hooksecurefunc("CastSpellByName", function(effect, target)
end) end)
hooksecurefunc("UseAction", function(slot, target, selfcast) hooksecurefunc("UseAction", function(slot, target, selfcast)
if not libpredict.sender.enabled then return end
if not IsCurrentAction(slot) then return end if not IsCurrentAction(slot) then return end
local kind, id = GetActionInfo(slot) local kind, id = GetActionInfo(slot)
local effect, rank local effect, rank
@@ -1036,7 +863,7 @@ hooksecurefunc("UseAction", function(slot, target, selfcast)
rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil rankNum = tonumber((string.gsub(rank, "Rank ", ""))) or nil
end end
-- Instant HoTs: libdebuff/Nampower via GetHotDuration, hook method as fallback -- Instant HoTs: UNIT_SPELLCAST_SUCCEEDED and C_UnitAuras, hook method as fallback
if effect == REJUVENATION then if effect == REJUVENATION then
local hotTarget = spell_queue[3] local hotTarget = spell_queue[3]
@@ -1076,8 +903,10 @@ hooksecurefunc("UseAction", function(slot, target, selfcast)
end) end)
libpredict.sender = CreateFrame("Frame", "pfPredictionSender", UIParent) libpredict.sender = CreateFrame("Frame", "pfPredictionSender", UIParent)
-- cleared when a HealComm addon already broadcasts this player's casts
libpredict.sender.enabled = true libpredict.sender.enabled = true
libpredict.sender.SendHealCommMsg = function(self, msg) libpredict.sender.SendHealCommMsg = function(self, msg)
if not self.enabled then return end
-- Smart channel selection: Only send to relevant channel to avoid duplicates -- Smart channel selection: Only send to relevant channel to avoid duplicates
if IsInRaid() then if IsInRaid() then
-- In raid: Only send to RAID (includes all raid members) -- In raid: Only send to RAID (includes all raid members)
@@ -1090,6 +919,7 @@ libpredict.sender.SendHealCommMsg = function(self, msg)
-- BG groups are handled by RAID channel -- BG groups are handled by RAID channel
end end
libpredict.sender.SendResCommMsg = function(self, msg) libpredict.sender.SendResCommMsg = function(self, msg)
if not self.enabled then return end
-- Smart channel selection: Only send to relevant channel to avoid duplicates -- Smart channel selection: Only send to relevant channel to avoid duplicates
if IsInRaid() then if IsInRaid() then
-- In raid: Only send to RAID (includes all raid members) -- In raid: Only send to RAID (includes all raid members)
@@ -1126,15 +956,16 @@ libpredict.sender:SetScript("OnUpdate", function()
end end
end) end)
-- Nampower events -- Own casts arrive as "player"; every other caster fires once per unit token
libpredict.sender:RegisterEvent("SPELL_FAILED_SELF") -- it currently holds (raidN, target, nameplateN, ...), so other-unit handlers
libpredict.sender:RegisterEvent("SPELL_DELAYED_SELF") -- drop the repeats by castGUID.
libpredict.sender:RegisterEvent("SPELL_HEAL_BY_SELF") libpredict.sender:RegisterEvent("UNIT_SPELLCAST_SENT")
libpredict.sender:RegisterEvent("SPELL_HEAL_BY_OTHER") -- populates foreignCache for other healers libpredict.sender:RegisterEvent("UNIT_SPELLCAST_START")
libpredict.sender:RegisterEvent("UNIT_SPELLCAST_DELAYED")
-- force cache updates libpredict.sender:RegisterEvent("UNIT_SPELLCAST_SUCCEEDED")
libpredict.sender:RegisterEvent("UNIT_INVENTORY_CHANGED") libpredict.sender:RegisterEvent("UNIT_SPELLCAST_FAILED")
libpredict.sender:RegisterEvent("SKILL_LINES_CHANGED") libpredict.sender:RegisterEvent("UNIT_SPELLCAST_INTERRUPTED")
libpredict.sender:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
-- Shared cleanup helper for failed/interrupted casts -- Shared cleanup helper for failed/interrupted casts
local function onCastFailed() local function onCastFailed()
@@ -1144,8 +975,7 @@ local function onCastFailed()
s:SendHealCommMsg("Healstop") s:SendHealCommMsg("Healstop")
s.healing = nil s.healing = nil
elseif s.resurrecting then elseif s.resurrecting then
local target = s.current_cast_target or senttarget or spell_queue[3] local target = s.current_cast_target or spell_queue[3]
libpredict:RessStop(UnitName("player"))
s:SendHealCommMsg("Resurrection/stop/") s:SendHealCommMsg("Resurrection/stop/")
s:SendResCommMsg("RESNO " .. (target or "")) s:SendResCommMsg("RESNO " .. (target or ""))
s.resurrecting = nil s.resurrecting = nil
@@ -1156,81 +986,110 @@ local function onCastFailed()
s.regrowth_target_next = nil s.regrowth_target_next = nil
s.regrowth_start_next = nil s.regrowth_start_next = nil
end end
s.castGUID = nil
s.current_cast = nil s.current_cast = nil
s.current_cast_target = nil s.current_cast_target = nil
end end
libpredict.sender:SetScript("OnEvent", function() -- Real heal amounts: own heals refresh the spell cache, other group healers'
-- ============================================================ -- heals fill foreignCache (one event per hit target for AoE heals like PoH).
-- NAMPOWER PATH local function OnHeal()
-- ============================================================ -- arg4=sourceGUID, arg12=spellId, arg13=spellName, arg15=amount, arg18=critical
if event == "SPELL_HEAL_BY_SELF" then local spellId, spellName, amount, isCrit = arg12, arg13, arg15, arg18 == 1
-- arg1=targetGuid, arg2=casterGuid, arg3=spellId, arg4=amount, arg5=critical, arg6=periodic if not spellName or not amount or amount <= 0 then return end
local spellId = arg3
local amount = arg4 if IsPlayerGuid(arg4) then
local isCrit = arg5 == 1 if spell_queue[1] == spellName then
local isPeriodic = arg6 == 1
local spellName = C_Spell.GetSpellName(spellId)
if spellName and spell_queue[1] == spellName then
UpdateCache(spell_queue[2], amount, isCrit) UpdateCache(spell_queue[2], amount, isCrit)
end end
return
end
elseif event == "SPELL_HEAL_BY_OTHER" then local casterName = resolveNameFromGuid(arg4)
-- Fires once per hit target for AoE heals (e.g. PoH). if not casterName then return end
-- Use this to build a per-caster cache of real heal amounts.
-- arg1=targetGuid, arg2=casterGuid, arg3=spellId, arg4=amount, arg5=critical, arg6=periodic
local casterGuid = arg2
local spellId = arg3
local amount = arg4
local isCrit = arg5 == 1
local isPeriodic = arg6 == 1
if isPeriodic or not spellId or not amount or amount <= 0 then return end local spellKey = spellName .. (C_Spell.GetSpellSubtext(spellId) or "")
local casterName = resolveNameFromGuid(casterGuid) foreignCache[casterName] = foreignCache[casterName] or {}
if not casterName or casterName == player then return end -- own heals handled by SPELL_HEAL_BY_SELF local existing = foreignCache[casterName][spellKey]
-- Store highest non-crit value for best prediction accuracy
if isCrit then
-- Estimate base from crit (vanilla crit = 150%)
local base = math.floor(amount * 2 / 3)
if not existing or base > existing then
foreignCache[casterName][spellKey] = base
end
else
if not existing or amount > existing then
foreignCache[casterName][spellKey] = amount
end
end
end
local spellName = C_Spell.GetSpellName(spellId) -- A landed resurrection: the target has an offer to accept, which outlasts
if not spellName then return end -- UnitHasIncomingResurrection's end with the cast
local rankStr = C_Spell.GetSpellSubtext(spellId) local function OnResurrect()
local spellKey = spellName .. (rankStr or "") -- arg8=destGUID
resOffers[arg8] = GetTime() + RES_OFFER_TIMEOUT
RefreshResFrames(arg8)
end
foreignCache[casterName] = foreignCache[casterName] or {} local lastOtherCast = {} -- [event] = castGUID of the last other-unit event handled
local existing = foreignCache[casterName][spellKey]
-- Store highest non-crit value for best prediction accuracy libpredict.sender:SetScript("OnEvent", function()
if isCrit then if event == "COMBAT_LOG_EVENT_UNFILTERED" then
-- Estimate base from crit (vanilla crit = 150%) if arg2 == "SPELL_HEAL" then OnHeal()
local base = math.floor(amount * 2 / 3) elseif arg2 == "SPELL_RESURRECT" then OnResurrect() end
if not existing or base > existing then return
foreignCache[casterName][spellKey] = base end
end
else -- UNIT_SPELLCAST_SENT: arg1=unit, arg2=target token, arg3=castGUID, arg4=spellID
if not existing or amount > existing then -- every other UNIT_SPELLCAST_*: arg1=unit, arg2=castGUID, arg3=spellID
foreignCache[casterName][spellKey] = amount local unit = arg1
if unit == "player" then
if event == "UNIT_SPELLCAST_SENT" then
sentTargets[arg3] = arg2 ~= "" and UnitName(arg2) or nil
elseif event == "UNIT_SPELLCAST_START" then
OnOwnCastStart(arg3, arg2)
elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
OnOwnCastSucceeded(arg3, arg2)
elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then
sentTargets[arg2] = nil
-- a refused cast (cooldown, range) fails under its own castGUID and
-- must not cancel the heal that is still casting
if arg2 == this.castGUID then onCastFailed() end
elseif event == "UNIT_SPELLCAST_DELAYED" then
-- delayTimeMs is the pushback so far; HealComm wants each step
local _, _, _, _, _, _, _, _, _, _, delayMs = C_Spell.CastingInfo()
if this.healing and delayMs and delayMs > this.delayMs then
local step = delayMs - this.delayMs
this.delayMs = delayMs
libpredict:HealDelay(player, step)
this:SendHealCommMsg("Healdelay/" .. step .. "/")
end end
end end
return
end
elseif event == "SPELL_FAILED_SELF" then if UnitIsUnit(unit, "player") or lastOtherCast[event] == arg2 then return end
onCastFailed() lastOtherCast[event] = arg2
elseif event == "SPELL_DELAYED_SELF" then
-- arg1=casterGuid, arg2=delayMs
if libpredict.sender.healing then
libpredict:HealDelay(player, arg2)
libpredict.sender:SendHealCommMsg("Healdelay/" .. arg2 .. "/")
end
if event == "UNIT_SPELLCAST_START" then
OnOtherCastStart(unit, arg3)
elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
OnOtherCastSucceeded(unit)
elseif event == "UNIT_SPELLCAST_INTERRUPTED" then
OnOtherCastInterrupted(unit)
end end
end) end)
function libpredict:GetHotDuration(unit, spell) function libpredict:GetHotDuration(unit, spell)
if unit == UNKNOWNOBJECT or unit == UNKOWNBEING then return end if unit == UNKNOWNOBJECT or unit == UKNOWNBEING then return end
-- NEW: Try libdebuff first (Nampower AURA_CAST events) -- Live aura timer first (C_UnitAuras via libdebuff)
if pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast then if pfUI.api.libdebuff then
local guid = UnitGUID(unit) local guid = UnitGUID(unit)
if guid then if guid then
-- Get the best (highest rank) aura cast for this spell
local spellName = spell local spellName = spell
-- Map short spell codes to full names -- Map short spell codes to full names
@@ -1245,7 +1104,6 @@ function libpredict:GetHotDuration(unit, spell)
local start, duration, timeleft, rank, casterGuid = pfUI.api.libdebuff:GetBestAuraCast(guid, spellName) local start, duration, timeleft, rank, casterGuid = pfUI.api.libdebuff:GetBestAuraCast(guid, spellName)
if start and duration and timeleft then if start and duration and timeleft then
-- SUCCESS: libdebuff has accurate server-side data!
if libpredict.debug then if libpredict.debug then
DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[GetHotDuration]|r %s on %s via libdebuff: dur=%.1fs timeleft=%.1fs rank=%d", DEFAULT_CHAT_FRAME:AddMessage(string.format("|cff00ff00[GetHotDuration]|r %s on %s via libdebuff: dur=%.1fs timeleft=%.1fs rank=%d",
spell, unit, duration, timeleft, rank or 0)) spell, unit, duration, timeleft, rank or 0))
@@ -1255,7 +1113,7 @@ function libpredict:GetHotDuration(unit, spell)
end end
end end
-- FALLBACK: Use old prediction system (for non-Nampower clients or no AURA_CAST data) -- FALLBACK: the HealComm/cast-fed table, for HoTs C_UnitAuras has no timer for
local start, duration, timeleft local start, duration, timeleft
local now = pfUI.uf.now or GetTime() local now = pfUI.uf.now or GetTime()
@@ -1289,16 +1147,11 @@ _G.SlashCmdList.HOTDEBUG = function()
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[HoT Tracking Debug]|r") DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[HoT Tracking Debug]|r")
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff========================================|r") DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff========================================|r")
-- Check libdebuff availability if pfUI.api.libdebuff then
local libdebuff_now = (pfUI.api.libdebuff and pfUI.api.libdebuff.GetBestAuraCast) and true or false
if libdebuff_now then
DEFAULT_CHAT_FRAME:AddMessage("|cff00ff00[PRIMARY]|r libdebuff integration: ACTIVE") DEFAULT_CHAT_FRAME:AddMessage("|cff00ff00[PRIMARY]|r libdebuff integration: ACTIVE")
DEFAULT_CHAT_FRAME:AddMessage(" Using AURA_CAST events for server-side tracking") DEFAULT_CHAT_FRAME:AddMessage(" Using C_UnitAuras timers")
DEFAULT_CHAT_FRAME:AddMessage(" Rank protection: ENABLED")
else else
DEFAULT_CHAT_FRAME:AddMessage("|cffff9900[PRIMARY]|r libdebuff integration: NOT AVAILABLE") DEFAULT_CHAT_FRAME:AddMessage("|cffff9900[PRIMARY]|r libdebuff integration: NOT AVAILABLE")
DEFAULT_CHAT_FRAME:AddMessage(" Reason: Nampower not enabled or libdebuff outdated")
end end
DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[FALLBACK]|r Legacy prediction system: ACTIVE") DEFAULT_CHAT_FRAME:AddMessage("|cff00ffff[FALLBACK]|r Legacy prediction system: ACTIVE")
-30
View File
@@ -1,30 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
--[[ librange ]]--
-- A thin wrapper over ClassicAPI's UnitInRange: a fixed 40y healing-range
-- check computed C-side from unit positions, valid for any unit. There is
-- no cache or scan loop -- the check is cheap enough to run per query,
-- which also sidesteps the staleness a cached scan hit on zone changes and
-- roster re-indexing.
--
-- librange:UnitInSpellRange(unit)
-- Returns `1` if the unit is within range, `nil` otherwise.
if pfUI.api.librange then return end
local librange = {}
function librange:UnitInSpellRange(unit)
-- _G-qualified: bare `UnitInRange` resolves to pfUI.api.UnitInRange inside
-- the pfUI environment (which calls us), so this must reach ClassicAPI's
-- global directly or it recurses.
local inRange, checked = _G.UnitInRange(unit)
-- position miss (e.g. a unit outside the client's sync range): we can't
-- tell, so default to in-range -- matches the old cache's nil behavior.
if not checked then return 1 end
return inRange and 1 or nil
end
-- add librange to pfUI API
pfUI.api.librange = librange
+7 -8
View File
@@ -83,12 +83,13 @@ end
-- [number] Casting time of the spell in milliseconds -- [number] Casting time of the spell in milliseconds
-- [number] Minimum range from the target required to cast the spell -- [number] Minimum range from the target required to cast the spell
-- [number] Maximum range from the target at which you can cast the spell -- [number] Maximum range from the target at which you can cast the spell
-- [number] The numeric spell-id of the spell -- [number] Spell's index in the book
-- [number] The type of the spellbook that the spell is in -- [number] The type of the spellbook that the spell is in
-- [number] The numeric spell-id of the spell
local spellinfo = {} local spellinfo = {}
function libspell.GetSpellInfo(index, bookType) function libspell.GetSpellInfo(index, bookType)
local cache = spellinfo[index] local cache = spellinfo[index]
if cache then return cache[1], cache[2], cache[3], cache[4], cache[5], cache[6], cache[7], cache[8] end if cache then return unpack(cache) end
local slot local slot
if type(index) == "string" then if type(index) == "string" then
@@ -108,16 +109,14 @@ function libspell.GetSpellInfo(index, bookType)
-- ClassicAPI's GetSpellInfo returns: name, rank, icon, cost, isFunnel, powerType, -- ClassicAPI's GetSpellInfo returns: name, rank, icon, cost, isFunnel, powerType,
-- castTime(ms), minRange, maxRange, spellID. Keep libspell's historical positional -- castTime(ms), minRange, maxRange, spellID. Keep libspell's historical positional
-- shape (castingTime at 4, ranges at 5/6, slot+bookType at 7/8). -- shape (castingTime at 4, ranges at 5/6, slot+bookType at 7/8).
local name, rank, icon, _, _, _, castingTime, minRange, maxRange = GetSpellInfo(slot, bookType) local name, rank, icon, _, _, _, castingTime, minRange, maxRange, spellId = GetSpellInfo(slot, bookType)
spellinfo[index] = { name, rank, icon, castingTime, minRange, maxRange, slot, bookType } spellinfo[index] = SafePack(name, rank, icon, castingTime, minRange, maxRange, slot, bookType, spellId)
return name, rank, icon, castingTime, minRange, maxRange, slot, bookType return name, rank, icon, castingTime, minRange, maxRange, slot, bookType, spellId
end end
-- Reset all spell caches whenever new spells are learned/unlearned -- Reset all spell caches whenever new spells are learned/unlearned
local resetcache = CreateFrame("Frame") pfUI.events:RegisterFrameEventAndCallback("LEARNED_SPELL_IN_TAB", function()
resetcache:RegisterEvent("LEARNED_SPELL_IN_TAB")
resetcache:SetScript("OnEvent", function()
table.wipe(spellmaxrank) table.wipe(spellmaxrank)
table.wipe(spellindex) table.wipe(spellindex)
table.wipe(spellinfo) table.wipe(spellinfo)
+2 -2
View File
@@ -35,7 +35,7 @@ libthrottle.defaults = {
nameplates_target = "custom", nameplates_target = "custom",
nameplates_castbar = "custom", nameplates_castbar = "custom",
nameplates_mass = "custom", nameplates_mass = "custom",
tooltip_cursor = "custom", tooltip_cursor = "fastest",
chat_tab = "custom", chat_tab = "custom",
swingtimer = "custom", swingtimer = "custom",
} }
@@ -160,7 +160,7 @@ libthrottle:SetScript("OnEvent", function()
-- Set defaults for custom fields if missing -- Set defaults for custom fields if missing
if not _G.pfUI_throttle.nameplates_target_custom then _G.pfUI_throttle.nameplates_target_custom = "50" end if not _G.pfUI_throttle.nameplates_target_custom then _G.pfUI_throttle.nameplates_target_custom = "50" end
if not _G.pfUI_throttle.nameplates_custom then _G.pfUI_throttle.nameplates_custom = "10" end if not _G.pfUI_throttle.nameplates_custom then _G.pfUI_throttle.nameplates_custom = "10" end
if not _G.pfUI_throttle.nameplates_castbar_custom then _G.pfUI_throttle.nameplates_castbar_custom = "50" end if not _G.pfUI_throttle.nameplates_castbar_custom then _G.pfUI_throttle.nameplates_castbar_custom = "100" end
if not _G.pfUI_throttle.nameplates_mass_custom then _G.pfUI_throttle.nameplates_mass_custom = "7" end if not _G.pfUI_throttle.nameplates_mass_custom then _G.pfUI_throttle.nameplates_mass_custom = "7" end
if not _G.pfUI_throttle.tooltip_cursor_custom then _G.pfUI_throttle.tooltip_cursor_custom = "10" end if not _G.pfUI_throttle.tooltip_cursor_custom then _G.pfUI_throttle.tooltip_cursor_custom = "10" end
if not _G.pfUI_throttle.chat_tab_custom then _G.pfUI_throttle.chat_tab_custom = "10" end if not _G.pfUI_throttle.chat_tab_custom then _G.pfUI_throttle.chat_tab_custom = "10" end
-200
View File
@@ -1,200 +0,0 @@
-- load pfUI environment
setfenv(1, pfUI:GetEnvironment())
--[[ libtipscan ]]--
-- A pfUI library that provides tooltip scanner.
--
-- libtipscan:GetScanner(name)
-- returns or resets a scanner for use with tooltip methods
--
-- libtipscan:List()
-- prints a list of all active scanners
--
-- The scanner tooltip returned by :GetScanner has all the Set____ GameTooltip methods with a built-in full clear
-- In addition the scanner has the following custom methods
-- <scanner>:Text()
-- return a table with all the left, right texts in {[line] = {left, right}} format
-- <scanner>:Find(text, [exact])
-- returns true (linenumber) and [the text found or the captures made if text is a pattern]
-- exact is optional flag making it look only for exact matches
-- <scanner>:Color(r,g,b)
-- returns true (linenumber) if the r,g,b color tuple is found as text color on the scanner
-- accepts color table as argument as well (eg. <scanner>:Color(RED_FONT_COLOR) )
-- <scanner>:Line(line_number)
-- returns left, right text from that tooltip line
-- <scanner>:List()
-- prints a list of all available scanner methods
-- return instantly when another libtipscan is already active
if pfUI.api.libtipscan then return end
local libtipscan = {}
local baseName = "pfUIScan"
local methods = {
"SetBagItem", "SetAction", "SetAuctionItem", "SetAuctionSellItem", "SetBuybackItem",
"SetCraftItem", "SetCraftSpell", "SetHyperlink", "SetInboxItem", "SetInventoryItem",
"SetLootItem", "SetLootRollItem", "SetMerchantItem", "SetPetAction", "SetPlayerBuff",
"SetQuestItem", "SetQuestLogItem", "SetQuestRewardSpell", "SetSendMailItem", "SetShapeshift",
"SetSpell", "SetTalent", "SetTrackingSpell", "SetTradePlayerItem", "SetTradeSkillItem", "SetTradeTargetItem",
"SetTrainerService", "SetUnit", "SetUnitBuff", "SetUnitDebuff",
}
local extra_methods = {
"Find", "Line", "Text", "List",
}
local getFontString = function(obj)
local name = obj:GetName()
local r, g, b, color, a
local text, segment
for i=1, obj:NumLines() do
local left = _G[string.format("%sTextLeft%d",name,i)]
segment = left and left:IsVisible() and left:GetText()
segment = segment and segment ~= "" and segment or nil
if segment then
r, g, b, a = left:GetTextColor()
segment = rgbhex(r,g,b) .. segment .. "|r"
text = text and text .. "\n" .. segment or segment
end
end
return text
end
local getText = function(obj)
local name = obj:GetName()
local text = {}
for i=1, obj:NumLines() do
local left, right = _G[string.format("%sTextLeft%d",name,i)], _G[string.format("%sTextRight%d",name,i)]
left = left and left:IsVisible() and left:GetText()
right = right and right:IsVisible() and right:GetText()
left = left and left ~= "" and left or nil
right = right and right ~= "" and right or nil
if left or right then
text[i] = {left, right}
end
end
return text
end
local findText = function(obj, text, exact)
local name = obj:GetName()
for i=1, obj:NumLines() do
local left, right = _G[string.format("%sTextLeft%d",name,i)], _G[string.format("%sTextRight%d",name,i)]
left = left and left:IsVisible() and left:GetText()
right = right and right:IsVisible() and right:GetText()
if exact then
if (left and left == text) or (right and right == text) then
return i, text
end
else
if left then
local found,_,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 = string.find(left, text)
if found then
return i, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10
end
end
if right then
local found,_,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10 = string.find(right, text)
if found then
return i, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10
end
end
end
end
end
local lineText = function(obj, line)
local name = obj:GetName()
if line <= obj:NumLines() then
local left, right = _G[string.format("%sTextLeft%d",name,line)], _G[string.format("%sTextRight%d",name,line)]
left = left and left:IsVisible() and left:GetText()
right = right and right:IsVisible() and right:GetText()
if left or right then
return left, right
end
end
end
local findColor = function(obj, r,g,b)
local name = obj:GetName()
if type(r) == "table" then
r,g,b = r.r or r[1], r.g or r[2], r.b or r[3]
end
for i=1, obj:NumLines() do
local tr, tg, tb
local left, right = _G[string.format("%sTextLeft%d",name,i)], _G[string.format("%sTextRight%d",name,i)]
if left and left:IsVisible() then
tr, tg, tb = left:GetTextColor()
tr, tg, tb = round(tr,1), round(tg,1), round(tb,1)
end
if tr and (tr == r and tg == g and tb == b) then
return i
end
if right and right:IsVisible() then
tr, tg, tb = right:GetTextColor()
tr, tg, tb = round(tr,1), round(tg,1), round(tb,1)
end
if tr and (tr == r and tg == g and tb == b) then
return i
end
end
end
libtipscan._registry = setmetatable({},{__index = function(t,k)
local v = CreateFrame("GameTooltip", string.format("%s%s",baseName,k), nil, "GameTooltipTemplate")
v:SetOwner(WorldFrame,"ANCHOR_NONE")
v:SetScript("OnHide", function ()
this:SetOwner(WorldFrame,"ANCHOR_NONE")
end)
function v:Text()
return getText(self)
end
function v:FontString()
return getFontString(self)
end
function v:Find(text, exact)
return findText(self, text, exact)
end
function v:Color(r,g,b)
return findColor(self,r,g,b)
end
function v:Line(line)
return lineText(self, line)
end
for _,method in ipairs(methods) do
local method = method
local old = v[method]
v[method] = function(v, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
v:ClearLines()
v:SetOwner(WorldFrame, "ANCHOR_NONE")
return old(v, a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
end
end
function v:List()
table.sort(methods)
for _,method in ipairs(methods) do
print(method)
end
for _,method in ipairs(extra_methods) do
print(method)
end
end
rawset(t,k,v)
return v
end})
function libtipscan:GetScanner(type)
local scanner = self._registry[type]
scanner:ClearLines()
return scanner
end
function libtipscan:List()
for name, scanner in pairs(self._registry) do
print(name)
end
end
-- add libtipscan to pfUI API
pfUI.api.libtipscan = libtipscan
+48 -106
View File
@@ -2,37 +2,26 @@
setfenv(1, pfUI:GetEnvironment()) setfenv(1, pfUI:GetEnvironment())
--[[ libunitscan ]]-- --[[ libunitscan ]]--
-- A pfUI library that detects and saves all kind of unit related informations. -- A pfUI library that remembers the class, level and guild of every player it
-- Such as level, class, elite-state and playertype. Each query causes the library -- sees: in the friends, guild, raid and party rosters, in /who results, and as
-- to automatically scan for the target if not already existing. Player-data is -- target, mouseover or nameplate. The data is persisted within pfUI_playerDB,
-- persisted within the pfUI_playerDB where the mob data is a throw-away table. -- for the places that only have a player's name, such as chat links and
-- The automatic target scanner is only working for vanilla due to client limitations -- offline friends. Anything with a unit reads the unit itself instead.
-- on further expansions.
-- --
-- External functions: -- External functions:
-- GetUnitInfo(name, active, isPlayer) -- GetUnitInfo(name)
-- Returns information of the given unitname. Returns nil if no match is found. -- Returns information of the given player name. Returns nil if the player
-- When nothing is found and the active flag is set, the autoscanner will -- was never seen.
-- automatically pick it up and try to fill the missing entry by targetting the unit.
-- Pass isPlayer=true/false to restrict the lookup to the players or mobs table
-- (avoids name-collision false positives, e.g. a player and an NPC named Chromie).
-- --
-- class[String] - The class of the unit -- class[String] - The class of the player
-- level[Number] - The level of the unit -- level[Number] - The level of the player
-- elite[String] - The elite state of the unit (See UnitClassification()) -- guild[String] - The guild name of the player
-- player[Boolean] - Returns true if unit is a player
-- guild[String] - Returns guild name of unit is a player
--
-- Internal functions:
-- libunitscan:AddData(db, name, class, level, elite)
-- Adds unit data to a given db. Where db should be either "players" or "mobs"
-- --
-- return instantly when another libunitscan is already active -- return instantly when another libunitscan is already active
if pfUI.api.libunitscan then return end if pfUI.api.libunitscan then return end
local units = { players = {}, mobs = {} } local players = {}
local queue = { }
-- Feed (guid, name, classToken) into ClassicAPI's persistent name -- Feed (guid, name, classToken) into ClassicAPI's persistent name
-- cache when the unit's GUID is resolvable. Roster-style packets -- cache when the unit's GUID is resolvable. Roster-style packets
@@ -46,28 +35,19 @@ local function RememberByUnit(unit, name, class)
C_PlayerCache.RememberPlayer(guid, name, class, UnitRace(unit), UnitSex(unit)) C_PlayerCache.RememberPlayer(guid, name, class, UnitRace(unit), UnitSex(unit))
end end
function GetUnitInfo(name, active, isPlayer) function GetUnitInfo(name)
if isPlayer ~= false and units["players"][name] then local ret = players[name]
local ret = units["players"][name] if ret then
return ret.class, ret.level, ret.elite, true, ret.guild return ret.class, ret.level, ret.guild
elseif isPlayer ~= true and units["mobs"][name] then
local ret = units["mobs"][name]
return ret.class, ret.level, ret.elite, nil, ret.guild
elseif active then
queue[name] = true
libunitscan:Show()
end end
end end
local function AddData(db, name, class, level, elite, guild) local function AddData(name, class, level, guild)
if not name or not db then return end if not name then return end
units[db] = units[db] or {} players[name] = players[name] or {}
units[db][name] = units[db][name] or {} players[name].class = class or players[name].class
units[db][name].class = class or units[db][name].class players[name].level = level or players[name].level
units[db][name].level = level or units[db][name].level players[name].guild = guild or players[name].guild
units[db][name].elite = elite or units[db][name].elite
units[db][name].guild = guild or units[db][name].guild
queue[name] = nil
end end
local libunitscan = CreateFrame("Frame", "pfUnitScan", UIParent) local libunitscan = CreateFrame("Frame", "pfUnitScan", UIParent)
@@ -85,116 +65,78 @@ libunitscan:SetScript("OnEvent", function()
if event == "PLAYER_ENTERING_WORLD" then if event == "PLAYER_ENTERING_WORLD" then
-- load pfUI_playerDB -- load pfUI_playerDB
units.players = pfUI_playerDB players = pfUI_playerDB
-- update own character details -- update own character details
local name = UnitName("player") local name = UnitName("player")
local _, class = UnitClass("player") local class = UnitClassBase("player")
local level = UnitLevel("player") local level = UnitLevel("player")
local guild = GetGuildInfo("player") local guild = GetGuildInfo("player")
AddData("players", name, class, level, nil, guild) AddData(name, class, level, guild)
RememberByUnit("player", name, class) RememberByUnit("player", name, class)
elseif event == "FRIENDLIST_UPDATE" then elseif event == "FRIENDLIST_UPDATE" then
local name, class, level
for i = 1, GetNumFriends() do for i = 1, GetNumFriends() do
name, level, class = GetFriendInfo(i) local info = C_FriendList.GetFriendInfoByIndex(i)
class = L["class"][class] or nil if info then
-- friendlist updates due to friend going off-line return level 0, let's not overwrite good older values local level = info.level > 0 and info.level or nil
level = level > 0 and level or nil AddData(info.name, info.classFilename, level)
AddData("players", name, class, level) end
end end
elseif event == "GUILD_ROSTER_UPDATE" then elseif event == "GUILD_ROSTER_UPDATE" then
local name, class, level, _, guild local guild = GetGuildInfo("player")
local name, class, level, _
for i = 1, GetNumGuildMembers() do for i = 1, GetNumGuildMembers() do
name, _, _, level, class = GetGuildRosterInfo(i) name, _, _, level, class = GetGuildRosterInfo(i)
guild = GetGuildInfo("player")
class = L["class"][class] or nil class = L["class"][class] or nil
AddData("players", name, class, level, nil, guild) AddData(name, class, level, guild)
end end
elseif event == "RAID_ROSTER_UPDATE" then elseif event == "RAID_ROSTER_UPDATE" then
local name, class, SubGroup, level, unit, _ local name, class, level, unit, _
for i = 1, GetNumRaidMembers() do for i = 1, GetNumRaidMembers() do
unit = "raid" .. i unit = "raid" .. i
name, _, SubGroup, level, class = GetRaidRosterInfo(i) name, _, _, level, class = GetRaidRosterInfo(i)
class = L["class"][class] or nil class = L["class"][class] or nil
AddData("players", name, class, level) AddData(name, class, level)
RememberByUnit(unit, name, class) RememberByUnit(unit, name, class)
end end
elseif event == "PARTY_MEMBERS_CHANGED" then elseif event == "PARTY_MEMBERS_CHANGED" then
local name, class, level, unit, _, guild local name, class, level, unit, guild
for i = 1, GetNumPartyMembers() do for i = 1, GetNumPartyMembers() do
unit = "party" .. i unit = "party" .. i
_, class = UnitClass(unit) class = UnitClassBase(unit)
name = UnitName(unit) name = UnitName(unit)
level = UnitLevel(unit) level = UnitLevel(unit)
guild = GetGuildInfo(unit) guild = GetGuildInfo(unit)
AddData("players", name, class, level, nil, guild) AddData(name, class, level, guild)
RememberByUnit(unit, name, class) RememberByUnit(unit, name, class)
end end
elseif event == "WHO_LIST_UPDATE" or event == "CHAT_MSG_SYSTEM" then elseif event == "WHO_LIST_UPDATE" or event == "CHAT_MSG_SYSTEM" then
local name, class, level, guild, _ for i = 1, C_FriendList.GetNumWhoResults() do
for i = 1, GetNumWhoResults() do local info = C_FriendList.GetWhoInfo(i)
name, guild, level, _, class, _ = GetWhoInfo(i) if info then
class = L["class"][class] or nil AddData(info.fullName, info.filename, info.level, info.fullGuildName)
AddData("players", name, class, level, nil, guild) end
end end
elseif event == "UPDATE_MOUSEOVER_UNIT" or event == "PLAYER_TARGET_CHANGED" or event == "NAME_PLATE_UNIT_ADDED" then elseif event == "UPDATE_MOUSEOVER_UNIT" or event == "PLAYER_TARGET_CHANGED" or event == "NAME_PLATE_UNIT_ADDED" then
local scan = event == "PLAYER_TARGET_CHANGED" and "target" local scan = event == "PLAYER_TARGET_CHANGED" and "target"
or event == "NAME_PLATE_UNIT_ADDED" and arg1 or event == "NAME_PLATE_UNIT_ADDED" and arg1
or "mouseover" or "mouseover"
local name, class, level, elite, guild, _
if UnitIsPlayer(scan) then if UnitIsPlayer(scan) then
_, class = UnitClass(scan) local name = UnitName(scan)
level = UnitLevel(scan) local class = UnitClassBase(scan)
-- UnitLevel returns -1 for unknown levels, don't overwrite known values -- UnitLevel returns -1 for unknown levels, don't overwrite known values
local level = UnitLevel(scan)
level = level > 0 and level or nil level = level > 0 and level or nil
name = UnitName(scan) AddData(name, class, level, GetGuildInfo(scan))
guild = GetGuildInfo(scan)
AddData("players", name, class, level, nil, guild)
RememberByUnit(scan, name, class) RememberByUnit(scan, name, class)
else
_, class = UnitClass(scan)
elite = UnitClassification(scan)
level = UnitLevel(scan)
-- UnitLevel returns -1 for unknown levels, don't overwrite known values
level = level > 0 and level or nil
name = UnitName(scan)
guild = UnitSubName(scan)
AddData("mobs", name, class, level, elite, guild)
end end
end end
end) end)
-- setup sound function switches
local SoundOn = PlaySound
local SoundOff = function() return end
libunitscan:SetScript("OnUpdate", function()
-- don't scan when another unit is in target
if UnitExists("target") or UnitName("target") then return end
local name = next(queue)
if name then
-- disable sound
_G.PlaySound = SoundOff
-- try to target the unknown unit
TargetByName(name, true)
ClearTarget()
-- enable sound again
_G.PlaySound = SoundOn
queue[name] = nil
end
this:Hide()
end)
pfUI.api.libunitscan = libunitscan pfUI.api.libunitscan = libunitscan
+296 -389
View File
File diff suppressed because it is too large Load Diff
+23 -31
View File
@@ -37,15 +37,10 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons.minimapbutton = CreateFrame("Button", "pfMinimapButton", pfUI.minimap or UIParent) pfUI.addonbuttons.minimapbutton = CreateFrame("Button", "pfMinimapButton", pfUI.minimap or UIParent)
pfUI.addonbuttons.minimapbutton:SetFrameLevel(24) pfUI.addonbuttons.minimapbutton:SetFrameLevel(24)
pfUI.addonbuttons.minimapbutton:SetWidth(12) pfUI.addonbuttons.minimapbutton:SetSize(12, 12)
pfUI.addonbuttons.minimapbutton:SetHeight(12)
pfUI.addonbuttons.minimapbutton:SetScript("OnClick", function() pfUI.addonbuttons.minimapbutton:SetScript("OnClick", function()
if pfUI.addonbuttons:IsShown() then pfUI.addonbuttons:SetShown(not pfUI.addonbuttons:IsShown())
pfUI.addonbuttons:Hide()
else
pfUI.addonbuttons:Show()
end
end) end)
pfUI.addonbuttons.buttons = {} pfUI.addonbuttons.buttons = {}
@@ -163,27 +158,25 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons:SetScale(pfUI.minimap:GetScale()) pfUI.addonbuttons:SetScale(pfUI.minimap:GetScale())
pfUI.addonbuttons.minimapbutton:ClearAllPoints() pfUI.addonbuttons.minimapbutton:ClearAllPoints()
local mbtnWidth, mbtnHeight = pfUI.minimap:GetSize()
local dynamicSize = ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)
if C.abuttons.position == "bottom" then if C.abuttons.position == "bottom" then
pfUI.addonbuttons:SetWidth(pfUI.minimap:GetWidth()) pfUI.addonbuttons:SetSize(mbtnWidth, dynamicSize)
pfUI.addonbuttons:SetHeight(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing))
pfUI.addonbuttons:SetPoint("TOP", pfUI.minimap, "BOTTOM", 0 , -default_border * 3) pfUI.addonbuttons:SetPoint("TOP", pfUI.minimap, "BOTTOM", 0 , -default_border * 3)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "down") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "down")
pfUI.addonbuttons.minimapbutton:SetPoint("BOTTOM", pfUI.minimap, "BOTTOM", 0, 4) pfUI.addonbuttons.minimapbutton:SetPoint("BOTTOM", pfUI.minimap, "BOTTOM", 0, 4)
elseif C.abuttons.position == "left" then elseif C.abuttons.position == "left" then
pfUI.addonbuttons:SetWidth(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)) pfUI.addonbuttons:SetSize(dynamicSize, mbtnHeight)
pfUI.addonbuttons:SetHeight(pfUI.minimap:GetHeight())
pfUI.addonbuttons:SetPoint("TOPRIGHT", pfUI.minimap, "TOPLEFT", -default_border * 3, 0) pfUI.addonbuttons:SetPoint("TOPRIGHT", pfUI.minimap, "TOPLEFT", -default_border * 3, 0)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "left") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "left")
pfUI.addonbuttons.minimapbutton:SetPoint("LEFT", pfUI.minimap, "LEFT", 4, 0) pfUI.addonbuttons.minimapbutton:SetPoint("LEFT", pfUI.minimap, "LEFT", 4, 0)
elseif C.abuttons.position == "top" then elseif C.abuttons.position == "top" then
pfUI.addonbuttons:SetWidth(pfUI.minimap:GetWidth()) pfUI.addonbuttons:SetSize(mbtnWidth, dynamicSize)
pfUI.addonbuttons:SetHeight(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing))
pfUI.addonbuttons:SetPoint("BOTTOM", pfUI.minimap, "TOP", 0 , default_border * 3) pfUI.addonbuttons:SetPoint("BOTTOM", pfUI.minimap, "TOP", 0 , default_border * 3)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "up") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "up")
pfUI.addonbuttons.minimapbutton:SetPoint("TOP", pfUI.minimap, "TOP", 0, -4) pfUI.addonbuttons.minimapbutton:SetPoint("TOP", pfUI.minimap, "TOP", 0, -4)
elseif C.abuttons.position == "right" then elseif C.abuttons.position == "right" then
pfUI.addonbuttons:SetWidth(ceil((GetNumButtons() > 0 and GetNumButtons() or 1) / tonumber(C.abuttons.rowsize)) * GetStringSize() + tonumber(C.abuttons.spacing)) pfUI.addonbuttons:SetSize(dynamicSize, mbtnHeight)
pfUI.addonbuttons:SetHeight(pfUI.minimap:GetHeight())
pfUI.addonbuttons:SetPoint("TOPLEFT", pfUI.minimap, "TOPRIGHT", default_border * 3, 0) pfUI.addonbuttons:SetPoint("TOPLEFT", pfUI.minimap, "TOPRIGHT", default_border * 3, 0)
SkinArrowButton(pfUI.addonbuttons.minimapbutton, "right") SkinArrowButton(pfUI.addonbuttons.minimapbutton, "right")
pfUI.addonbuttons.minimapbutton:SetPoint("RIGHT", pfUI.minimap, "RIGHT", -4, 0) pfUI.addonbuttons.minimapbutton:SetPoint("RIGHT", pfUI.minimap, "RIGHT", -4, 0)
@@ -231,7 +224,7 @@ pfUI:RegisterModule("addonbuttons", function ()
frame.backup.is_clamped_to_screen = frame:IsClampedToScreen() frame.backup.is_clamped_to_screen = frame:IsClampedToScreen()
frame.backup.is_movable = frame:IsMovable() frame.backup.is_movable = frame:IsMovable()
frame.backup.point = {frame:GetPoint()} frame.backup.point = {frame:GetPoint()}
frame.backup.size = {frame:GetHeight(), frame:GetWidth()} frame.backup.size = {frame:GetSize()}
frame.backup.scale = frame:GetScale() frame.backup.scale = frame:GetScale()
if frame:HasScript("OnDragStart") then if frame:HasScript("OnDragStart") then
frame.backup.on_drag_start = frame:GetScript("OnDragStart") frame.backup.on_drag_start = frame:GetScript("OnDragStart")
@@ -256,8 +249,7 @@ pfUI:RegisterModule("addonbuttons", function ()
frame:SetClampedToScreen(frame.backup.is_clamped_to_screen) frame:SetClampedToScreen(frame.backup.is_clamped_to_screen)
frame:SetMovable(frame.backup.is_movable) frame:SetMovable(frame.backup.is_movable)
frame:SetScale(frame.backup.scale) frame:SetScale(frame.backup.scale)
frame:SetHeight(frame.backup.size[1]) frame:SetSize(frame.backup.size[2], frame.backup.size[1])
frame:SetWidth(frame.backup.size[2])
frame:ClearAllPoints() frame:ClearAllPoints()
frame:SetPoint(frame.backup.point[1], frame.backup.point[2], frame.backup.point[3], frame.backup.point[4], frame.backup.point[5]) frame:SetPoint(frame.backup.point[1], frame.backup.point[2], frame.backup.point[3], frame.backup.point[4], frame.backup.point[5])
if frame.backup.on_drag_start ~= nil then if frame.backup.on_drag_start ~= nil then
@@ -405,22 +397,22 @@ pfUI:RegisterModule("addonbuttons", function ()
pfUI.addonbuttons:ProcessButtons() pfUI.addonbuttons:ProcessButtons()
end) end)
pfUI.addonbuttons:SetScript("OnUpdate", function() -- Initial setup on the next frame, once other addons' minimap buttons exist
-- check if the panel should be shown by default RunNextFrame(function()
if not this.initialized then -- rescan before deciding whether the panel should be shown by default
if C.abuttons.showdefault == "1" and GetNumButtons() > 0 then pfUI.addonbuttons:ProcessButtons()
pfUI.addonbuttons:Show()
else
pfUI.addonbuttons:Hide()
end
-- update all buttons pfUI.addonbuttons:SetShown(C.abuttons.showdefault == "1" and GetNumButtons() > 0)
pfUI.addonbuttons:ProcessButtons()
this.initialized = true -- apply workarounds
for k, v in pairs(pfUI.addonbuttons.overrides) do
_G[k] = v
end end
end)
-- throttle updates to once per 5 seconds -- Rescan minimap buttons every 5 seconds while the panel is shown
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + 5 end C_Timer.NewTicker(5, function()
if not pfUI.addonbuttons:IsShown() then return end
-- reload/rescan minimap buttons -- reload/rescan minimap buttons
pfUI.addonbuttons:ProcessButtons() pfUI.addonbuttons:ProcessButtons()
+1 -1
View File
@@ -128,7 +128,7 @@ pfUI:RegisterModule("addoncompat", function ()
{T["Yes"], function() {T["Yes"], function()
ReloadUI() ReloadUI()
end}, end},
{T["No"], function() end}, {T["No"], nop},
nil) nil)
end end
end end
+126 -178
View File
@@ -9,7 +9,6 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons:Show() pfUI.addons:Show()
HideUIPanel(GameMenuFrame) HideUIPanel(GameMenuFrame)
end) end)
SkinButton(pfUIAddonButton)
local point, relativeTo, relativePoint, xOffset, yOffset = GameMenuButtonOptions:GetPoint() local point, relativeTo, relativePoint, xOffset, yOffset = GameMenuButtonOptions:GetPoint()
GameMenuButtonOptions:SetPoint(point, relativeTo, relativePoint, xOffset, yOffset - 22) GameMenuButtonOptions:SetPoint(point, relativeTo, relativePoint, xOffset, yOffset - 22)
@@ -18,8 +17,7 @@ pfUI:RegisterModule("addons", function ()
-- addon window -- addon window
pfUI.addons = CreateFrame("Frame", "pfAddons", UIParent) pfUI.addons = CreateFrame("Frame", "pfAddons", UIParent)
pfUI.addons:SetFrameStrata("DIALOG") pfUI.addons:SetFrameStrata("DIALOG")
pfUI.addons:SetHeight(490) pfUI.addons:SetSize(380, 490)
pfUI.addons:SetWidth(380)
pfUI.addons:SetPoint("CENTER", 0,0) pfUI.addons:SetPoint("CENTER", 0,0)
pfUI.addons:EnableMouseWheel(1) pfUI.addons:EnableMouseWheel(1)
pfUI.addons:SetMovable(true) pfUI.addons:SetMovable(true)
@@ -51,8 +49,7 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons.close = CreateFrame("Button", "pfBagClose", pfUI.addons) pfUI.addons.close = CreateFrame("Button", "pfBagClose", pfUI.addons)
pfUI.addons.close:SetPoint("TOPRIGHT", -border*2,-border*2 ) pfUI.addons.close:SetPoint("TOPRIGHT", -border*2,-border*2 )
CreateBackdrop(pfUI.addons.close) CreateBackdrop(pfUI.addons.close)
pfUI.addons.close:SetHeight(15) pfUI.addons.close:SetSize(15, 15)
pfUI.addons.close:SetWidth(15)
pfUI.addons.close.texture = pfUI.addons.close:CreateTexture("pfBagClose") pfUI.addons.close.texture = pfUI.addons.close:CreateTexture("pfBagClose")
pfUI.addons.close.texture:SetTexture(pfUI.media["img:close"]) pfUI.addons.close.texture:SetTexture(pfUI.media["img:close"])
pfUI.addons.close.texture:ClearAllPoints() pfUI.addons.close.texture:ClearAllPoints()
@@ -72,17 +69,53 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons:Hide() pfUI.addons:Hide()
end) end)
-- installed addons, one entry per row of the addon list
local addons = {}
for i = 1, GetNumAddOns() do
local name, title, notes = GetAddOnInfo(i)
addons[i] = {
index = i,
name = name,
title = title,
notes = notes,
author = GetAddOnMetadata(name, "Author"),
version = GetAddOnMetadata(name, "Version"),
deps = { GetAddOnDependencies(i) }, -- required (.toc Dependencies)
optdeps = { C_AddOns.GetAddOnOptionalDependencies(i) }, -- optional (.toc OptionalDeps)
}
end
local function IsAddonEnabled(index)
local _, _, _, enabled = GetAddOnInfo(index)
return enabled
end
local function SetAddonEnabled(index, enabled)
if enabled then
EnableAddOn(index)
else
DisableAddOn(index)
end
pfUI.addons.hasChanged = true
end
-- addons profile -- addons profile
local function GetSelectedAddonsList() local function GetSelectedAddonsList()
local selected_addons = {} local selected_addons = {}
for i, frame in ipairs(pfUI.addons.list) do for i, addon in ipairs(addons) do
if frame.input:GetChecked() then if IsAddonEnabled(i) then
table.insert(selected_addons, frame.aname) table.insert(selected_addons, addon.name)
end end
end end
return selected_addons return selected_addons
end end
local selectedProfile
local function IsSelectedProfile(profile)
return profile == selectedProfile
end
local function SetAddonProfile(profile) local function SetAddonProfile(profile)
-- create new profile if not existing -- create new profile if not existing
if not pfUI_addon_profiles[profile] then if not pfUI_addon_profiles[profile] then
@@ -90,31 +123,24 @@ pfUI:RegisterModule("addons", function ()
end end
-- set dropdown to profile -- set dropdown to profile
pfUI.addons.profile.dropdown:SetSelectionByText(profile) selectedProfile = profile
pfUI.addons.profile.dropdown:GenerateMenu()
-- load profile -- load profile
local selected_list = pfUI_addon_profiles[profile] local selected = {}
for i=1, GetNumAddOns() do for _, name in ipairs(pfUI_addon_profiles[profile]) do
local active = false selected[name] = true
local f = pfUI.addons.list[i] end
for i_i, n in ipairs(selected_list) do for i, addon in ipairs(addons) do
if f.aname == n then if selected[addon.name] and not IsAddonEnabled(i) then
active = true SetAddonEnabled(i, true)
break elseif not selected[addon.name] and IsAddonEnabled(i) then
end SetAddonEnabled(i, false)
end
if active then
if not f.input:GetChecked() then
f.input:Click()
end
else
if f.input:GetChecked() then
f.input:Click()
end
end end
end end
pfUI.addons.list.ScrollBox:ReinitializeFrames()
end end
-- addon profiles -- addon profiles
@@ -125,8 +151,7 @@ pfUI:RegisterModule("addons", function ()
end) end)
pfUI.addons.profile:SetPoint("TOP", pfUI.addons, "TOP", 0, -30) pfUI.addons.profile:SetPoint("TOP", pfUI.addons, "TOP", 0, -30)
pfUI.addons.profile:SetHeight(30) pfUI.addons.profile:SetSize(370, 30)
pfUI.addons.profile:SetWidth(370)
CreateBackdrop(pfUI.addons.profile, nil, true) CreateBackdrop(pfUI.addons.profile, nil, true)
-- addon profile: title -- addon profile: title
@@ -139,14 +164,13 @@ pfUI:RegisterModule("addons", function ()
-- addon profile: delete -- addon profile: delete
pfUI.addons.profile.del = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate") pfUI.addons.profile.del = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate")
SkinButton(pfUI.addons.profile.del) SkinButton(pfUI.addons.profile.del)
pfUI.addons.profile.del:SetWidth(16) pfUI.addons.profile.del:SetSize(16, 16)
pfUI.addons.profile.del:SetHeight(16)
pfUI.addons.profile.del:SetPoint("RIGHT", -10, 0) pfUI.addons.profile.del:SetPoint("RIGHT", -10, 0)
pfUI.addons.profile.del:GetFontString():SetPoint("CENTER", 1, 0) pfUI.addons.profile.del:GetFontString():SetPoint("CENTER", 1, 0)
pfUI.addons.profile.del:SetText("-") pfUI.addons.profile.del:SetText("-")
pfUI.addons.profile.del:SetTextColor(1,.5,.5,1) pfUI.addons.profile.del:SetTextColor(1,.5,.5,1)
pfUI.addons.profile.del:SetScript("OnClick", function() -- TODO pfUI.addons.profile.del:SetScript("OnClick", function() -- TODO
local id, name = pfUI.addons.profile.dropdown:GetSelection() local name = selectedProfile
if not name then return end if not name then return end
CreateQuestionDialog(T["Delete profile"] .. " '|cff33ffcc" .. name .. "|r'?", function() CreateQuestionDialog(T["Delete profile"] .. " '|cff33ffcc" .. name .. "|r'?", function()
pfUI_addon_profiles[name] = nil pfUI_addon_profiles[name] = nil
@@ -157,8 +181,7 @@ pfUI:RegisterModule("addons", function ()
-- addon profile: create -- addon profile: create
pfUI.addons.profile.add = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate") pfUI.addons.profile.add = CreateFrame("Button", nil, pfUI.addons.profile, "UIPanelButtonTemplate")
SkinButton(pfUI.addons.profile.add) SkinButton(pfUI.addons.profile.add)
pfUI.addons.profile.add:SetWidth(16) pfUI.addons.profile.add:SetSize(16, 16)
pfUI.addons.profile.add:SetHeight(16)
pfUI.addons.profile.add:SetPoint("RIGHT", pfUI.addons.profile.del, "LEFT", -4, 0) pfUI.addons.profile.add:SetPoint("RIGHT", pfUI.addons.profile.del, "LEFT", -4, 0)
pfUI.addons.profile.add:GetFontString():SetPoint("CENTER", 1, 0) pfUI.addons.profile.add:GetFontString():SetPoint("CENTER", 1, 0)
pfUI.addons.profile.add:SetText("+") pfUI.addons.profile.add:SetText("+")
@@ -177,46 +200,15 @@ pfUI:RegisterModule("addons", function ()
end) end)
-- addon profile: dropdown -- addon profile: dropdown
pfUI.addons.profile.dropdown = CreateDropDownButton("pfAddonListProfileList", pfUI.addons.profile) pfUI.addons.profile.dropdown = CreateFrame("DropdownButton", nil, pfUI.addons.profile, "pfUIDropdownTemplate")
pfUI.addons.profile.dropdown:SetBackdrop(nil)
pfUI.addons.profile.dropdown:ClearAllPoints()
pfUI.addons.profile.dropdown:SetPoint("RIGHT", pfUI.addons.profile.add, "LEFT", -2, 0) pfUI.addons.profile.dropdown:SetPoint("RIGHT", pfUI.addons.profile.add, "LEFT", -2, 0)
pfUI.addons.profile.dropdown:SetWidth(220) pfUI.addons.profile.dropdown:SetWidth(220)
pfUI.addons.profile.dropdown:SetMenu(function() pfUI.addons.profile.dropdown:SetupMenu(function(dropdown, rootDescription)
local menu = {} for name in pairs(pfUI_addon_profiles) do
rootDescription:CreateRadio(name, IsSelectedProfile, SetAddonProfile, name)
for name, list in pairs(pfUI_addon_profiles) do
local name = name
local entry = {}
entry.text = name
entry.checked = false
entry.func = function()
SetAddonProfile(name)
end
table.insert(menu, entry)
end end
return menu
end) end)
-- addon list: scroll frame
pfUI.addons.scroll = CreateScrollFrame("pfAddonListScroll", pfUI.addons)
pfUI.addons.scroll:SetWidth(360)
pfUI.addons.scroll:SetHeight(410)
pfUI.addons.scroll:SetPoint("BOTTOM", 0, 10)
pfUI.addons.scroll.backdrop = CreateFrame("Frame", nil, pfUI.addons.scroll)
pfUI.addons.scroll.backdrop:SetFrameLevel(1)
pfUI.addons.scroll.backdrop:SetPoint("TOPLEFT", pfUI.addons.scroll, "TOPLEFT", -5, 5)
pfUI.addons.scroll.backdrop:SetPoint("BOTTOMRIGHT", pfUI.addons.scroll, "BOTTOMRIGHT", 5, -5)
CreateBackdrop(pfUI.addons.scroll.backdrop, nil, true)
-- addon list: scroll parent
pfUI.addons.list = CreateScrollChild("pfAddonList", pfUI.addons.scroll)
pfUI.addons.list:RegisterEvent("ADDON_LOADED")
pfUI.addons.list:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.addons.list:SetHeight(GetNumAddOns() * 25 + 26)
local function AddDependencyLines(header, deps) local function AddDependencyLines(header, deps)
if not deps or table.getn(deps) == 0 then return end if not deps or table.getn(deps) == 0 then return end
GameTooltip:AddLine(" ") GameTooltip:AddLine(" ")
@@ -232,138 +224,94 @@ pfUI:RegisterModule("addons", function ()
end end
end end
local function AddonOnEnter() local function RowOnEnter(self)
this:SetBackdropBorderColor(1,1,1,.08) local addon = self.addon
self:SetBackdropBorderColor(1,1,1,.08)
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(self, "ANCHOR_RIGHT")
GameTooltip:SetText(this.atitle) GameTooltip:SetText(addon.title)
if this.aversion then if addon.version then
GameTooltip:AddDoubleLine(T["Version"], this.aversion, 1,1,1, .2,1,.8) GameTooltip:AddDoubleLine(T["Version"], addon.version, 1,1,1, .2,1,.8)
end end
if this.aauthor then if addon.author then
GameTooltip:AddDoubleLine(T["Author"], this.aauthor, 1,1,1, .2,1,.8) GameTooltip:AddDoubleLine(T["Author"], addon.author, 1,1,1, .2,1,.8)
end end
GameTooltip:AddLine(this.anote, .75,.75,.75,1) GameTooltip:AddLine(addon.notes, .75,.75,.75,1)
AddDependencyLines(T["Dependencies"], this.adeps) AddDependencyLines(T["Dependencies"], addon.deps)
AddDependencyLines(T["Optional Dependencies"], this.aoptdeps) AddDependencyLines(T["Optional Dependencies"], addon.optdeps)
GameTooltip:SetWidth(180) GameTooltip:SetWidth(180)
GameTooltip:Show() GameTooltip:Show()
end end
local function AddonOnLeave() local function RowOnLeave(self)
this:SetBackdropBorderColor(1,1,1,.04) self:SetBackdropBorderColor(1,1,1,.04)
GameTooltip:Hide() GameTooltip:Hide()
end end
local function AddonOnClick() local function RowOnClick(self)
this.input:Click() self.input:Click()
end end
local function InputOnClick() local function InputOnClick(self)
if this:GetChecked() then SetAddonEnabled(self:GetParent().addon.index, self:GetChecked())
EnableAddOn(this:GetID())
else
DisableAddOn(this:GetID())
end
pfUI.addons.hasChanged = true
local id, name = pfUI.addons.profile.dropdown:GetSelection() pfUI_addon_profiles[selectedProfile or T["Current"]] = GetSelectedAddonsList()
name = name or T["Current"]
pfUI_addon_profiles[name] = GetSelectedAddonsList()
end end
pfUI.addons.list:SetScript("OnEvent", function() local function InitRow(row, addon)
for i=1, GetNumAddOns() do -- one-time setup of a pooled row
local aname, atitle, anote = GetAddOnInfo(i) if not row.input then
local aauthor = GetAddOnMetadata(aname, "Author") row:SetBackdrop(pfUI.backdrop_hover)
local aversion = GetAddOnMetadata(aname, "Version") row:SetBackdropBorderColor(1,1,1,.04)
-- basic frame row:EnableMouse(true)
if not pfUI.addons.list[i] then row:SetScript("OnEnter", RowOnEnter)
pfUI.addons.list[i] = CreateFrame("Button", nil, pfUI.addons.list) row:SetScript("OnLeave", RowOnLeave)
local frame = pfUI.addons.list[i] row:SetScript("OnClick", RowOnClick)
frame.aname = aname
frame.atitle = atitle
frame.anote = anote
frame.aauthor = aauthor
frame.aversion = aversion
frame.adeps = { GetAddOnDependencies(i) } -- required (.toc Dependencies)
frame.aoptdeps = { C_AddOns.GetAddOnOptionalDependencies(i) } -- optional (.toc OptionalDeps)
frame:SetWidth(340) -- caption
frame:SetHeight(25) row.caption = row:CreateFontString(nil, "LOW", "GameFontNormal")
frame:SetPoint("TOPLEFT", 5, i * -25 + 20) row.caption:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE")
row.caption:SetPoint("LEFT", row, "LEFT", 2, 0)
row.caption:SetFontObject(GameFontWhite)
row.caption:SetJustifyH("LEFT")
frame:SetBackdrop(pfUI.backdrop_hover) -- input field
frame:SetBackdropBorderColor(1,1,1,.04) row.input = CreateFrame("CheckButton", nil, row, "UICheckButtonTemplate")
row.input:SetNormalTexture("")
frame:EnableMouse(1) row.input:SetPushedTexture("")
frame:SetScript("OnEnter", AddonOnEnter) row.input:SetHighlightTexture("")
frame:SetScript("OnLeave", AddonOnLeave) CreateBackdrop(row.input, nil, true)
frame:SetScript("OnClick", AddonOnClick) row.input:SetBackdropBorderColor(.3,.3,.3,1)
row.input:SetSize(14, 14)
-- caption row.input:SetPoint("RIGHT" , -5, 1)
frame.caption = frame:CreateFontString("Status", "LOW", "GameFontNormal") row.input:SetScript("OnClick", InputOnClick)
frame.caption:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE")
frame.caption:SetPoint("LEFT", frame, "LEFT", 2, 0)
frame.caption:SetFontObject(GameFontWhite)
frame.caption:SetJustifyH("LEFT")
frame.caption:SetText(atitle)
-- input field
frame.input = CreateFrame("CheckButton", nil, frame, "UICheckButtonTemplate")
frame.input:SetFrameLevel(3)
frame.input:SetNormalTexture("")
frame.input:SetPushedTexture("")
frame.input:SetHighlightTexture("")
CreateBackdrop(frame.input, nil, true)
frame.input:SetBackdropBorderColor(.3,.3,.3,1)
frame.input:SetWidth(14)
frame.input:SetHeight(14)
frame.input:SetPoint("RIGHT" , -5, 1)
frame.input:SetID(i)
frame.input:SetScript("OnClick", InputOnClick)
end
if IsAddOnLoaded(i) then
pfUI.addons.list[i].input:SetChecked()
pfUI.addons.list[i].caption:SetAlpha(1)
else
pfUI.addons.list[i].caption:SetAlpha(.5)
end
end end
end)
-- show only frames in visible range row.addon = addon
function pfUI.addons.scroll:ShowVisibleRange() row.caption:SetText(addon.title)
local top_index, bottom_index, range row.caption:SetAlpha(IsAddOnLoaded(addon.index) and 1 or .5)
range = floor(pfUI.addons.scroll:GetHeight() / 25) + 1 row.input:SetChecked(IsAddonEnabled(addon.index))
top_index = floor(pfUI.addons.scroll:GetVerticalScroll() / 25) > 0 and floor(pfUI.addons.scroll:GetVerticalScroll() / 25) or 1
bottom_index = top_index + range
for i=1, GetNumAddOns() do
if i >= top_index and i <= bottom_index then
pfUI.addons.list[i]:Show()
else
pfUI.addons.list[i]:Hide()
end
end
end end
pfUI.addons.scroll.slider:SetScript("OnValueChanged", function() -- addon list: a ScrollBox keeps rows only for the addons in view
this:GetParent():SetVerticalScroll(this:GetValue()) pfUI.addons.list = CreateFrame("Frame", "pfAddonList", pfUI.addons, "pfUIScrollBoxListTemplate")
end) pfUI.addons.list:SetSize(370, 420)
pfUI.addons.scroll:SetScript("OnScrollRangeChanged", function() pfUI.addons.list:SetPoint("BOTTOM", 0, 5)
this.slider:SetMinMaxValues(1, floor(this:GetVerticalScrollRange() + 25)) CreateBackdrop(pfUI.addons.list, nil, true)
end)
pfUI.addons.scroll:SetScript("OnShow", function() local view = CreateScrollBoxListLinearView(5, 5, 5, 8)
this.slider:SetValue(floor(this:GetVerticalScroll())) view:SetElementExtent(25)
pfUI.addons.scroll:ShowVisibleRange() view:SetElementInitializer("Button", InitRow)
end) ScrollUtil.InitScrollBoxListWithScrollBar(pfUI.addons.list.ScrollBox, pfUI.addons.list.ScrollBar, view)
pfUI.addons.scroll:SetScript("OnVerticalScroll", function() pfUI.addons.list.ScrollBox:SetDataProvider(CreateDataProvider(addons))
pfUI.addons.scroll:ShowVisibleRange()
this.slider:SetValue(floor(this:GetVerticalScroll())) -- a load-on-demand addon that loads brightens its row
pfUI.addons.list:RegisterEvent("ADDON_LOADED")
pfUI.addons.list:SetScript("OnEvent", function(self)
self.ScrollBox:ReinitializeFrames()
end) end)
end) end)
+18 -21
View File
@@ -16,40 +16,39 @@ pfUI:RegisterModule("afkcam", function ()
overlay.top:SetPoint("TOPLEFT", overlay, "TOPLEFT") overlay.top:SetPoint("TOPLEFT", overlay, "TOPLEFT")
overlay.top:SetPoint("TOPRIGHT", overlay, "TOPRIGHT") overlay.top:SetPoint("TOPRIGHT", overlay, "TOPRIGHT")
overlay.top:SetHeight(100) overlay.top:SetHeight(100)
overlay.top:SetTexture(1,1,1,1) overlay.top:SetColorTexture(1,1,1,1)
overlay.top:SetGradientAlpha("VERTICAL", 0,0,0,0, 0,0,0,1) overlay.top:SetGradientAlpha("VERTICAL", 0,0,0,0, 0,0,0,1)
overlay.bottom = overlay:CreateTexture("pfAFKGradientTop", "BACKGROUND") overlay.bottom = overlay:CreateTexture("pfAFKGradientTop", "BACKGROUND")
overlay.bottom:SetPoint("BOTTOMLEFT", overlay, "BOTTOMLEFT") overlay.bottom:SetPoint("BOTTOMLEFT", overlay, "BOTTOMLEFT")
overlay.bottom:SetPoint("BOTTOMRIGHT", overlay, "BOTTOMRIGHT") overlay.bottom:SetPoint("BOTTOMRIGHT", overlay, "BOTTOMRIGHT")
overlay.bottom:SetHeight(100) overlay.bottom:SetHeight(100)
overlay.bottom:SetTexture(1,1,1,1) overlay.bottom:SetColorTexture(1,1,1,1)
overlay.bottom:SetGradientAlpha("VERTICAL", 0,0,0,1, 0,0,0,0) overlay.bottom:SetGradientAlpha("VERTICAL", 0,0,0,1, 0,0,0,0)
overlay:SetFrameStrata("DIALOG") overlay:SetFrameStrata("DIALOG")
overlay:SetAllPoints(WorldFrame) overlay:SetAllPoints(WorldFrame)
overlay:SetScript("OnMouseUp",function() -- /afk toggles, so send it only while AFK is still set: once the client
SendChatMessage("","AFK") -- or the server has cleared it, /afk would set it again
this._parent:stop() local function Wake()
end) if IsChatAFK() then SendChatMessage("", "AFK") end
afkcam:stop()
end
overlay:SetScript("OnMouseUp", Wake)
overlay:SetScript("OnShow", function() overlay:SetScript("OnShow", function()
this:EnableKeyboard(true) this:EnableKeyboard(true)
end) end)
overlay:SetScript("OnHide", function() overlay:SetScript("OnHide", function()
this:EnableKeyboard(false) this:EnableKeyboard(false)
end) end)
overlay:SetScript("OnKeyUp",function() overlay:SetScript("OnKeyUp", Wake)
SendChatMessage("","AFK")
this._parent:stop()
end)
overlay:Hide() overlay:Hide()
local chat = CreateFrame("ScrollingMessageFrame", "pfAFKCamChat", overlay) local chat = CreateFrame("ScrollingMessageFrame", "pfAFKCamChat", overlay)
chat:EnableMouse(false) chat:EnableMouse(false)
chat:EnableMouseWheel(true) chat:EnableMouseWheel(true)
chat:SetHeight(150) chat:SetSize(500, 150)
chat:SetWidth(500)
chat:SetPoint("BOTTOMLEFT",overlay,"BOTTOMLEFT", 10, 10) chat:SetPoint("BOTTOMLEFT",overlay,"BOTTOMLEFT", 10, 10)
chat:SetTimeVisible(1800.0) chat:SetTimeVisible(1800.0)
chat:SetMaxLines(500) chat:SetMaxLines(500)
@@ -60,7 +59,10 @@ pfUI:RegisterModule("afkcam", function ()
if not this:IsVisible() then return end if not this:IsVisible() then return end
local info = _G.ChatTypeInfo[string.gsub(event,"CHAT_MSG_","")] local info = _G.ChatTypeInfo[string.gsub(event,"CHAT_MSG_","")]
if not info then return end if not info then return end
local class = GetUnitInfo(arg2 or "") -- the engine name-queries a chat sender before the event fires, so the
-- sender's GUID (arg12) always resolves
local _, class
if arg12 and arg12 ~= "" then _, class = GetPlayerInfoByGUID(arg12) end
local author, msg local author, msg
if class and class ~= UNKNOWN then if class and class ~= UNKNOWN then
local class_color = PFUI_CLASS_COLORS[class]:GenerateHexColorMarkup() local class_color = PFUI_CLASS_COLORS[class]:GenerateHexColorMarkup()
@@ -75,15 +77,10 @@ pfUI:RegisterModule("afkcam", function ()
chat:RegisterEvent(ctype) chat:RegisterEvent(ctype)
end end
chat:SetScript("OnMouseWheel",function() chat:SetScript("OnMouseWheel",function()
if arg1 > 0 then this:ScrollByAmount(arg1)
this:ScrollUp()
else
this:ScrollDown()
end
end) end)
overlay.chat = chat overlay.chat = chat
overlay._parent = afkcam
afkcam.overlay = overlay afkcam.overlay = overlay
local clock = CreateFrame("Frame", "pfAFKClock", overlay) local clock = CreateFrame("Frame", "pfAFKClock", overlay)
@@ -167,9 +164,9 @@ pfUI:RegisterModule("afkcam", function ()
if event == "PLAYER_FLAGS_CHANGED" then if event == "PLAYER_FLAGS_CHANGED" then
if UnitIsAFK('player') then if UnitIsAFK('player') then
delay:Show() delay:Show()
elseif delay:IsVisible() then else
delay:Hide() delay:Hide()
this:stop() if this._spinning then this:stop() end
end end
else else
if this._spinning then if this._spinning then
+5
View File
@@ -2,6 +2,11 @@ pfUI:RegisterModule("autoshift", function ()
pfUI.autoshift = CreateFrame("Frame") pfUI.autoshift = CreateFrame("Frame")
pfUI.autoshift:RegisterEvent("UI_ERROR_MESSAGE") pfUI.autoshift:RegisterEvent("UI_ERROR_MESSAGE")
-- Empty stub kept only so Turtle WoW's pfUI-turtle addon doesn't error when
-- its obsolete moonkin autoshift module iterates pfUI.autoshift.shapeshifts.
-- This fork drives autoshift off GetShapeshiftFormID() and no longer uses it.
pfUI.autoshift.shapeshifts = {}
pfUI.autoshift.scanString = string.gsub(SPELL_FAILED_ONLY_SHAPESHIFT, "%%s", "(.+)") pfUI.autoshift.scanString = string.gsub(SPELL_FAILED_ONLY_SHAPESHIFT, "%%s", "(.+)")
pfUI.autoshift.errors = { SPELL_FAILED_NOT_MOUNTED, ERR_ATTACK_MOUNTED, ERR_TAXIPLAYERALREADYMOUNTED, pfUI.autoshift.errors = { SPELL_FAILED_NOT_MOUNTED, ERR_ATTACK_MOUNTED, ERR_TAXIPLAYERALREADYMOUNTED,
+3 -8
View File
@@ -56,9 +56,8 @@ pfUI:RegisterModule("autovendor", function ()
-- Setup Autosell button -- Setup Autosell button
autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame) autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame)
autovendor.button:SetWidth(36) autovendor.button:SetSize(36, 36)
autovendor.button:SetHeight(36) autovendor.button.icon = autovendor.button:CreateTexture(nil, "ARTWORK")
autovendor.button.icon = autovendor.button:CreateTexture("ARTWORK")
autovendor.button.icon:SetTexture("Interface\\Icons\\Spell_Shadow_SacrificialShield") autovendor.button.icon:SetTexture("Interface\\Icons\\Spell_Shadow_SacrificialShield")
autovendor.button:SetScript("OnEnter", function() autovendor.button:SetScript("OnEnter", function()
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
@@ -87,11 +86,7 @@ pfUI:RegisterModule("autovendor", function ()
if not pfMerchantFrame_Update then if not pfMerchantFrame_Update then
local pfMerchantFrame_Update = MerchantFrame_Update local pfMerchantFrame_Update = MerchantFrame_Update
function _G.MerchantFrame_Update() function _G.MerchantFrame_Update()
if MerchantFrame.selectedTab == 1 and C["global"]["autosell"] ~= "1" then autovendor.button:SetShown(MerchantFrame.selectedTab == 1 and C["global"]["autosell"] ~= "1")
autovendor.button:Show()
else
autovendor.button:Hide()
end
pfMerchantFrame_Update() pfMerchantFrame_Update()
end end
end end
+75 -157
View File
@@ -6,7 +6,12 @@ pfUI:RegisterModule("bags", function ()
[1804] = {frame="picklock"}, [1804] = {frame="picklock"},
} }
local scanner = libtipscan:GetScanner("input_search") local function BagSortOpts()
return {
reverse = C.appearance.bags.sortreverse == "1",
reversePrio = C.appearance.bags.sortprioreverse == "1",
}
end
-- function to detect openable items in inventory -- function to detect openable items in inventory
local openable = { bag = nil, slot = nil, icon = nil } local openable = { bag = nil, slot = nil, icon = nil }
@@ -35,11 +40,7 @@ pfUI:RegisterModule("bags", function ()
-- overwrite some bag functions -- overwrite some bag functions
function _G.OpenAllBags() function _G.OpenAllBags()
if pfUI.bag.right:IsShown() then pfUI.bag.right:SetShown(not pfUI.bag.right:IsShown())
pfUI.bag.right:Hide()
else
pfUI.bag.right:Show()
end
end end
function _G.CloseAllBags() function _G.CloseAllBags()
@@ -47,11 +48,7 @@ pfUI:RegisterModule("bags", function ()
end end
function _G.ToggleBackpack() function _G.ToggleBackpack()
if pfUI.bag.right:IsShown() then pfUI.bag.right:SetShown(not pfUI.bag.right:IsShown())
pfUI.bag.right:Hide()
else
pfUI.bag.right:Show()
end
end end
function _G.OpenBackpack() function _G.OpenBackpack()
@@ -88,6 +85,7 @@ pfUI:RegisterModule("bags", function ()
pfUI.bag:RegisterEvent("ITEM_LOCK_CHANGED") pfUI.bag:RegisterEvent("ITEM_LOCK_CHANGED")
pfUI.bag:RegisterEvent("SPELLS_CHANGED") pfUI.bag:RegisterEvent("SPELLS_CHANGED")
pfUI.bag:RegisterEvent("MERCHANT_CLOSED") pfUI.bag:RegisterEvent("MERCHANT_CLOSED")
pfUI.bag:RegisterEvent("INVENTORY_SEARCH_UPDATE")
pfUI.bag.delay = { UpdateBag = {} } pfUI.bag.delay = { UpdateBag = {} }
@@ -115,6 +113,11 @@ pfUI:RegisterModule("bags", function ()
pfUI.bag:UpdateItemLock() pfUI.bag:UpdateItemLock()
end end
if this.delay.UpdateSearch then
this.delay.UpdateSearch = nil
pfUI.bag:UpdateSearch()
end
for bag in pairs(this.delay.UpdateBag) do for bag in pairs(this.delay.UpdateBag) do
this.delay.UpdateBag[bag] = nil this.delay.UpdateBag[bag] = nil
pfUI.bag:UpdateBag(bag) pfUI.bag:UpdateBag(bag)
@@ -152,6 +155,10 @@ pfUI:RegisterModule("bags", function ()
this.delay.UpdateItemLock = true this.delay.UpdateItemLock = true
end end
if event == "INVENTORY_SEARCH_UPDATE" then
this.delay.UpdateSearch = true
end
if event == "PLAYERBANKSLOTS_CHANGED" then if event == "PLAYERBANKSLOTS_CHANGED" then
this.delay.UpdateBag[-1] = true this.delay.UpdateBag[-1] = true
end end
@@ -319,8 +326,7 @@ pfUI:RegisterModule("bags", function ()
default_border + x*(frame.button_size+default_border*3), default_border + x*(frame.button_size+default_border*3),
-default_border*2 - y*(frame.button_size+default_border*3) - topspace) -default_border*2 - y*(frame.button_size+default_border*3) - topspace)
pfUI.bags[bag].slots[slot].frame:SetHeight(frame.button_size) pfUI.bags[bag].slots[slot].frame:SetSize(frame.button_size, frame.button_size)
pfUI.bags[bag].slots[slot].frame:SetWidth(frame.button_size)
if x >= rowlength - 1 then if x >= rowlength - 1 then
y = y + 1 y = y + 1
@@ -343,7 +349,7 @@ pfUI:RegisterModule("bags", function ()
chat:Hide() chat:Hide()
end end
if C.appearance.bags.autoSortOnOpen == "1" then if C.appearance.bags.autoSortOnOpen == "1" then
libbagsort:Sort({0, 1, 2, 3, 4}) libbagsort:Sort({0, 1, 2, 3, 4}, BagSortOpts())
end end
pfUI.bag:CreateBags(object) pfUI.bag:CreateBags(object)
PlaySound("INTERFACESOUND_BACKPACKOPEN") PlaySound("INTERFACESOUND_BACKPACKOPEN")
@@ -371,6 +377,21 @@ pfUI:RegisterModule("bags", function ()
end end
end end
-- dim the slots that the bag search (C_Container.SetItemSearch) filters out
local searchInfo = {}
function pfUI.bag:UpdateSlotSearch(bag, slot)
local info = C_Container.GetContainerItemInfo(bag, slot, searchInfo)
pfUI.bags[bag].slots[slot].frame:SetAlpha(info and info.isFiltered and .25 or 1)
end
function pfUI.bag:UpdateSearch()
for bag = -2, 11 do
for slot in ipairs(pfUI.bags[bag].slots) do
pfUI.bag:UpdateSlotSearch(bag, slot)
end
end
end
function pfUI.bag:UpdateSlot(bag, slot) function pfUI.bag:UpdateSlot(bag, slot)
if not pfUI.bags[bag] then return end if not pfUI.bags[bag] then return end
@@ -386,29 +407,26 @@ pfUI:RegisterModule("bags", function ()
pfUI.bags[bag].slots[slot].slot = slot pfUI.bags[bag].slots[slot].slot = slot
pfUI.bags[bag].slots[slot].frame:SetID(slot) pfUI.bags[bag].slots[slot].frame:SetID(slot)
-- add cooldown frame to bankslots -- native cooldown frame: the bank template has none and the bag
if tpl == "BankItemButtonGenericTemplate" then -- template's is 1.12's indicator Model, which can't reverse.
local bankslot = pfUI.bags[bag].slots[slot].frame -- ContainerFrame_UpdateCooldown reads the "<button>Cooldown" global.
local name = "pfBag" .. bag .. "item" .. slot .. "Cooldown" -- 1.12 binds a frame's name only while that global is unset, so the
bankslot.cd = CreateFrame(COOLDOWN_FRAME_TYPE, name, bankslot, "CooldownFrameTemplate") -- global is rebound by hand; the Model starts hidden and nothing
bankslot.cd:SetAllPoints(bankslot) -- reaches it after that
bankslot.cd.pfCooldownStyleAnimation = 1 local slotframe = pfUI.bags[bag].slots[slot].frame
bankslot.cd.pfCooldownType = "ALL" local cdname = slotframe:GetName() .. "Cooldown"
else slotframe.cd = CreateCooldown(slotframe, "bags", cdname)
local bagslot = pfUI.bags[bag].slots[slot].frame _G[cdname] = slotframe.cd
bagslot.cd = _G[bagslot:GetName().."Cooldown"]
bagslot.cd.pfCooldownType = "ALL"
end
if not pfUI.bags[bag].slots[slot].frame.backdrop then if not pfUI.bags[bag].slots[slot].frame.backdrop then
CreateBackdrop(pfUI.bags[bag].slots[slot].frame, default_border) CreateBackdrop(pfUI.bags[bag].slots[slot].frame, default_border)
end end
local highlight = pfUI.bags[bag].slots[slot].frame:GetHighlightTexture() local highlight = pfUI.bags[bag].slots[slot].frame:GetHighlightTexture()
highlight:SetTexture(.5, .5, .5, .5) highlight:SetColorTexture(.5, .5, .5, .5)
local pushed = pfUI.bags[bag].slots[slot].frame:GetPushedTexture() local pushed = pfUI.bags[bag].slots[slot].frame:GetPushedTexture()
pushed:SetTexture(.5, .5, .5, .5) pushed:SetColorTexture(.5, .5, .5, .5)
local questText = pfUI.bags[bag].slots[slot].frame.qtext local questText = pfUI.bags[bag].slots[slot].frame.qtext
questText:SetFont(pfUI.font_default, 13, "THICKOUTLINE") questText:SetFont(pfUI.font_default, 13, "THICKOUTLINE")
@@ -448,7 +466,7 @@ pfUI:RegisterModule("bags", function ()
end end
end end
local _, _, q, _, _, _, itype = GetItemInfo(itemID) local _, _, q, _, _, _, itype = C_Item.GetItemInfo(itemID)
-- running advanced item color scan -- running advanced item color scan
if C.appearance.bags.borderonlygear == "0" and texture and quality and quality < 1 then if C.appearance.bags.borderonlygear == "0" and texture and quality and quality < 1 then
@@ -458,6 +476,7 @@ pfUI:RegisterModule("bags", function ()
SetItemButtonTexture(pfUI.bags[bag].slots[slot].frame, texture) SetItemButtonTexture(pfUI.bags[bag].slots[slot].frame, texture)
SetItemButtonCount(pfUI.bags[bag].slots[slot].frame, count) SetItemButtonCount(pfUI.bags[bag].slots[slot].frame, count)
SetItemButtonDesaturated(pfUI.bags[bag].slots[slot].frame, locked, 0.5, 0.5, 0.5) SetItemButtonDesaturated(pfUI.bags[bag].slots[slot].frame, locked, 0.5, 0.5, 0.5)
pfUI.bag:UpdateSlotSearch(bag, slot)
local hasItem = texture and 1 or nil local hasItem = texture and 1 or nil
pfUI.bags[bag].slots[slot].frame.hasItem = hasItem pfUI.bags[bag].slots[slot].frame.hasItem = hasItem
@@ -538,8 +557,7 @@ pfUI:RegisterModule("bags", function ()
local width = (frame.button_size/5*4 + default_border*2) * (max-min+1+extra) local width = (frame.button_size/5*4 + default_border*2) * (max-min+1+extra)
local height = default_border + (frame.button_size/5*4 + default_border) local height = default_border + (frame.button_size/5*4 + default_border)
frame.bagslots:SetWidth(width) frame.bagslots:SetSize(width, height)
frame.bagslots:SetHeight(height)
for slot=min, max do for slot=min, max do
if not frame.bagslots.slots[slot] then if not frame.bagslots.slots[slot] then
frame.bagslots.slots[slot] = {} frame.bagslots.slots[slot] = {}
@@ -554,10 +572,10 @@ pfUI:RegisterModule("bags", function ()
border:SetTexture("") border:SetTexture("")
local highlight = frame.bagslots.slots[slot].frame:GetHighlightTexture() local highlight = frame.bagslots.slots[slot].frame:GetHighlightTexture()
highlight:SetTexture(.5, .5, .5, .5) highlight:SetColorTexture(.5, .5, .5, .5)
local pushed = frame.bagslots.slots[slot].frame:GetPushedTexture() local pushed = frame.bagslots.slots[slot].frame:GetPushedTexture()
pushed:SetTexture(.5, .5, .5, .5) pushed:SetColorTexture(.5, .5, .5, .5)
if frame == pfUI.bag.left then if frame == pfUI.bag.left then
frame.bagslots.slots[slot].frame:SetID(slot + 4) frame.bagslots.slots[slot].frame:SetID(slot + 4)
@@ -567,31 +585,16 @@ pfUI:RegisterModule("bags", function ()
frame.bagslots.slots[slot].slot = slot frame.bagslots.slots[slot].slot = slot
end end
local SlotEnter = frame.bagslots.slots[slot].frame:GetScript("OnEnter") frame.bagslots.slots[slot].frame:HookScript("OnEnter", function()
frame.bagslots.slots[slot].frame:SetScript("OnEnter", function()
for slot, f in ipairs(pfUI.bags[this.slot + 1].slots) do for slot, f in ipairs(pfUI.bags[this.slot + 1].slots) do
CreateBackdrop(f.frame, default_border) CreateBackdrop(f.frame, default_border)
f.frame.backdrop:SetBackdropBorderColor(.2,1,.8,1) f.frame.backdrop:SetBackdropBorderColor(.2,1,.8,1)
end end
SlotEnter(this)
end) end)
local SlotLeave = frame.bagslots.slots[slot].frame:GetScript("OnLeave") frame.bagslots.slots[slot].frame:HookScript("OnLeave", function()
frame.bagslots.slots[slot].frame:SetScript("OnLeave", function()
pfUI.bag:UpdateBag(this.slot + 1) pfUI.bag:UpdateBag(this.slot + 1)
SlotLeave()
end) end)
-- On TBC, the OnEvent function of the template scans for framenames,
-- and obviously doesn't know the pf-Names. Therefore, triggering
-- the update function on each frame manually
if frame == pfUI.bag.left and BankFrameItemButton_Update then
local SlotUpdate = frame.bagslots.slots[slot].frame:GetScript("OnUpdate")
frame.bagslots.slots[slot].frame:SetScript("OnUpdate", function()
if SlotUpdate then SlotUpdate(this) end
BankFrameItemButton_Update(this)
end)
end
end end
local left = (slot-min)*(frame.button_size/5*4+default_border*2) + default_border local left = (slot-min)*(frame.button_size/5*4+default_border*2) + default_border
@@ -599,8 +602,7 @@ pfUI:RegisterModule("bags", function ()
frame.bagslots.slots[slot].frame:ClearAllPoints() frame.bagslots.slots[slot].frame:ClearAllPoints()
frame.bagslots.slots[slot].frame:SetPoint("TOPLEFT", frame.bagslots, "TOPLEFT", left, top) frame.bagslots.slots[slot].frame:SetPoint("TOPLEFT", frame.bagslots, "TOPLEFT", left, top)
frame.bagslots.slots[slot].frame:SetHeight(frame.button_size/5*4) frame.bagslots.slots[slot].frame:SetSize(frame.button_size/5*4, frame.button_size/5*4)
frame.bagslots.slots[slot].frame:SetWidth(frame.button_size/5*4)
CreateBackdrop(frame.bagslots.slots[slot].frame, default_border) CreateBackdrop(frame.bagslots.slots[slot].frame, default_border)
frame.bagslots.slots[slot].frame:Show() frame.bagslots.slots[slot].frame:Show()
@@ -619,8 +621,7 @@ pfUI:RegisterModule("bags", function ()
end end
frame.bagslots.buy:SetPoint("RIGHT", frame.bagslots, "RIGHT", -default_border, 0) frame.bagslots.buy:SetPoint("RIGHT", frame.bagslots, "RIGHT", -default_border, 0)
CreateBackdrop(frame.bagslots.buy, default_border) CreateBackdrop(frame.bagslots.buy, default_border)
frame.bagslots.buy:SetHeight(frame.button_size/5*4) frame.bagslots.buy:SetSize(frame.button_size/5*4, frame.button_size/5*4)
frame.bagslots.buy:SetWidth(frame.button_size/5*4)
frame.bagslots.buy:SetText("+") frame.bagslots.buy:SetText("+")
frame.bagslots.buy:SetTextColor(.5,.5,1,1) frame.bagslots.buy:SetTextColor(.5,.5,1,1)
frame.bagslots.buy:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bagslots.buy:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
@@ -712,8 +713,7 @@ pfUI:RegisterModule("bags", function ()
frame.close = CreateFrame("Button", "pfBagClose", frame) frame.close = CreateFrame("Button", "pfBagClose", frame)
frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border ) frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border )
CreateBackdrop(frame.close, default_border) CreateBackdrop(frame.close, default_border)
frame.close:SetHeight(12) frame.close:SetSize(12, 12)
frame.close:SetWidth(12)
frame.close.texture = frame.close:CreateTexture("pfBagClose") frame.close.texture = frame.close:CreateTexture("pfBagClose")
frame.close.texture:SetTexture(pfUI.media["img:close"]) frame.close.texture:SetTexture(pfUI.media["img:close"])
frame.close.texture:ClearAllPoints() frame.close.texture:ClearAllPoints()
@@ -738,8 +738,7 @@ pfUI:RegisterModule("bags", function ()
frame.bags = CreateFrame("Button", "pfBagSlotShow", frame) frame.bags = CreateFrame("Button", "pfBagSlotShow", frame)
frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0) frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.bags, default_border) CreateBackdrop(frame.bags, default_border)
frame.bags:SetHeight(12) frame.bags:SetSize(12, 12)
frame.bags:SetWidth(12)
frame.bags:SetTextColor(1,1,.25,1) frame.bags:SetTextColor(1,1,.25,1)
frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp") frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp")
@@ -766,11 +765,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.bags:SetScript("OnClick", function() frame.bags:SetScript("OnClick", function()
if pfUI.bag.right.bagslots:IsShown() then pfUI.bag.right.bagslots:SetShown(not pfUI.bag.right.bagslots:IsShown())
pfUI.bag.right.bagslots:Hide()
else
pfUI.bag.right.bagslots:Show()
end
end) end)
end end
@@ -779,8 +774,7 @@ pfUI:RegisterModule("bags", function ()
frame.open = CreateFrame("Button", "pfBagSlotOpen", frame) frame.open = CreateFrame("Button", "pfBagSlotOpen", frame)
frame.open:SetPoint("TOPRIGHT", frame.bags, "TOPLEFT", -default_border*3, 0) frame.open:SetPoint("TOPRIGHT", frame.bags, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.open, default_border) CreateBackdrop(frame.open, default_border)
frame.open:SetHeight(12) frame.open:SetSize(12, 12)
frame.open:SetWidth(12)
frame.open:SetTextColor(1,1,.25,1) frame.open:SetTextColor(1,1,.25,1)
frame.open:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.open:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.open.texture = frame.open:CreateTexture("pfBagOpenContainer") frame.open.texture = frame.open:CreateTexture("pfBagOpenContainer")
@@ -838,8 +832,7 @@ pfUI:RegisterModule("bags", function ()
frame.disenchant = CreateFrame("Button", "pfBagSlotDisenchant", frame) frame.disenchant = CreateFrame("Button", "pfBagSlotDisenchant", frame)
frame.disenchant:SetPoint("TOPRIGHT", frame.open, "TOPLEFT", -default_border*3, 0) frame.disenchant:SetPoint("TOPRIGHT", frame.open, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.disenchant, default_border) CreateBackdrop(frame.disenchant, default_border)
frame.disenchant:SetHeight(12) frame.disenchant:SetSize(12, 12)
frame.disenchant:SetWidth(12)
frame.disenchant:SetTextColor(1,1,.25,1) frame.disenchant:SetTextColor(1,1,.25,1)
frame.disenchant:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.disenchant:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.disenchant.texture = frame.disenchant:CreateTexture("pfBagDisenchant") frame.disenchant.texture = frame.disenchant:CreateTexture("pfBagDisenchant")
@@ -881,8 +874,7 @@ pfUI:RegisterModule("bags", function ()
frame.picklock = CreateFrame("Button", "pfBagSlotPicklock", frame) frame.picklock = CreateFrame("Button", "pfBagSlotPicklock", frame)
frame.picklock:SetPoint("TOPRIGHT", frame.disenchant, "TOPLEFT", -default_border*3, 0) frame.picklock:SetPoint("TOPRIGHT", frame.disenchant, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.picklock, default_border) CreateBackdrop(frame.picklock, default_border)
frame.picklock:SetHeight(12) frame.picklock:SetSize(12, 12)
frame.picklock:SetWidth(12)
frame.picklock:SetTextColor(1,1,.25,1) frame.picklock:SetTextColor(1,1,.25,1)
frame.picklock:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.picklock:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.picklock.texture = frame.picklock:CreateTexture("pfBagPicklock") frame.picklock.texture = frame.picklock:CreateTexture("pfBagPicklock")
@@ -924,8 +916,7 @@ pfUI:RegisterModule("bags", function ()
frame.keys = CreateFrame("Button", "pfBagSlotShow", frame) frame.keys = CreateFrame("Button", "pfBagSlotShow", frame)
frame.keys:SetPoint("TOPRIGHT", frame.picklock, "TOPLEFT", -default_border*3, 0) frame.keys:SetPoint("TOPRIGHT", frame.picklock, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.keys, default_border) CreateBackdrop(frame.keys, default_border)
frame.keys:SetHeight(12) frame.keys:SetSize(12, 12)
frame.keys:SetWidth(12)
frame.keys:SetTextColor(1,1,.25,1) frame.keys:SetTextColor(1,1,.25,1)
frame.keys:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.keys:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.keys.texture = frame.keys:CreateTexture("pfBagArrowUp") frame.keys.texture = frame.keys:CreateTexture("pfBagArrowUp")
@@ -967,8 +958,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort = CreateFrame("Button", "pfBagSort", frame) frame.sort = CreateFrame("Button", "pfBagSort", frame)
frame.sort:SetPoint("TOPRIGHT", frame.keys, "TOPLEFT", -default_border*3, 0) frame.sort:SetPoint("TOPRIGHT", frame.keys, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.sort, default_border) CreateBackdrop(frame.sort, default_border)
frame.sort:SetHeight(12) frame.sort:SetSize(12, 12)
frame.sort:SetWidth(12)
frame.sort.texture = frame.sort:CreateTexture("pfBagSortIcon") frame.sort.texture = frame.sort:CreateTexture("pfBagSortIcon")
frame.sort.texture:SetTexture(pfUI.media["img:sort"]) frame.sort.texture:SetTexture(pfUI.media["img:sort"])
frame.sort.texture:ClearAllPoints() frame.sort.texture:ClearAllPoints()
@@ -980,7 +970,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1) frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1)
frame.sort.texture:SetVertexColor(1,1,.25,1) frame.sort.texture:SetVertexColor(1,1,.25,1)
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText("Sort Bags") GameTooltip:SetText(T["Sort Bags"])
GameTooltip:Show() GameTooltip:Show()
end) end)
@@ -993,7 +983,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.sort:SetScript("OnClick", function() frame.sort:SetScript("OnClick", function()
libbagsort:Sort({0, 1, 2, 3, 4}) libbagsort:Sort({0, 1, 2, 3, 4}, BagSortOpts())
end) end)
end end
@@ -1001,8 +991,7 @@ pfUI:RegisterModule("bags", function ()
if not frame.gold and (C.appearance.bags.movable == "1" or not pfUI.panel) then if not frame.gold and (C.appearance.bags.movable == "1" or not pfUI.panel) then
frame.gold = CreateFrame("Frame", "pfBagGoldString", frame) frame.gold = CreateFrame("Frame", "pfBagGoldString", frame)
frame.gold:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -4, 1) frame.gold:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -4, 1)
frame.gold:SetWidth(200) frame.gold:SetSize(200, 18)
frame.gold:SetHeight(18)
frame.gold:RegisterEvent("PLAYER_ENTERING_WORLD") frame.gold:RegisterEvent("PLAYER_ENTERING_WORLD")
frame.gold:RegisterEvent("PLAYER_MONEY") frame.gold:RegisterEvent("PLAYER_MONEY")
frame.gold:SetScript("OnEvent", function() frame.gold:SetScript("OnEvent", function()
@@ -1018,7 +1007,6 @@ pfUI:RegisterModule("bags", function ()
-- bag search -- bag search
if not frame.search then if not frame.search then
frame.search = CreateFrame("Frame", "pfBagSearch", frame) frame.search = CreateFrame("Frame", "pfBagSearch", frame)
frame.search.db = {}
frame.search:SetHeight(12) frame.search:SetHeight(12)
frame.search:SetPoint("TOPLEFT", frame, "TOPLEFT", default_border, -default_border) frame.search:SetPoint("TOPLEFT", frame, "TOPLEFT", default_border, -default_border)
frame.search:SetPoint("TOPRIGHT", frame.sort, "TOPLEFT", -default_border*3, -default_border) frame.search:SetPoint("TOPRIGHT", frame.sort, "TOPLEFT", -default_border*3, -default_border)
@@ -1043,72 +1031,18 @@ pfUI:RegisterModule("bags", function ()
frame.search.edit:SetScript("OnEditFocusLost", function() frame.search.edit:SetScript("OnEditFocusLost", function()
this:SetText(T["Search"]) this:SetText(T["Search"])
for bag=-2, 11 do C_Container.SetItemSearch("")
local bagsize = GetContainerNumSlots(bag)
if bag == -2 and pfUI.bag.showKeyring == true then bagsize = GetKeyRingSize() end
for slot=1, bagsize do
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
end) end)
frame.search.edit:SetScript("OnTextChanged", function() frame.search.edit:SetScript("OnTextChanged", function()
if this:GetText() == T["Search"] then return end if this:GetText() == T["Search"] then return end
for bag=-2, 11 do C_Container.SetItemSearch(this:GetText())
local bagsize = GetContainerNumSlots(bag)
if bag == -2 and pfUI.bag.showKeyring == true then bagsize = GetKeyRingSize() end
for slot=1, bagsize do
pfUI.bags[bag].slots[slot].frame:SetAlpha(.25)
local texture, itemCount, locked, quality, readable = GetContainerItemInfo(bag, slot)
if itemCount then
local itemLink = GetContainerItemLink(bag, slot)
local itemstring = string.sub(itemLink, string.find(itemLink, "%[")+1, string.find(itemLink, "%]")-1)
if C.appearance.bags.fulltext == "1" then
if not frame.search.db[itemLink] then
scanner:SetBagItem(bag, slot)
local text = scanner:Text()
local str = ""
for k, v in pairs(text) do
str = str .. (v[1] or "") .. (v[2] or "")
end
frame.search.db[itemLink] = strlower(str)
end
if strfind(frame.search.db[itemLink], strlower(this:GetText()), 1, true) then
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
if strfind(strlower(itemstring), strlower(this:GetText()), 1, true) then
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
end
end
end) end)
frame.search:SetScript("OnLeave", function() frame.search:SetScript("OnLeave", function()
frame.search.edit:ClearFocus() frame.search.edit:ClearFocus()
end) end)
frame.search:SetScript("OnHide", function()
frame.search.edit:SetText(T["Search"])
for bag = -2, 11 do
if pfUI.bags[bag] then
local bagsize = GetContainerNumSlots(bag)
if bag == -2 and pfUI.bag.showKeyring == true then bagsize = GetKeyRingSize() end
for slot = 1, bagsize do
if pfUI.bags[bag] and pfUI.bags[bag].slots[slot] then
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
end
end
end)
frame.search.edit:SetScript("OnMouseUp", function() frame.search.edit:SetScript("OnMouseUp", function()
if arg1 == "RightButton" then if arg1 == "RightButton" then
this:ClearFocus() this:ClearFocus()
@@ -1117,17 +1051,7 @@ pfUI:RegisterModule("bags", function ()
frame.search:SetScript("OnHide", function() frame.search:SetScript("OnHide", function()
frame.search.edit:SetText(T["Search"]) frame.search.edit:SetText(T["Search"])
for bag = -2, 11 do C_Container.SetItemSearch("")
if pfUI.bags[bag] then
local bagsize = GetContainerNumSlots(bag)
if bag == -2 and pfUI.bag.showKeyring == true then bagsize = GetKeyRingSize() end
for slot = 1, bagsize do
if pfUI.bags[bag] and pfUI.bags[bag].slots[slot] then
pfUI.bags[bag].slots[slot].frame:SetAlpha(1)
end
end
end
end
end) end)
end end
else else
@@ -1138,8 +1062,7 @@ pfUI:RegisterModule("bags", function ()
frame.close = CreateFrame("Button", "pfBagClose", frame) frame.close = CreateFrame("Button", "pfBagClose", frame)
frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border ) frame.close:SetPoint("TOPRIGHT", -default_border*1,-default_border )
CreateBackdrop(frame.close, default_border) CreateBackdrop(frame.close, default_border)
frame.close:SetHeight(12) frame.close:SetSize(12, 12)
frame.close:SetWidth(12)
frame.close.texture = frame.close:CreateTexture("pfBagClose") frame.close.texture = frame.close:CreateTexture("pfBagClose")
frame.close.texture:SetTexture(pfUI.media["img:close"]) frame.close.texture:SetTexture(pfUI.media["img:close"])
frame.close.texture:ClearAllPoints() frame.close.texture:ClearAllPoints()
@@ -1164,8 +1087,7 @@ pfUI:RegisterModule("bags", function ()
frame.bags = CreateFrame("Button", "pfBagSlotShow", frame) frame.bags = CreateFrame("Button", "pfBagSlotShow", frame)
frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0) frame.bags:SetPoint("TOPRIGHT", frame.close, "TOPLEFT", -default_border*3, 0)
CreateBackdrop(frame.bags, default_border) CreateBackdrop(frame.bags, default_border)
frame.bags:SetHeight(12) frame.bags:SetSize(12, 12)
frame.bags:SetWidth(12)
frame.bags:SetTextColor(1,1,.25,1) frame.bags:SetTextColor(1,1,.25,1)
frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") frame.bags:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp") frame.bags.texture = frame.bags:CreateTexture("pfBagArrowUp")
@@ -1192,11 +1114,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.bags:SetScript("OnClick", function() frame.bags:SetScript("OnClick", function()
if pfUI.bag.left.bagslots:IsShown() then pfUI.bag.left.bagslots:SetShown(not pfUI.bag.left.bagslots:IsShown())
pfUI.bag.left.bagslots:Hide()
else
pfUI.bag.left.bagslots:Show()
end
end) end)
end end
@@ -1218,7 +1136,7 @@ pfUI:RegisterModule("bags", function ()
frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1) frame.sort.backdrop:SetBackdropBorderColor(1,1,.25,1)
frame.sort.texture:SetVertexColor(1,1,.25,1) frame.sort.texture:SetVertexColor(1,1,.25,1)
GameTooltip:SetOwner(this, "ANCHOR_RIGHT") GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText("Sort Bank") GameTooltip:SetText(T["Sort Bank"])
GameTooltip:Show() GameTooltip:Show()
end) end)
@@ -1231,7 +1149,7 @@ pfUI:RegisterModule("bags", function ()
end) end)
frame.sort:SetScript("OnClick", function() frame.sort:SetScript("OnClick", function()
libbagsort:Sort({-1, 5, 6, 7, 8, 9, 10}) libbagsort:Sort({-1, 5, 6, 7, 8, 9, 10}, BagSortOpts())
end) end)
end end
end end
+3 -5
View File
@@ -2,14 +2,12 @@ pfUI:RegisterModule("bgscore", function ()
local bgframe = WorldStateAlwaysUpFrame local bgframe = WorldStateAlwaysUpFrame
if not bgframe then if not bgframe then
bgframe = CreateFrame("Frame", "WorldStateAlwaysUpFrame", UIParent) bgframe = CreateFrame("Frame", "WorldStateAlwaysUpFrame", UIParent)
bgframe:SetWidth(200) bgframe:SetSize(200, 25)
bgframe:SetHeight(25)
bgframe:SetPoint("TOP", UIParent, "TOP", 0, -100) bgframe:SetPoint("TOP", UIParent, "TOP", 0, -100)
end end
local mover = CreateFrame("Frame", "pfUIBGScoreMover", UIParent) local mover = CreateFrame("Frame", "pfUIBGScoreMover", UIParent)
mover:SetWidth(220) mover:SetSize(220, 30)
mover:SetHeight(30)
mover:SetPoint("TOP", UIParent, "TOP", 0, -100) mover:SetPoint("TOP", UIParent, "TOP", 0, -100)
mover:SetFrameStrata("DIALOG") mover:SetFrameStrata("DIALOG")
mover:SetMovable(true) mover:SetMovable(true)
@@ -34,7 +32,7 @@ pfUI:RegisterModule("bgscore", function ()
-- Title label -- Title label
local title = mover:CreateFontString(nil, "OVERLAY") local title = mover:CreateFontString(nil, "OVERLAY")
title:SetFont("Fonts\\FRIZQT__.TTF", 14, "OUTLINE") title:SetFont("Fonts\\FRIZQT__.TTF", 14, "OUTLINE")
title:SetText("Battleground Frames") title:SetText(T["Battleground Frames"])
title:SetPoint("TOP", mover, "TOP", 0, -2) title:SetPoint("TOP", mover, "TOP", 0, -2)
-- BG score preview text -- BG score preview text
+8 -16
View File
@@ -2,7 +2,7 @@ pfUI:RegisterModule("bubbles", function ()
local alpha = tonumber(C.chat.bubbles.alpha) local alpha = tonumber(C.chat.bubbles.alpha)
pfUI.bubbles = CreateFrame("Frame", "pfChatBubbles", UIParent) pfUI.bubbles = Mixin(CreateFrame("Frame", "pfChatBubbles", UIParent), DirtiableMixin)
pfUI.bubbles:RegisterEvent("CHAT_MSG_SAY") pfUI.bubbles:RegisterEvent("CHAT_MSG_SAY")
pfUI.bubbles:RegisterEvent("CHAT_MSG_YELL") pfUI.bubbles:RegisterEvent("CHAT_MSG_YELL")
pfUI.bubbles:RegisterEvent("CHAT_MSG_PARTY") pfUI.bubbles:RegisterEvent("CHAT_MSG_PARTY")
@@ -11,18 +11,6 @@ pfUI:RegisterModule("bubbles", function ()
pfUI.bubbles:RegisterEvent("CHAT_MSG_MONSTER_YELL") pfUI.bubbles:RegisterEvent("CHAT_MSG_MONSTER_YELL")
pfUI.bubbles:RegisterEvent("CHAT_MSG_MONSTER_PARTY") pfUI.bubbles:RegisterEvent("CHAT_MSG_MONSTER_PARTY")
pfUI.bubbles:SetScript("OnEvent", function()
-- Bubble frames are attached to WorldFrame after the chat event fires,
-- so wait one tick before scanning.
RunNextFrame(function() pfUI.bubbles:ScanBubbles() end)
end)
function pfUI.bubbles:IsBubble(f)
if f:GetName() then return end
if not f:GetRegions() then return end
return f:GetRegions().GetTexture and f:GetRegions():GetTexture() == "Interface\\Tooltips\\ChatBubble-Background"
end
function pfUI.bubbles:ProcessBubble(f) function pfUI.bubbles:ProcessBubble(f)
f.text:Hide() f.text:Hide()
f.text:SetFont(pfUI.font_default, tonumber(C.global.font_size) * UIParent:GetScale(), "OUTLINE") f.text:SetFont(pfUI.font_default, tonumber(C.global.font_size) * UIParent:GetScale(), "OUTLINE")
@@ -34,9 +22,8 @@ pfUI:RegisterModule("bubbles", function ()
end end
function pfUI.bubbles:ScanBubbles() function pfUI.bubbles:ScanBubbles()
local childs = { WorldFrame:GetChildren() } for _, f in ipairs(C_ChatBubbles.GetAllChatBubbles()) do
for _, f in pairs(childs) do if not f.frame then
if not f.frame and pfUI.bubbles:IsBubble(f) then
local textures = {f:GetRegions()} local textures = {f:GetRegions()}
for _, object in pairs(textures) do for _, object in pairs(textures) do
if object:GetObjectType() == "Texture" then if object:GetObjectType() == "Texture" then
@@ -69,4 +56,9 @@ pfUI:RegisterModule("bubbles", function ()
end end
end end
end end
-- Bubble frames are attached to WorldFrame after the chat event fires, so
-- the scan waits a frame, and runs once for all of that frame's messages.
pfUI.bubbles:SetDirtyMethod(pfUI.bubbles.ScanBubbles)
pfUI.bubbles:SetScript("OnEvent", pfUI.bubbles.MarkDirty)
end) end)
+112 -98
View File
@@ -7,10 +7,38 @@ pfUI:RegisterModule("buff", function ()
local br, bg, bb, ba = GetStringColor(pfUI_config.appearance.border.color) local br, bg, bb, ba = GetStringColor(pfUI_config.appearance.border.color)
-- Player aura slot ids, enumerated once per refresh pass (ScanPlayerAuraSlots)
-- and read per button by its aura index: one GetAuraSlots walk per range
-- instead of a by-index walk per button.
local helpfulSlots, harmfulSlots = {}, {}
local function ScanPlayerAuraSlots()
ScanAuraSlots("player", "HELPFUL", helpfulSlots, 32)
ScanAuraSlots("player", "HARMFUL", harmfulSlots, 16)
end
-- weapon enchants report only their time left, and no event as their
-- charges and time run down, so the OnUpdate below refreshes their buttons
-- too: the charges, and the timer when the enchant was renewed
local function RefreshWeaponButton(buff, timeleft, charges)
timeleft = (timeleft or 0) / 1000
charges = charges or 0
buff.stacks:SetText(charges > 1 and charges or "")
local expires = GetTime() + timeleft
if timeleft <= 0 then
buff.cd:Clear()
buff.cdExpires = nil
elseif not buff.cdExpires or abs(buff.cdExpires - expires) > 1 then
SetCooldownTimeLeft(buff.cd, timeleft)
buff.cdExpires = expires
end
buff.cdStart = nil
end
local function RefreshBuffButton(buff) local function RefreshBuffButton(buff)
if buff.btype == "HELPFUL" then if buff.btype == "HELPFUL" then
if C.buffs.separateweapons == "1" then if C.buffs.separateweapons == "1" then
buff.id = buff.gid - (buff.weapon ~= nill and buff.gid or 0) buff.id = buff.gid - (buff.weapon ~= nil and buff.gid or 0)
else else
buff.id = buff.gid - pfUI.buff.wepbuffs.count buff.id = buff.gid - pfUI.buff.wepbuffs.count
end end
@@ -23,7 +51,8 @@ pfUI:RegisterModule("buff", function ()
CreateBackdropShadow(buff) CreateBackdropShadow(buff)
end end
local aura = C_UnitAuras.GetAuraDataByIndex("player", buff.id, buff.btype) local slots = buff.btype == "HELPFUL" and helpfulSlots or harmfulSlots
local name, icon, count, dispelType, duration, expirationTime, _, _, _, spellId = C_UnitAuras.UnitAuraBySlot("player", slots[buff.id])
--detect weapon buffs --detect weapon buffs
if buff.btype == "HELPFUL" and ((C.buffs.separateweapons == "0" and buff.gid <= pfUI.buff.wepbuffs.count) or (pfUI.buff.wepbuffs.count > 0 and buff.weapon ~= nil)) then if buff.btype == "HELPFUL" and ((C.buffs.separateweapons == "0" and buff.gid <= pfUI.buff.wepbuffs.count) or (pfUI.buff.wepbuffs.count > 0 and buff.weapon ~= nil)) then
@@ -47,28 +76,41 @@ pfUI:RegisterModule("buff", function ()
end end
end end
-- Set Weapon Texture and Border -- Set Weapon Texture, Border and Timer
if buff.mode == "MAINHAND" then if buff.mode == "MAINHAND" then
buff.texture:SetTexture(GetInventoryItemTexture("player", 16)) buff.texture:SetTexture(GetInventoryItemTexture("player", 16))
buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 16) or 1)) buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 16) or 1))
RefreshWeaponButton(buff, mhtime, mhcharge)
elseif buff.mode == "OFFHAND" then elseif buff.mode == "OFFHAND" then
buff.texture:SetTexture(GetInventoryItemTexture("player", 17)) buff.texture:SetTexture(GetInventoryItemTexture("player", 17))
buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 17) or 1)) buff.backdrop:SetBackdropBorderColor(GetItemQualityColor(GetInventoryItemQuality("player", 17) or 1))
RefreshWeaponButton(buff, ohtime, ohcharge)
end end
elseif aura and (( buff.btype == "HARMFUL" and C.buffs.debuffs == "1" ) or ( buff.btype == "HELPFUL" and C.buffs.buffs == "1" )) then elseif name and (( buff.btype == "HARMFUL" and C.buffs.debuffs == "1" ) or ( buff.btype == "HELPFUL" and C.buffs.buffs == "1" )) then
-- Set Buff Texture and Border -- Set Buff Texture and Border
buff.mode = buff.btype buff.mode = buff.btype
buff.expirationTime = aura.expirationTime buff.spellId = spellId
buff.stackCount = aura.applications buff.texture:SetTexture(icon)
buff.spellId = aura.spellId buff.stacks:SetText((count or 0) > 1 and count or "")
buff.texture:SetTexture(aura.icon)
if buff.btype == "HARMFUL" then if buff.btype == "HARMFUL" then
local dispelColor = C_UnitAuras.GetAuraDispelTypeColor(aura.dispelName) local dispelColor = C_UnitAuras.GetAuraDispelTypeColor(dispelType)
buff.backdrop:SetBackdropBorderColor(dispelColor:GetRGBA()) buff.backdrop:SetBackdropBorderColor(dispelColor:GetRGBA())
else else
buff.backdrop:SetBackdropBorderColor(br,bg,bb,ba) buff.backdrop:SetBackdropBorderColor(br,bg,bb,ba)
end end
-- start the timer from the aura's duration; permanent auras have none
local start, dur = GetAuraTimer(duration, expirationTime)
if dur <= 0 then
buff.cd:Clear()
buff.cdStart = nil
elseif buff.cdStart == nil or abs(buff.cdStart - start) > .5 or buff.cdDuration ~= dur then
CooldownFrame_SetTimer(buff.cd, start, dur, 1)
buff.cdStart = start
buff.cdDuration = dur
end
buff.cdExpires = nil
else else
buff:Hide() buff:Hide()
return return
@@ -96,17 +138,24 @@ pfUI:RegisterModule("buff", function ()
buff.texture:SetTexCoord(.07,.93,.07,.93) buff.texture:SetTexCoord(.07,.93,.07,.93)
buff.texture:SetAllPoints(buff) buff.texture:SetAllPoints(buff)
buff.timer = buff:CreateFontString(nil, "OVERLAY", "GameFontNormal") -- overlay lifts the stacks above the sweep: a child frame renders above
buff.timer:SetTextColor(1,1,1,1) -- all of its parent's own regions, so they would dim under the dark
buff.timer:SetJustifyH("CENTER") -- wedge otherwise
buff.timer:SetJustifyV("CENTER") buff.overlay = CreateFrame("Frame", nil, buff)
buff.overlay:SetAllPoints(buff)
buff.stacks = buff:CreateFontString(nil, "OVERLAY", "GameFontNormal") buff.stacks = buff.overlay:CreateFontString(nil, "OVERLAY", "GameFontNormal")
buff.stacks:SetTextColor(1,1,1,1) buff.stacks:SetTextColor(1,1,1,1)
buff.stacks:SetJustifyH("RIGHT") buff.stacks:SetJustifyH("RIGHT")
buff.stacks:SetJustifyV("BOTTOM") buff.stacks:SetJustifyV("BOTTOM")
buff.stacks:SetAllPoints(buff) buff.stacks:SetAllPoints(buff)
-- the sweep and the duration numbers (the template covers the button and
-- starts hidden); RefreshBuffButton starts its timer
buff.cd = CreateCooldown(buff, "buff", buttonName .. "Cooldown")
buff.cd:SetFrameLevel(buff:GetFrameLevel() + 1)
buff.overlay:SetFrameLevel(buff:GetFrameLevel() + 2)
buff:RegisterForClicks("RightButtonUp") buff:RegisterForClicks("RightButtonUp")
buff.weapon = weapon buff.weapon = weapon
@@ -138,16 +187,10 @@ pfUI:RegisterModule("buff", function ()
end end
end) end)
buff:SetScript("OnLeave", function() buff:SetScript("OnLeave", GameTooltip_Hide)
GameTooltip:Hide()
end)
buff:SetScript("OnClick", function() buff:SetScript("OnClick", function()
if CancelItemTempEnchantment and this.mode and this.mode == "MAINHAND" then if this.spellId then
CancelItemTempEnchantment(1)
elseif CancelItemTempEnchantment and this.mode and this.mode == "OFFHAND" then
CancelItemTempEnchantment(2)
elseif this.spellId then
C_Spell.CancelSpellByID(this.spellId) C_Spell.CancelSpellByID(this.spellId)
end end
end) end)
@@ -160,7 +203,7 @@ pfUI:RegisterModule("buff", function ()
pfUI.buff = CreateFrame("Frame", "pfGlobalBuffFrame", UIParent) pfUI.buff = CreateFrame("Frame", "pfGlobalBuffFrame", UIParent)
pfUI.buff:RegisterEvent("PLAYER_AURAS_CHANGED") pfUI.buff:RegisterEvent("PLAYER_AURAS_CHANGED")
pfUI.buff:RegisterEvent("PLAYER_EQUIPMENT_CHANGED") pfUI.buff:RegisterEvent("PLAYER_EQUIPMENT_CHANGED")
pfUI.buff:RegisterEvent("UNIT_MODEL_CHANGED") pfUI.buff:RegisterUnitEvent("UNIT_MODEL_CHANGED", "player")
pfUI.buff:RegisterEvent("BUFF_UPDATE_DURATION_SELF") pfUI.buff:RegisterEvent("BUFF_UPDATE_DURATION_SELF")
pfUI.buff:RegisterEvent("DEBUFF_UPDATE_DURATION_SELF") pfUI.buff:RegisterEvent("DEBUFF_UPDATE_DURATION_SELF")
pfUI.buff:SetScript("OnEvent", function() pfUI.buff:SetScript("OnEvent", function()
@@ -172,6 +215,8 @@ pfUI:RegisterModule("buff", function ()
pfUI.buff.wepbuffs.count = 0 pfUI.buff.wepbuffs.count = 0
end end
ScanPlayerAuraSlots()
for i=1,32 do for i=1,32 do
RefreshBuffButton(pfUI.buff.buffs.buttons[i]) RefreshBuffButton(pfUI.buff.buffs.buttons[i])
end end
@@ -187,71 +232,32 @@ pfUI:RegisterModule("buff", function ()
end end
end) end)
-- PERF: Consolidated OnUpdate handler for all buff timers -- the buttons that can show a weapon enchant: the first two buffs, or the
-- This replaces 50 individual OnUpdate handlers with a single one -- separate weapon buttons
local weaponButtons
-- weapon enchants, see RefreshWeaponButton
pfUI.buff:SetScript("OnUpdate", function() pfUI.buff:SetScript("OnUpdate", function()
local now = GetTime() local now = GetTime()
if not this.nextUpdate then this.nextUpdate = now + 0.1 end if not this.nextUpdate then this.nextUpdate = now + 0.1 end
if this.nextUpdate > now then return end if this.nextUpdate > now then return end
this.nextUpdate = now + 0.1 this.nextUpdate = now + 0.1
-- Cache weapon enchant info once per update cycle local _, mhtime, mhcharge, _, ohtime, ohcharge = GetWeaponEnchantInfo()
local mh, mhtime, mhcharge, oh, ohtime, ohcharge = GetWeaponEnchantInfo() for _, buff in ipairs(weaponButtons) do
-- Update all visible buff buttons
local buttons = pfUI.buff.buffs.buttons
for i = 1, 32 do
local buff = buttons[i]
if buff:IsShown() then if buff:IsShown() then
local timeleft, stacks = 0, 0 if buff.mode == "MAINHAND" then
if buff.mode == buff.btype then RefreshWeaponButton(buff, mhtime, mhcharge)
timeleft = buff.expirationTime > 0 and (buff.expirationTime - now) or 0
stacks = buff.stackCount or 0
elseif buff.mode == "MAINHAND" then
timeleft = mhtime and mhtime / 1000 or 0
stacks = mhcharge or 0
elseif buff.mode == "OFFHAND" then elseif buff.mode == "OFFHAND" then
timeleft = ohtime and ohtime / 1000 or 0 RefreshWeaponButton(buff, ohtime, ohcharge)
stacks = ohcharge or 0
end
buff.timer:SetText(timeleft > 0 and GetColoredTimeString(timeleft) or "")
buff.stacks:SetText(stacks > 1 and stacks or "")
end
end
-- Update all visible debuff buttons
buttons = pfUI.buff.debuffs.buttons
for i = 1, 16 do
local buff = buttons[i]
if buff:IsShown() then
local timeleft = buff.expirationTime > 0 and (buff.expirationTime - now) or 0
local stacks = buff.stackCount or 0
buff.timer:SetText(timeleft > 0 and GetColoredTimeString(timeleft) or "")
buff.stacks:SetText(stacks > 1 and stacks or "")
end
end
-- Update weapon buff buttons if separate
if C.buffs.separateweapons == "1" then
buttons = pfUI.buff.wepbuffs.buttons
for i = 1, 2 do
local buff = buttons[i]
if buff:IsShown() then
local timeleft, stacks = 0, 0
if buff.mode == "MAINHAND" then
timeleft = mhtime and mhtime / 1000 or 0
stacks = mhcharge or 0
elseif buff.mode == "OFFHAND" then
timeleft = ohtime and ohtime / 1000 or 0
stacks = ohcharge or 0
end
buff.timer:SetText(timeleft > 0 and GetColoredTimeString(timeleft) or "")
buff.stacks:SetText(stacks > 1 and stacks or "")
end end
end end
end end
end) end)
-- CreateBuffButton refreshes each new button from the slot buffers
ScanPlayerAuraSlots()
-- Weapon Buffs -- Weapon Buffs
pfUI.buff.wepbuffs = CreateFrame("Frame", "pfWepBuffFrame", UIParent) pfUI.buff.wepbuffs = CreateFrame("Frame", "pfWepBuffFrame", UIParent)
pfUI.buff.wepbuffs.count = 0 pfUI.buff.wepbuffs.count = 0
@@ -274,64 +280,72 @@ pfUI:RegisterModule("buff", function ()
pfUI.buff.debuffs.buttons[i] = CreateBuffButton(i, "HARMFUL") pfUI.buff.debuffs.buttons[i] = CreateBuffButton(i, "HARMFUL")
end end
weaponButtons = {
pfUI.buff.buffs.buttons[1], pfUI.buff.buffs.buttons[2],
pfUI.buff.wepbuffs.buttons[1], pfUI.buff.wepbuffs.buttons[2],
}
-- config loading -- config loading
function pfUI.buff:UpdateConfigBuffButton(buff) function pfUI.buff:UpdateConfigBuffButton(buff)
local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize
local buffSize, buffSpacing = tonumber(C.buffs.size), tonumber(C.buffs.spacing)
local rowextra = C.buffs.textinside == "1" and 0 or GetCooldownFontSize(buffSize) * 1.5
local rowcount, relFrame, offsetX, offsetY local rowcount, relFrame, offsetX, offsetY
if buff.btype == "HELPFUL" then if buff.btype == "HELPFUL" then
if buff.weapon == 1 and C.buffs.separateweapons == "1" then if buff.weapon == 1 and C.buffs.separateweapons == "1" then
rowcount = floor((buff.gid-1) / tonumber(C.buffs.wepbuffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.wepbuffrowsize))
relFrame = pfUI.buff.wepbuffs relFrame = pfUI.buff.wepbuffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.wepbuffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.wepbuffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * (rowextra+buffSize+2*buffSpacing)
else else
rowcount = floor((buff.gid-1) / tonumber(C.buffs.buffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.buffrowsize))
relFrame = pfUI.buff.buffs relFrame = pfUI.buff.buffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.buffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.buffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * (rowextra+buffSize+2*buffSpacing)
end end
else else
rowcount = floor((buff.gid-1) / tonumber(C.buffs.debuffrowsize)) rowcount = floor((buff.gid-1) / tonumber(C.buffs.debuffrowsize))
relFrame = pfUI.buff.debuffs relFrame = pfUI.buff.debuffs
offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.debuffrowsize))*(tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetX = -(buff.gid-1-rowcount*tonumber(C.buffs.debuffrowsize))*(buffSize+2*buffSpacing)
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)) offsetY = -(rowcount) * (rowextra+buffSize+2*buffSpacing)
end end
buff:SetSize(buffSize, buffSize)
buff:SetWidth(tonumber(C.buffs.size))
buff:SetHeight(tonumber(C.buffs.size))
buff:ClearAllPoints() buff:ClearAllPoints()
buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY) buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY)
buff.timer:SetFont(pfUI.font_default, fontsize, "OUTLINE")
buff.stacks:SetFont(pfUI.font_default, fontsize+1, "OUTLINE") buff.stacks:SetFont(pfUI.font_default, fontsize+1, "OUTLINE")
buff.timer:SetHeight(fontsize * 1.3) -- the duration numbers sit inside the icon or below it
local countdown = buff.cd:GetCountdownFontString()
buff.timer:ClearAllPoints() countdown:ClearAllPoints()
if C.buffs.textinside == "1" then if C.buffs.textinside == "1" then
buff.timer:SetAllPoints(buff) countdown:SetPoint("CENTER", buff, "CENTER", 0, 0)
else else
buff.timer:SetPoint("TOP", buff, "BOTTOM", 0, -3) countdown:SetPoint("TOP", buff, "BOTTOM", 0, -3)
end end
end end
function pfUI.buff:UpdateConfig() function pfUI.buff:UpdateConfig()
local fontsize = C.buffs.fontsize == "-1" and C.global.font_size or C.buffs.fontsize local spacing = tonumber(C.buffs.spacing)
local cell = tonumber(C.buffs.size) + 2 * spacing
local rowextra = C.buffs.textinside == "1" and 0 or GetCooldownFontSize(tonumber(C.buffs.size)) * 1.5
pfUI.buff.buffs:SetWidth(tonumber(C.buffs.buffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) local function SizeBuffFrame(frame, rowsize, count)
pfUI.buff.buffs:SetHeight(ceil(32/tonumber(C.buffs.buffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) rowsize = tonumber(rowsize)
pfUI.buff.buffs:SetPoint("TOPRIGHT", pfUI.minimap or UIParent, "TOPLEFT", -4*tonumber(C.buffs.spacing), 0) frame:SetSize(rowsize * cell, ceil(count / rowsize) * (rowextra + cell))
end
SizeBuffFrame(pfUI.buff.buffs, C.buffs.buffrowsize, 32)
pfUI.buff.buffs:SetPoint("TOPRIGHT", pfUI.minimap or UIParent, "TOPLEFT", -4 * spacing, 0)
UpdateMovable(pfUI.buff.buffs) UpdateMovable(pfUI.buff.buffs)
pfUI.buff.debuffs:SetWidth(tonumber(C.buffs.debuffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) SizeBuffFrame(pfUI.buff.debuffs, C.buffs.debuffrowsize, 16)
pfUI.buff.debuffs:SetHeight(ceil(16/tonumber(C.buffs.debuffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)))
pfUI.buff.debuffs:SetPoint("TOPRIGHT", pfUI.buff.buffs, "BOTTOMRIGHT", 0, 0) pfUI.buff.debuffs:SetPoint("TOPRIGHT", pfUI.buff.buffs, "BOTTOMRIGHT", 0, 0)
UpdateMovable(pfUI.buff.debuffs) UpdateMovable(pfUI.buff.debuffs)
if C.buffs.separateweapons == "1" then if C.buffs.separateweapons == "1" then
pfUI.buff.wepbuffs:ClearAllPoints() pfUI.buff.wepbuffs:ClearAllPoints()
pfUI.buff.wepbuffs:SetWidth(tonumber(C.buffs.wepbuffrowsize) * (tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing))) SizeBuffFrame(pfUI.buff.wepbuffs, C.buffs.wepbuffrowsize, 2)
pfUI.buff.wepbuffs:SetHeight(ceil(2/tonumber(C.buffs.wepbuffrowsize)) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+tonumber(C.buffs.size)+2*tonumber(C.buffs.spacing)))
pfUI.buff.wepbuffs:SetPoint("TOPRIGHT", pfUI.buff.debuffs, "BOTTOMRIGHT", 0, 0) pfUI.buff.wepbuffs:SetPoint("TOPRIGHT", pfUI.buff.debuffs, "BOTTOMRIGHT", 0, 0)
pfUI.buff.wepbuffs:Show() pfUI.buff.wepbuffs:Show()
UpdateMovable(pfUI.buff.wepbuffs) UpdateMovable(pfUI.buff.wepbuffs)
+77 -72
View File
@@ -73,12 +73,15 @@ pfUI:RegisterModule("buffwatch", function ()
return anchor return anchor
end end
local function GetBuffData(unit, id, type, selfdebuff) -- reusable GetAuraSlots buffer, filled once per RefreshBuffBarFrame
local filter = (selfdebuff and type == "HARMFUL") and "HARMFUL|PLAYER" or type local auraSlots = {}
local aura = C_UnitAuras.GetAuraDataByIndex(unit, id, filter)
if not aura then return end -- Reads one aura by the slot id GetAuraSlots returned (nil slot -> nil).
local remaining = aura.expirationTime > 0 and (aura.expirationTime - GetTime()) or 0 local function GetBuffData(unit, slot)
return remaining, aura.icon, aura.name, aura.applications local name, icon, count, dispelType, _, expirationTime = C_UnitAuras.UnitAuraBySlot(unit, slot)
if not name then return end
local remaining = expirationTime > 0 and (expirationTime - GetTime()) or 0
return remaining, icon, name, count, dispelType
end end
local function StatusBarOnClick() local function StatusBarOnClick()
@@ -90,14 +93,17 @@ pfUI:RegisterModule("buffwatch", function ()
if val == skill then return end if val == skill then return end
end end
config.whitelist = config.whitelist .. "#" .. skill config.whitelist = config.whitelist .. "#" .. skill
fcache[tostring(config)] = nil -- invalidate so the new entry takes effect immediately
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now whitelisted."]) DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now whitelisted."])
elseif IsShiftKeyDown() then elseif IsShiftKeyDown() then
for _, val in pairs({strsplit("#", config.blacklist)}) do for _, val in pairs({strsplit("#", config.blacklist)}) do
if val == skill then return end if val == skill then return end
end end
config.blacklist = config.blacklist .. "#" .. skill config.blacklist = config.blacklist .. "#" .. skill
fcache[tostring(config)] = nil -- invalidate so the new entry takes effect immediately
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now blacklisted."]) DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. skill .. "|r" .. T["is now blacklisted."])
end end
this.parent.Refresh()
elseif this.parent.unit == "player" then elseif this.parent.unit == "player" then
local aura = C_UnitAuras.GetAuraDataByIndex("player", this.id, this.type) local aura = C_UnitAuras.GetAuraDataByIndex("player", this.id, this.type)
if aura and aura.spellId then C_Spell.CancelSpellByID(aura.spellId) end if aura and aura.spellId then C_Spell.CancelSpellByID(aura.spellId) end
@@ -107,31 +113,9 @@ pfUI:RegisterModule("buffwatch", function ()
local function StatusBarOnEnter() local function StatusBarOnEnter()
GameTooltip:SetOwner(this, "NONE") GameTooltip:SetOwner(this, "NONE")
if this.unit == "player" then -- C_UnitAuras lists the player's own auras first, so the selfdebuff
GameTooltip:SetUnitAura("player", this.id, this.type) -- (HARMFUL|PLAYER) list is a prefix of the HARMFUL list: same index.
elseif this.type == "HARMFUL" then GameTooltip:SetUnitAura(this.unit, this.id, this.type)
-- selfdebuff filters the displayed list to player-cast harmful auras, but
-- SetUnitAura's index has to be into the engine's full HARMFUL list. Look
-- up the displayed aura via the PLAYER filter, then scan engine slots for
-- one whose name + sourceGUID match.
local config = this.parent and this.parent.config
if config and config.selfdebuff == "1" then
local ownAura = C_UnitAuras.GetAuraDataByIndex(this.unit, this.id, "HARMFUL|PLAYER")
if ownAura then
for gameSlot = 1, 16 do
local check = C_UnitAuras.GetDebuffDataByIndex(this.unit, gameSlot)
if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
GameTooltip:SetUnitAura(this.unit, gameSlot, "HARMFUL")
break
end
end
end
else
GameTooltip:SetUnitAura(this.unit, this.id, "HARMFUL")
end
elseif this.type == "HELPFUL" then
GameTooltip:SetUnitAura(this.unit, this.id, "HELPFUL")
end
if IsShiftKeyDown() then if IsShiftKeyDown() then
GameTooltip:AddLine(" ") GameTooltip:AddLine(" ")
@@ -162,8 +146,7 @@ pfUI:RegisterModule("buffwatch", function ()
local color = parent.color local color = parent.color
local bordercolor = parent.bordercolor local bordercolor = parent.bordercolor
local textcolor = parent.textcolor local textcolor = parent.textcolor
local width = parent:GetWidth() local width, height = parent:GetSize()
local height = parent:GetHeight()
local framename = "pf" .. parent.unit .. ( parent.type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar" .. bar local framename = "pf" .. parent.unit .. ( parent.type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar" .. bar
local font = parent.config.use_unitfonts == "1" and pfUI.font_unit or pfUI.font_default local font = parent.config.use_unitfonts == "1" and pfUI.font_unit or pfUI.font_default
@@ -172,8 +155,7 @@ pfUI:RegisterModule("buffwatch", function ()
frame:EnableMouse(1) frame:EnableMouse(1)
frame:Hide() frame:Hide()
frame:SetPoint("BOTTOM", 0, (bar-1)*(height+2*border+1)) frame:SetPoint("BOTTOM", 0, (bar-1)*(height+2*border+1))
frame:SetWidth(width) frame:SetSize(width, height)
frame:SetHeight(height)
frame.bar = CreateFrame("StatusBar", "pfBuffBar" .. bar, frame) frame.bar = CreateFrame("StatusBar", "pfBuffBar" .. bar, frame)
frame.bar:SetPoint("TOPLEFT", frame, "TOPLEFT", height+1, 0) frame.bar:SetPoint("TOPLEFT", frame, "TOPLEFT", height+1, 0)
@@ -202,8 +184,7 @@ pfUI:RegisterModule("buffwatch", function ()
frame.time:SetJustifyH("RIGHT") frame.time:SetJustifyH("RIGHT")
frame.icon = frame:CreateTexture(nil, "OVERLAY") frame.icon = frame:CreateTexture(nil, "OVERLAY")
frame.icon:SetWidth(height) frame.icon:SetSize(height, height)
frame.icon:SetHeight(height)
frame.icon:SetPoint("LEFT", frame, "LEFT", 0, 0) frame.icon:SetPoint("LEFT", frame, "LEFT", 0, 0)
frame.icon:SetTexCoord(.07,.93,.07,.93) frame.icon:SetTexCoord(.07,.93,.07,.93)
@@ -225,7 +206,7 @@ pfUI:RegisterModule("buffwatch", function ()
CreateBackdrop(frame) CreateBackdrop(frame)
CreateBackdropShadow(frame) CreateBackdropShadow(frame)
if bordercolor.r ~= "0" and bordercolor.g ~= "0" and bordercolor.b ~= "0" and bordercolor.a ~= "0" then if bordercolor.r ~= 0 and bordercolor.g ~= 0 and bordercolor.b ~= 0 and bordercolor.a ~= 0 then
frame.backdrop:SetBackdropBorderColor(bordercolor.r,bordercolor.g,bordercolor.b,1) frame.backdrop:SetBackdropBorderColor(bordercolor.r,bordercolor.g,bordercolor.b,1)
end end
@@ -235,9 +216,15 @@ pfUI:RegisterModule("buffwatch", function ()
local function RefreshBuffBarFrame(frame) local function RefreshBuffBarFrame(frame)
-- reinitialize all active buffs -- reinitialize all active buffs
local selfdebuff = frame.config.selfdebuff == "1" local selfdebuff = frame.config.selfdebuff == "1"
local filter = (selfdebuff and frame.type == "HARMFUL") and "HARMFUL|PLAYER" or frame.type
-- one GetAuraSlots enumeration per refresh instead of a by-index walk per
-- bar; the i-th slot is the i-th aura of the filtered list, so `i` stays
-- the index the tooltip / cancel handlers pass to the by-index API
ScanAuraSlots(frame.unit, filter, auraSlots, 32)
for i=1,32 do for i=1,32 do
local timeleft, texture, name, stacks = GetBuffData(frame.unit, i, frame.type, selfdebuff) local timeleft, texture, name, stacks, dtype = GetBuffData(frame.unit, auraSlots[i])
timeleft = timeleft or 0 timeleft = timeleft or 0
if texture and name and name ~= "" and BuffIsVisible(frame.config, name) then if texture and name and name ~= "" and BuffIsVisible(frame.config, name) then
@@ -246,19 +233,21 @@ pfUI:RegisterModule("buffwatch", function ()
frame.buffs[i][3] = name frame.buffs[i][3] = name
frame.buffs[i][4] = texture frame.buffs[i][4] = texture
frame.buffs[i][5] = stacks frame.buffs[i][5] = stacks
frame.buffs[i][6] = dtype
else else
frame.buffs[i][1] = 0 frame.buffs[i][1] = 0
frame.buffs[i][2] = nil frame.buffs[i][2] = nil
frame.buffs[i][3] = nil frame.buffs[i][3] = nil
frame.buffs[i][4] = nil frame.buffs[i][4] = nil
frame.buffs[i][5] = 0 frame.buffs[i][5] = 0
frame.buffs[i][6] = nil
end end
end end
table.sort(frame.buffs, frame.buffcmp) table.sort(frame.buffs, frame.buffcmp)
-- create a buff bar for each below threshold -- create a buff bar for each below threshold
local bar = 1 local bar, crossing = 1, nil
for id, data in pairs(frame.buffs) do for id, data in pairs(frame.buffs) do
if data[1] and ((data[1] ~= 0 and data[1] < frame.threshold) or frame.threshold == -1) -- timeleft checks if data[1] and ((data[1] ~= 0 and data[1] < frame.threshold) or frame.threshold == -1) -- timeleft checks
and data[3] and data[3] ~= "" -- buff has a name and data[3] and data[3] ~= "" -- buff has a name
@@ -295,12 +284,9 @@ pfUI:RegisterModule("buffwatch", function ()
-- calculate dynamic auto color -- calculate dynamic auto color
local r, g, b local r, g, b
if frame.type == "HARMFUL" then if frame.type == "HARMFUL" then
r, g, b = 1, .2, .2 -- official Blizzard dispel-type colors (matches unitframes/buff);
local a = C_UnitAuras.GetDebuffDataByIndex(frame.unit, data[2]) -- nil/unknown type falls back to the DEBUFF_TYPE_NONE colour
local dtype = a and a.dispelName r, g, b = C_UnitAuras.GetAuraDispelTypeColor(data[6] or ""):GetRGBA()
if dtype and DebuffTypeColor[dtype] then
r,g,b = DebuffTypeColor[dtype].r,DebuffTypeColor[dtype].g,DebuffTypeColor[dtype].b
end
else else
r,g,b = str2rgb(data[3]) r,g,b = str2rgb(data[3])
end end
@@ -355,6 +341,10 @@ pfUI:RegisterModule("buffwatch", function ()
frame.bars[bar]:Show() frame.bars[bar]:Show()
bar = bar + 1 bar = bar + 1
elseif data[1] and data[1] > 0 and data[3] and data[4] and frame.threshold ~= -1 then
-- still above the threshold: its bar shows once it drops under
local wait = data[1] - frame.threshold
if not crossing or wait < crossing then crossing = wait end
end end
end end
@@ -362,13 +352,11 @@ pfUI:RegisterModule("buffwatch", function ()
for i = bar, table.getn(frame.bars) do for i = bar, table.getn(frame.bars) do
frame.bars[i]:Hide() frame.bars[i]:Hide()
end end
end
-- Create a new Buff Bar -- no event marks an aura's time left dropping under the threshold, so
local function BuffBarFrameOnUpdate() -- wake when the next one does
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + .4 end if frame.crossing then frame.crossing:Cancel() end
RefreshBuffBarFrame(this) frame.crossing = crossing and C_Timer.NewTimer(crossing + .1, frame.Refresh) or nil
this:RefreshPosition()
end end
local function RefreshPosition(self) local function RefreshPosition(self)
@@ -388,6 +376,19 @@ pfUI:RegisterModule("buffwatch", function ()
end end
end end
-- every watch frame: one stacks on the bars of another, so all of them
-- re-anchor together
local watched = {}
local function RefreshPositions()
for _, frame in pairs(watched) do frame:RefreshPosition() end
end
-- the bars sit above their unit frame's aura rows, which move when the
-- rows lay out again
pfUI.events:RegisterCallback("unitframe:auras", function(_, unit)
if unit == pfUI.uf.player or unit == pfUI.uf.target then RefreshPositions() end
end, "buffwatch")
local function CreateBuffBarFrame(unit, type) local function CreateBuffBarFrame(unit, type)
local framename = "pf" .. unit .. ( type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar" local framename = "pf" .. unit .. ( type == "HARMFUL" and "Debuff" or "Buff" ) .. "Bar"
local frame = _G[framename] or CreateFrame("Frame", framename, UIParent) local frame = _G[framename] or CreateFrame("Frame", framename, UIParent)
@@ -403,9 +404,22 @@ pfUI:RegisterModule("buffwatch", function ()
end end
frame.RefreshPosition = RefreshPosition frame.RefreshPosition = RefreshPosition
frame.Refresh = function()
RefreshBuffBarFrame(frame)
RefreshPositions()
end
-- OnEvent (UNIT_AURA) doesn't trigger properly on buff refresh -- UNIT_AURA_DELTA reports refreshes and new durations as well, so the bars
frame:SetScript("OnUpdate", BuffBarFrameOnUpdate) -- follow the auras on events alone. A new target is another unit, whose
-- auras no delta describes.
frame:RegisterUnitEvent("UNIT_AURA_DELTA", frame.unit)
frame:RegisterEvent("PLAYER_ENTERING_WORLD")
if frame.unit == "target" then frame:RegisterEvent("PLAYER_TARGET_CHANGED") end
frame:SetScript("OnEvent", frame.Refresh)
table.insert(watched, frame)
-- the first read waits until the caller has configured the frame
RunNextFrame(frame.Refresh)
return frame return frame
end end
@@ -422,18 +436,15 @@ pfUI:RegisterModule("buffwatch", function ()
if pfUI.uf.player and C.buffbar.pbuff.enable == "1" then if pfUI.uf.player and C.buffbar.pbuff.enable == "1" then
pfUI.uf.player.buffbar = CreateBuffBarFrame("Player", "HELPFUL") pfUI.uf.player.buffbar = CreateBuffBarFrame("Player", "HELPFUL")
local config = C.buffbar.pbuff local config = C.buffbar.pbuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.player.buffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width) pfUI.uf.player.buffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width)
pfUI.uf.player.buffbar:SetHeight(config.height) pfUI.uf.player.buffbar:SetHeight(config.height)
pfUI.uf.player.buffbar.threshold = tonumber(config.threshold) pfUI.uf.player.buffbar.threshold = tonumber(config.threshold)
pfUI.uf.player.buffbar.config = config pfUI.uf.player.buffbar.config = config
pfUI.uf.player.buffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.player.buffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.player.buffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.player.buffbar.color = GetStringColorObject(config.color)
pfUI.uf.player.buffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.player.buffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.player.buffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.player.buffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.player.buffbar.anchors = { pfUI.uf.player.buffbar.anchors = {
pfUI.uf.player, pfUI.uf.player,
pfUI.uf.player and pfUI.uf.player.debuffs, pfUI.uf.player and pfUI.uf.player.debuffs,
@@ -448,9 +459,6 @@ pfUI:RegisterModule("buffwatch", function ()
-- create player debuffbars -- create player debuffbars
if pfUI.uf.player and C.buffbar.pdebuff.enable == "1" then if pfUI.uf.player and C.buffbar.pdebuff.enable == "1" then
local config = C.buffbar.pdebuff local config = C.buffbar.pdebuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.player.debuffbar = CreateBuffBarFrame("Player", "HARMFUL") pfUI.uf.player.debuffbar = CreateBuffBarFrame("Player", "HARMFUL")
pfUI.uf.player.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width) pfUI.uf.player.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.player:GetWidth() or config.width)
@@ -458,9 +466,9 @@ pfUI:RegisterModule("buffwatch", function ()
pfUI.uf.player.debuffbar.threshold = tonumber(config.threshold) pfUI.uf.player.debuffbar.threshold = tonumber(config.threshold)
pfUI.uf.player.debuffbar.config = config pfUI.uf.player.debuffbar.config = config
pfUI.uf.player.debuffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.player.debuffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.player.debuffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.player.debuffbar.color = GetStringColorObject(config.color)
pfUI.uf.player.debuffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.player.debuffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.player.debuffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.player.debuffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.player.debuffbar.anchors = { pfUI.uf.player.debuffbar.anchors = {
pfUI.uf.player, pfUI.uf.player,
pfUI.uf.player and pfUI.uf.player.buffbar and pfUI.uf.player.buffbar.bars, pfUI.uf.player and pfUI.uf.player.buffbar and pfUI.uf.player.buffbar.bars,
@@ -476,18 +484,15 @@ pfUI:RegisterModule("buffwatch", function ()
-- create target debuffbars -- create target debuffbars
if pfUI.uf.target and C.buffbar.tdebuff.enable == "1" then if pfUI.uf.target and C.buffbar.tdebuff.enable == "1" then
local config = C.buffbar.tdebuff local config = C.buffbar.tdebuff
local r, g, b, a = strsplit(",", config.color)
local br, bg, bb, ba = strsplit(",", config.bordercolor)
local tr, tg, tb, ta = strsplit(",", config.textcolor)
pfUI.uf.target.debuffbar = CreateBuffBarFrame("Target", "HARMFUL") pfUI.uf.target.debuffbar = CreateBuffBarFrame("Target", "HARMFUL")
pfUI.uf.target.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.target:GetWidth() or config.width) pfUI.uf.target.debuffbar:SetWidth(config.width == "-1" and pfUI.uf.target:GetWidth() or config.width)
pfUI.uf.target.debuffbar:SetHeight(config.height) pfUI.uf.target.debuffbar:SetHeight(config.height)
pfUI.uf.target.debuffbar.config = config pfUI.uf.target.debuffbar.config = config
pfUI.uf.target.debuffbar.buffcmp = config.sort == "asc" and asc or desc pfUI.uf.target.debuffbar.buffcmp = config.sort == "asc" and asc or desc
pfUI.uf.target.debuffbar.color = { r = r, g = g, b = b, a = a } pfUI.uf.target.debuffbar.color = GetStringColorObject(config.color)
pfUI.uf.target.debuffbar.bordercolor = { r = br, g = bg, b = bb, a = ba } pfUI.uf.target.debuffbar.bordercolor = GetStringColorObject(config.bordercolor)
pfUI.uf.target.debuffbar.textcolor = { r = tr, g = tg, b = tb, a = ta } pfUI.uf.target.debuffbar.textcolor = GetStringColorObject(config.textcolor)
pfUI.uf.target.debuffbar.threshold = tonumber(config.threshold) pfUI.uf.target.debuffbar.threshold = tonumber(config.threshold)
pfUI.uf.target.debuffbar.anchors = { pfUI.uf.target.debuffbar.anchors = {
pfUI.uf.target, pfUI.uf.target,
+153 -163
View File
@@ -16,9 +16,13 @@ pfUI:RegisterModule("castbar", function ()
end end
end end
-- Clear cast state on the bar. Shows the bar full for one frame, then -- Clear cast state on the bar and start the fade-out. On a normal end the bar
-- OnUpdate fades it out. -- is left at its current fill (a completed cast is already ~full; nothing
local function ClearBar(cb) -- snaps to full, which used to flash for a frame when the next cast stamped
-- the bar). When `failed` is set for a cast that was actually in progress, the
-- bar flashes full red before fading — the cancelled-cast indicator.
local function ClearBar(cb, failed)
local wasActive = cb.endTime ~= nil
cb.startTime, cb.endTime, cb.isChannel = nil, nil, nil cb.startTime, cb.endTime, cb.isChannel = nil, nil, nil
cb.activeName, cb.spellID = nil, nil cb.activeName, cb.spellID = nil, nil
cb.isTradeskill = nil cb.isTradeskill = nil
@@ -26,10 +30,13 @@ pfUI:RegisterModule("castbar", function ()
cb.tradeskillSingleMs, cb.currentCraftStart = nil, nil cb.tradeskillSingleMs, cb.currentCraftStart = nil, nil
cb.lastMax = nil cb.lastMax = nil
cb.delay = 0 cb.delay = 0
cb.bar:SetMinMaxValues(1, 100) if failed and wasActive then
cb.bar:SetValue(100) cb.bar:SetStatusBarColor(GetStringColor(C.appearance.castbar.failcolor))
cb.bar:SetMinMaxValues(0, 1)
cb.bar:SetValue(1)
end
if cb.bar.spark then cb.bar.spark:Hide() end if cb.bar.spark then cb.bar.spark:Hide() end
cb.fadeout = 1 if cb:GetAlpha() > 0 and not cb.fade:IsPlaying() then cb.fade:Play() end
end end
-- "Spellname (N)" label for an active tradeskill merge — N is the number -- "Spellname (N)" label for an active tradeskill merge — N is the number
@@ -38,7 +45,7 @@ pfUI:RegisterModule("castbar", function ()
if not cb.tradeskillTotal or not cb.activeName or not cb.showname then return end if not cb.tradeskillTotal or not cb.activeName or not cb.showname then return end
local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0) local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0)
if remaining > 1 then if remaining > 1 then
cb.bar.left:SetText(string.format("%s (%d)", cb.activeName, remaining)) cb.bar.left:SetFormattedText("%s (%d)", cb.activeName, remaining)
else else
cb.bar.left:SetText(cb.activeName) cb.bar.left:SetText(cb.activeName)
end end
@@ -65,8 +72,8 @@ pfUI:RegisterModule("castbar", function ()
end end
-- Mark the start of craft 2..N within an active merge (called from the -- Mark the start of craft 2..N within an active merge (called from the
-- SPELLCAST_START / SPELL_START_SELF handlers). Resets the per-craft -- UNIT_SPELLCAST_START handler). Resets the per-craft spark to the left
-- spark to the left edge of the bar. -- edge of the bar.
local function StartTradeskillCraft(cb) local function StartTradeskillCraft(cb)
cb.currentCraftStart = GetTime() * 1000 cb.currentCraftStart = GetTime() * 1000
local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0) local remaining = cb.tradeskillTotal - (cb.tradeskillCompleted or 0)
@@ -79,7 +86,7 @@ pfUI:RegisterModule("castbar", function ()
-- Stamp the bar with cast data and render text/icon/lag once. OnUpdate -- Stamp the bar with cast data and render text/icon/lag once. OnUpdate
-- then animates the fill from this state without touching C_Spell. -- then animates the fill from this state without touching C_Spell.
local function StampBar(cb, name, tex, startMs, endMs, spellID, isChannel, delayMs, isTradeskill) local function StampBar(cb, name, tex, startMs, endMs, spellID, isChannel, delayMs, isTradeskill, rank, noInterrupt)
cb.startTime = startMs cb.startTime = startMs
cb.endTime = endMs cb.endTime = endMs
cb.isChannel = isChannel cb.isChannel = isChannel
@@ -87,15 +94,21 @@ pfUI:RegisterModule("castbar", function ()
cb.activeName = name cb.activeName = name
cb.isTradeskill = isTradeskill cb.isTradeskill = isTradeskill
cb.delay = (delayMs or 0) / 1000 cb.delay = (delayMs or 0) / 1000
cb.fade:Stop()
cb:SetAlpha(1) cb:SetAlpha(1)
cb.fadeout = nil
cb.bar:SetStatusBarColor(strsplit(",", C.appearance.castbar[isChannel and "channelcolor" or "castbarcolor"])) -- Shield an uninterruptible cast. Not on the player's own bar: the flag is
-- measured against the reader's own interrupts and silences, so on your own
-- cast it answers a question nobody asked.
SetCastbarShield(cb.bar, cb.icon, noInterrupt and cb.unitstr ~= "player", isChannel)
local rank = "" -- Rank: prefer the value the UNIT_SPELLCAST_* event delivered (arg5, passed
if spellID and GetSpellRecField then -- through by RefreshBar). Only the retarget re-poll has no event in hand, so
rank = GetSpellRecField(spellID, "rank") or "" -- it falls back to a lookup.
if not rank and spellID then
rank = C_Spell.GetSpellSubtext(spellID) or ""
end end
rank = rank or ""
local spellname = (cb.showname and name) and (name .. " ") or "" local spellname = (cb.showname and name) and (name .. " ") or ""
local rankstr = (cb.showrank and rank ~= "") and string.format("|cffaaffcc[%s]|r", rank) or "" local rankstr = (cb.showrank and rank ~= "") and string.format("|cffaaffcc[%s]|r", rank) or ""
cb.bar.left:SetText(spellname .. rankstr) cb.bar.left:SetText(spellname .. rankstr)
@@ -103,8 +116,7 @@ pfUI:RegisterModule("castbar", function ()
if tex and cb.showicon then if tex and cb.showicon then
local size = cb:GetHeight() local size = cb:GetHeight()
cb.icon:Show() cb.icon:Show()
cb.icon:SetHeight(size) cb.icon:SetSize(size, size)
cb.icon:SetWidth(size)
cb.icon.texture:SetTexture(tex) cb.icon.texture:SetTexture(tex)
cb.bar:SetPoint("TOPLEFT", cb.icon, "TOPRIGHT", cb.spacing, 0) cb.bar:SetPoint("TOPLEFT", cb.icon, "TOPRIGHT", cb.spacing, 0)
else else
@@ -123,20 +135,30 @@ pfUI:RegisterModule("castbar", function ()
cb.bar:SetMinMaxValues(0, duration) cb.bar:SetMinMaxValues(0, duration)
cb.lastMax = duration cb.lastMax = duration
-- Prime the fill on this frame. StampBar otherwise leaves the previous
-- value in place (ClearBar, run on the prior cast's STOP, leaves it full),
-- so the bar would flash full for the frame between here and the next
-- OnUpdate tick. Reset the throttle too so the timer text updates promptly.
local nowSec = GetTime()
local cur = isChannel and (endMs / 1000 - nowSec) or (nowSec - startMs / 1000)
if cur < 0 then cur = 0 elseif cur > duration then cur = duration end
cb.bar:SetValue(cur)
cb.tick = 0
end end
-- One-shot poll: read C_Spell for the bar's unit, stamp or clear. Called -- One-shot poll: read C_Spell for the bar's unit, stamp or clear. Called
-- from event handlers (cast start, target/focus change), never per-frame. -- from event handlers (cast start, target/focus change), never per-frame.
local function RefreshBar(cb) local function RefreshBar(cb, rank)
local query = cb.unitstr ~= "" and cb.unitstr or cb.unitname local query = cb.unitstr
if not query or (cb.unitstr ~= "" and not UnitExists(cb.unitstr)) then if not UnitExists(query) then
ClearBar(cb) ClearBar(cb)
return return
end end
local name, _, tex, startMs, endMs, isTradeskill, _, _, spellID, _, delayMs = C_Spell.UnitCastingInfo(query) local name, _, tex, startMs, endMs, isTradeskill, _, noInterrupt, spellID, _, delayMs = C_Spell.UnitCastingInfo(query)
local isChan local isChan
if not name then if not name then
name, _, tex, startMs, endMs, _, _, spellID = C_Spell.UnitChannelInfo(query) name, _, tex, startMs, endMs, _, noInterrupt, spellID = C_Spell.UnitChannelInfo(query)
isChan = true isChan = true
end end
-- Synthetic fallback for abilities the engine treats as instant-cast but -- Synthetic fallback for abilities the engine treats as instant-cast but
@@ -150,13 +172,13 @@ pfUI:RegisterModule("castbar", function ()
end end
end end
if name and startMs and endMs then if name and startMs and endMs then
StampBar(cb, name, tex, startMs, endMs, spellID, isChan, delayMs, isTradeskill) StampBar(cb, name, tex, startMs, endMs, spellID, isChan, delayMs, isTradeskill, rank, noInterrupt)
else else
ClearBar(cb) ClearBar(cb)
end end
end end
local function CreateCastbar(name, parent, unitstr, unitname) local function CreateCastbar(name, parent, unitstr)
local cb = CreateFrame("Frame", name, parent or UIParent) local cb = CreateFrame("Frame", name, parent or UIParent)
cb:SetHeight(C.global.font_size * 1.5) cb:SetHeight(C.global.font_size * 1.5)
@@ -164,13 +186,11 @@ pfUI:RegisterModule("castbar", function ()
cb:SetFrameLevel(8) cb:SetFrameLevel(8)
cb.unitstr = unitstr cb.unitstr = unitstr
cb.unitname = unitname
-- icon -- icon
cb.icon = CreateFrame("Frame", nil, cb) cb.icon = CreateFrame("Frame", nil, cb)
cb.icon:SetPoint("TOPLEFT", 0, 0) cb.icon:SetPoint("TOPLEFT", 0, 0)
cb.icon:SetHeight(16) cb.icon:SetSize(16, 16)
cb.icon:SetWidth(16)
cb.icon.texture = cb.icon:CreateTexture(nil, "OVERLAY") cb.icon.texture = cb.icon:CreateTexture(nil, "OVERLAY")
cb.icon.texture:SetAllPoints() cb.icon.texture:SetAllPoints()
@@ -214,21 +234,27 @@ pfUI:RegisterModule("castbar", function ()
cb.bar.lag = cb.bar:CreateTexture(nil, "OVERLAY") cb.bar.lag = cb.bar:CreateTexture(nil, "OVERLAY")
cb.bar.lag:SetPoint("TOPRIGHT", cb.bar, "TOPRIGHT", 0, 0) cb.bar.lag:SetPoint("TOPRIGHT", cb.bar, "TOPRIGHT", 0, 0)
cb.bar.lag:SetPoint("BOTTOMRIGHT", cb.bar, "BOTTOMRIGHT", 0, 0) cb.bar.lag:SetPoint("BOTTOMRIGHT", cb.bar, "BOTTOMRIGHT", 0, 0)
cb.bar.lag:SetTexture(1,.2,.2,.2) cb.bar.lag:SetColorTexture(1,.2,.2,.2)
-- Per-craft progress spark for tradeskill merge — a thin vertical line -- Per-craft progress spark for tradeskill merge — a thin vertical line
-- that crosses the bar once per craft in the chain (so on a 5-stack it -- that crosses the bar once per craft in the chain (so on a 5-stack it
-- moves 5x faster than the main fill). Position is updated by OnUpdate -- moves 5x faster than the main fill). Position is updated by OnUpdate
-- while a merge is active; hidden otherwise. -- while a merge is active; hidden otherwise.
cb.bar.spark = cb.bar:CreateTexture(nil, "OVERLAY") cb.bar.spark = cb.bar:CreateTexture(nil, "OVERLAY")
cb.bar.spark:SetTexture(1, 1, 1, 0.8) cb.bar.spark:SetColorTexture(1, 1, 1, 0.8)
cb.bar.spark:SetWidth(2) cb.bar.spark:SetWidth(2)
cb.bar.spark:SetPoint("TOP", cb.bar, "TOPLEFT", 0, 0) cb.bar.spark:SetPoint("TOP", cb.bar, "TOPLEFT", 0, 0)
cb.bar.spark:SetPoint("BOTTOM", cb.bar, "BOTTOMLEFT", 0, 0) cb.bar.spark:SetPoint("BOTTOM", cb.bar, "BOTTOMLEFT", 0, 0)
cb.bar.spark:Hide() cb.bar.spark:Hide()
-- OnUpdate animates the bar fill and fades it out on completion. All -- Fade-out after a cast ends. The bar stays at alpha 0 while idle.
-- state transitions (cast start/stop/interrupt, channel start/stop, cb.fade = cb:CreateAnimationGroup()
local fade = cb.fade:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(.4)
cb.fade:SetScript("OnFinished", function() cb:SetAlpha(0) end)
-- OnUpdate animates the bar fill. All state transitions (cast start/stop/interrupt, channel start/stop,
-- pushback) come from the event handler below — we never poll C_Spell -- pushback) come from the event handler below — we never poll C_Spell
-- here. -- here.
cb:SetScript("OnUpdate", function() cb:SetScript("OnUpdate", function()
@@ -236,15 +262,12 @@ pfUI:RegisterModule("castbar", function ()
this.tick = GetTime() + 0.020 -- ~50 FPS this.tick = GetTime() + 0.020 -- ~50 FPS
if this.drag and this.drag:IsShown() then if this.drag and this.drag:IsShown() then
this.fade:Stop()
this:SetAlpha(1) this:SetAlpha(1)
return return
end end
if this.fadeout and this:GetAlpha() > 0 then if this.fade:IsPlaying() then return end
this:SetAlpha(this:GetAlpha() - 0.05)
if this:GetAlpha() <= 0 then this.fadeout = nil end
return
end
if not this.endTime then if not this.endTime then
if this:GetAlpha() ~= 0 then this:SetAlpha(0) end if this:GetAlpha() ~= 0 then this:SetAlpha(0) end
@@ -253,7 +276,7 @@ pfUI:RegisterModule("castbar", function ()
-- Non-player bars: if the unit disappears (target died / detarget), -- Non-player bars: if the unit disappears (target died / detarget),
-- drop the bar immediately. -- drop the bar immediately.
if this.unitstr ~= "" and this.unitstr ~= "player" and not UnitExists(this.unitstr) then if this.unitstr ~= "player" and not UnitExists(this.unitstr) then
ClearBar(this) ClearBar(this)
return return
end end
@@ -296,35 +319,39 @@ pfUI:RegisterModule("castbar", function ()
end end
end) end)
-- Cast lifecycle events. Player bars react to vanilla SPELLCAST_*; non- -- Cast lifecycle, entirely on ClassicAPI's UNIT_SPELLCAST_* events. They
-- player bars also react to Nampower SPELL_*_OTHER (gated by the -- fire per unit token: arg1=="player" for the player's own casts, and the
-- NP_EnableSpell{Start,Go}Events CVars, enabled by libdebuff) plus the -- remote token(s) ("target", "focus", ...) for other units -- so one set of
-- retarget event. Player events also feed non-player bars for the -- events drives every bar with no Nampower dependency. The handler routes an
-- target=self case. -- event to this bar when arg1 matches its unit, or -- since the player's own
cb:RegisterEvent("SPELLCAST_START") -- casts only ever fire arg1=="player" -- when the bar's unit resolves to the
cb:RegisterEvent("SPELLCAST_STOP") -- player (target=self). PLAYER_TARGET/FOCUS_CHANGED re-polls so a unit
cb:RegisterEvent("SPELLCAST_FAILED") -- already mid-cast when it becomes the target/focus still shows.
cb:RegisterEvent("SPELLCAST_INTERRUPTED") -- Filter to this bar's unit, plus "player" for the target/focus bars: the
cb:RegisterEvent("SPELLCAST_CHANNEL_START") -- player's own casts only ever fire arg1=="player", so a self-targeted cast
cb:RegisterEvent("SPELLCAST_CHANNEL_STOP") -- has to reach them too (nil for the player bar itself, which the filter
cb:RegisterEvent("SPELLCAST_CHANNEL_UPDATE") -- skips). This only narrows what arrives -- the arg1/UnitIsUnit test below
cb:RegisterEvent("SPELL_DELAYED_SELF") -- still decides whether the bar acts on it.
-- Chained same-spell recasts never run the client cast path (the 1.12 local selfunit = unitstr ~= "player" and "player" or nil
-- engine short-circuits at spellID == current-cast), so vanilla cb:RegisterUnitEvent("UNIT_SPELLCAST_START", unitstr, selfunit)
-- SPELLCAST_START never fires for them. nampower's SPELL_START_SELF cb:RegisterUnitEvent("UNIT_SPELLCAST_STOP", unitstr, selfunit)
-- (server-driven) is the only signal that shows them. cb:RegisterUnitEvent("UNIT_SPELLCAST_FAILED", unitstr, selfunit)
cb:RegisterEvent("SPELL_START_SELF") cb:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTED", unitstr, selfunit)
if unitstr == "player" then cb:RegisterUnitEvent("UNIT_SPELLCAST_DELAYED", unitstr, selfunit)
cb:RegisterEvent("SPELL_GO_SELF") cb:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", unitstr, selfunit)
cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_START", unitstr, selfunit)
cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", unitstr, selfunit)
cb:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_UPDATE", unitstr, selfunit)
if unitstr == "target" then
cb:RegisterEvent("PLAYER_TARGET_CHANGED")
elseif unitstr == "focus" then
cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
end end
if unitstr ~= "player" and unitstr ~= "" then -- The shield can flip mid-cast (the caster gains or loses an aura that
cb:RegisterEvent("SPELL_START_OTHER") -- blocks interrupts). These only fire for target and focus.
cb:RegisterEvent("SPELL_FAILED_OTHER") if unitstr == "target" or unitstr == "focus" then
if unitstr == "target" then cb:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTIBLE", unitstr)
cb:RegisterEvent("PLAYER_TARGET_CHANGED") cb:RegisterUnitEvent("UNIT_SPELLCAST_NOT_INTERRUPTIBLE", unitstr)
elseif unitstr == "focus" then
cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
end
end end
cb:SetScript("OnEvent", function() cb:SetScript("OnEvent", function()
@@ -335,83 +362,33 @@ pfUI:RegisterModule("castbar", function ()
return return
end end
if event == "SPELL_START_OTHER" then -- UNIT_SPELLCAST_* fire per unit token (arg1). Handle an event when it's
-- arg3=casterGuid. Defer one frame so ClassicAPI's UnitChannelInfo -- for this bar's unit, or -- since the player's own casts only ever fire
-- can see the engine's +0x228 broadcast for remote-unit channels -- arg1=="player" -- when this bar's unit currently resolves to the player
-- (the cohook+packet handler runs in the same frame; the broadcast -- (target=self / focus=self).
-- propagates after). -- Args: arg1=unit, arg2=castGUID, arg3=spellID, arg4=name, arg5=rank.
if arg3 == UnitGUID(unit) then if arg1 ~= unit and not (arg1 == "player" and UnitIsUnit(unit, "player")) then
local target = this
RunNextFrame(function() RefreshBar(target) end)
end
return return
end end
if event == "SPELL_FAILED_OTHER" then if event == "UNIT_SPELLCAST_START" or event == "UNIT_SPELLCAST_CHANNEL_START" then
if arg1 == UnitGUID(unit) then ClearBar(this) end -- START also fires per craft in a same-spell chain, so an active merge
return -- just resyncs the current craft's spark/label instead of restamping.
end
-- Vanilla SPELLCAST_* + SPELL_DELAYED_SELF fire only for the local
-- player. Non-player bars handle them only when their unit currently
-- resolves to the player (target=self / focus=self).
if not UnitIsUnit(unit, 'player') then return end
if event == "SPELLCAST_START" or event == "SPELLCAST_CHANNEL_START" then
if this.tradeskillTotal then if this.tradeskillTotal then
-- Mid-chain craft N+1 of N. Keep the merged bar; resync the spark
-- to the new craft's start and refresh the "(N)" count label.
StartTradeskillCraft(this) StartTradeskillCraft(this)
else else
RefreshBar(this) RefreshBar(this, arg5)
if this.isTradeskill and (this.pendingTradeskillCount or 0) > 1 if this.isTradeskill and (this.pendingTradeskillCount or 0) > 1
and C.castbar.player.mergetradeskill == "1" then and C.castbar.player.mergetradeskill == "1" then
EnterTradeskillMerge(this, this.startTime, this.endTime, this.pendingTradeskillCount) EnterTradeskillMerge(this, this.startTime, this.endTime, this.pendingTradeskillCount)
end end
this.pendingTradeskillCount = nil this.pendingTradeskillCount = nil
end end
elseif event == "SPELL_START_SELF" then elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
-- Catches chained same-spell recasts (no SPELLCAST_START fires) — -- Per-craft completion during a tradeskill merge (arg3 = spellID):
-- including tradeskill chaining where craft 2..N reuse one spell. -- count and clear when the chain is done. A no-op for normal casts,
-- Defer one frame so ClassicAPI's SMSG_SPELL_START co-hook has -- which are cleared by UNIT_SPELLCAST_STOP.
-- stamped g_cast before we poll, regardless of co-hook order. if this.tradeskillTotal and arg3 == this.tradeskillSpellID then
if this.tradeskillTotal then
StartTradeskillCraft(this)
else
local target = this
RunNextFrame(function()
-- Re-check: SPELL_START_SELF (nampower co-hook) fires before vanilla
-- SPELLCAST_START on the same packet, so SPELLCAST_START may have
-- entered merge in this same frame. Don't restamp over it.
if target.tradeskillTotal then
StartTradeskillCraft(target)
return
end
RefreshBar(target)
if target.unitstr == "player" and target.isTradeskill
and (target.pendingTradeskillCount or 0) > 1
and C.castbar.player.mergetradeskill == "1" then
EnterTradeskillMerge(target, target.startTime, target.endTime, target.pendingTradeskillCount)
end
target.pendingTradeskillCount = nil
end)
end
elseif event == "SPELLCAST_CHANNEL_STOP" then
-- A channel's stop can arrive after a following cast already claimed
-- the bar (channel->cast transition); only clear if a channel is
-- actually being shown, so it doesn't wipe an active cast bar.
if this.isChannel then ClearBar(this) end
elseif event == "SPELLCAST_STOP" then
-- During a tradeskill chain, SPELL_GO_SELF already counted this craft
-- and either cleared the bar (chain done) or kept it running. Only a
-- non-merge cast clears here.
if not this.tradeskillTotal then ClearBar(this) end
elseif event == "SPELLCAST_FAILED" or event == "SPELLCAST_INTERRUPTED" then
ClearBar(this)
elseif event == "SPELL_GO_SELF" then
-- arg2 = spellId. In a tradeskill merge, count each successful craft
-- and clear when the chain is done.
if this.tradeskillTotal and arg2 == this.tradeskillSpellID then
this.tradeskillCompleted = (this.tradeskillCompleted or 0) + 1 this.tradeskillCompleted = (this.tradeskillCompleted or 0) + 1
if this.tradeskillCompleted >= this.tradeskillTotal then if this.tradeskillCompleted >= this.tradeskillTotal then
ClearBar(this) ClearBar(this)
@@ -419,33 +396,49 @@ pfUI:RegisterModule("castbar", function ()
UpdateTradeskillLabel(this) UpdateTradeskillLabel(this)
end end
end end
elseif event == "SPELL_DELAYED_SELF" then elseif event == "UNIT_SPELLCAST_CHANNEL_STOP" then
-- Cast pushback. nampower's event carries the delay (arg2); apply it -- A channel's stop can arrive after a following cast already claimed
-- locally rather than re-polling, so the bar doesn't depend on -- the bar (channel->cast transition); only clear if a channel is
-- ClassicAPI's SMSG_SPELL_DELAYED co-hook having bumped g_cast before -- actually being shown, so it doesn't wipe an active cast bar.
-- this fires (co-hook order vs nampower is not guaranteed). if this.isChannel then ClearBar(this) end
if not this.endTime or not arg2 then return end elseif event == "UNIT_SPELLCAST_STOP" then
local delayMs = tonumber(arg2) or 0 -- STOP fires between crafts in a merge too (each craft is a new cast);
if delayMs > 0 then -- UNIT_SPELLCAST_SUCCEEDED owns the count, so only a non-merge cast
this.delay = (this.delay or 0) + delayMs / 1000 -- clears here.
this.endTime = this.endTime + delayMs if not this.tradeskillTotal then ClearBar(this) end
local newDuration = (this.endTime - this.startTime) / 1000 elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then
this.bar:SetMinMaxValues(0, newDuration) ClearBar(this, true)
this.lastMax = newDuration elseif event == "UNIT_SPELLCAST_INTERRUPTIBLE" or event == "UNIT_SPELLCAST_NOT_INTERRUPTIBLE" then
if this.endTime then
SetCastbarShield(this.bar, this.icon, event == "UNIT_SPELLCAST_NOT_INTERRUPTIBLE", this.isChannel)
end end
elseif event == "SPELLCAST_CHANNEL_UPDATE" then elseif event == "UNIT_SPELLCAST_DELAYED" or event == "UNIT_SPELLCAST_CHANNEL_UPDATE" then
-- Channel pushback. ClassicAPI doesn't track channel delay in -- Pushback: a cast delayed later or a channel shortened. Following
-- g_channel, so we adjust endTime + delay locally and resize the -- Quartz, re-poll just the times and accumulate the shift into a running
-- bar so OnUpdate animates against the new total. -- this.delay for the +/- indicator, rather than a full restamp (which
if not this.endTime or not arg1 then return end -- would reset that total and re-render icon/text). ClassicAPI moves
local newEndMs = GetTime() * 1000 + arg1 -- endMs (SpellDelayed_h bumps g_cast.endMs; the MSG_CHANNEL_UPDATE
local diff = this.endTime - newEndMs -- co-hook rewrites g_channel.endMs) while startMs stays put, so we diff
if diff > 50 then -- endMs. delay is a positive magnitude; OnUpdate signs it "+" for casts
this.delay = (this.delay or 0) + diff / 1000 -- and "-" for channels. Skipped during a tradeskill merge.
this.endTime = newEndMs if this.endTime and not this.tradeskillTotal then
local newDuration = (this.endTime - this.startTime) / 1000 local startMs, endMs
this.bar:SetMinMaxValues(0, newDuration) if this.isChannel then
this.lastMax = newDuration local _, _, _, s, e = C_Spell.UnitChannelInfo(unit)
startMs, endMs = s, e
else
local _, _, _, s, e = C_Spell.UnitCastingInfo(unit)
startMs, endMs = s, e
end
if startMs and endMs then
local shift = this.isChannel and (this.endTime - endMs) or (endMs - this.endTime)
this.delay = (this.delay or 0) + shift / 1000
this.startTime = startMs
this.endTime = endMs
local newDuration = (endMs - startMs) / 1000
this.bar:SetMinMaxValues(0, newDuration)
this.lastMax = newDuration
end
end end
end end
end) end)
@@ -491,10 +484,10 @@ pfUI:RegisterModule("castbar", function ()
UpdateMovable(pfUI.castbar.player) UpdateMovable(pfUI.castbar.player)
-- Tradeskill merge: hook DoTradeSkill so the player castbar knows the -- Tradeskill merge: hook DoTradeSkill so the player castbar knows the
-- requested count before the first SPELLCAST_START fires. Always-on hook -- requested count before the first UNIT_SPELLCAST_START fires. Always-on
-- (the config knob is read at event time so toggling takes effect on the -- hook (the config knob is read at event time so toggling takes effect on
-- next craft without a /reload). DoTradeSkill is synchronous; the server -- the next craft without a /reload). DoTradeSkill is synchronous; the
-- roundtrip to SPELLCAST_START gives us plenty of time after this hook. -- server roundtrip to UNIT_SPELLCAST_START gives us plenty of time.
hooksecurefunc("DoTradeSkill", function(index, num) hooksecurefunc("DoTradeSkill", function(index, num)
if pfUI.castbar.player then if pfUI.castbar.player then
pfUI.castbar.player.pendingTradeskillCount = tonumber(num) or 1 pfUI.castbar.player.pendingTradeskillCount = tonumber(num) or 1
@@ -549,9 +542,6 @@ pfUI:RegisterModule("castbar", function ()
pfUI.castbar.focus:SetHeight(C.castbar.focus.height) pfUI.castbar.focus:SetHeight(C.castbar.focus.height)
end end
-- bind castbar to the "focus" unit token; the GUID resolves at read time
pfUI.castbar.focus.unitstr = "focus"
UpdateMovable(pfUI.castbar.focus) UpdateMovable(pfUI.castbar.focus)
end end
end) end)
+196 -185
View File
@@ -63,6 +63,23 @@ pfUI:RegisterModule("chat", function ()
return pfUI_cache["chathistory"][realm][player][id] return pfUI_cache["chathistory"][realm][player][id]
end end
-- [ Chat Panel Colors ]
-- The panels normally inherit pfUI's global appearance theme; custom colors let chat
-- deviate from it. CreateBackdrop is re-run first to restore the theme, so toggling
-- custom colors back off doesn't leave the previous override behind.
local function ApplyPanelColors(panel)
if not panel then return end
CreateBackdrop(panel, default_border, nil, .8)
if C.chat.global.custombg ~= "1" then return end
local r, g, b, a = GetStringColor(C.chat.global.background)
panel.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = GetStringColor(C.chat.global.border)
panel.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat = CreateFrame("Frame",nil,UIParent) pfUI.chat = CreateFrame("Frame",nil,UIParent)
pfUI.chat.left = CreateFrame("Frame", "pfChatLeft", UIParent) pfUI.chat.left = CreateFrame("Frame", "pfChatLeft", UIParent)
@@ -76,19 +93,11 @@ pfUI:RegisterModule("chat", function ()
pfUI.chat.left:SetPoint("BOTTOMLEFT", 2*default_border,2*default_border) pfUI.chat.left:SetPoint("BOTTOMLEFT", 2*default_border,2*default_border)
pfUI.chat.left:SetScript("OnShow", function() pfUI.chat:RefreshChat() end) pfUI.chat.left:SetScript("OnShow", function() pfUI.chat:RefreshChat() end)
UpdateMovable(pfUI.chat.left) UpdateMovable(pfUI.chat.left)
CreateBackdrop(pfUI.chat.left, default_border, nil, .8) ApplyPanelColors(pfUI.chat.left)
if C.chat.global.frameshadow == "1" then if C.chat.global.frameshadow == "1" then
CreateBackdropShadow(pfUI.chat.left) CreateBackdropShadow(pfUI.chat.left)
end end
if C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background)
pfUI.chat.left.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border)
pfUI.chat.left.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat.left.panelTop = CreateFrame("Frame", "leftChatPanelTop", pfUI.chat.left) pfUI.chat.left.panelTop = CreateFrame("Frame", "leftChatPanelTop", pfUI.chat.left)
pfUI.chat.left.panelTop:ClearAllPoints() pfUI.chat.left.panelTop:ClearAllPoints()
pfUI.chat.left.panelTop:SetHeight(C.global.font_size+default_border*2) pfUI.chat.left.panelTop:SetHeight(C.global.font_size+default_border*2)
@@ -136,7 +145,7 @@ pfUI:RegisterModule("chat", function ()
["URL"] = function(a1,a2,a3) return pfUI.chat:FormatLink(pfUI.chat.URLPattern.URL.fm,a1,a2,a3) end, ["URL"] = function(a1,a2,a3) return pfUI.chat:FormatLink(pfUI.chat.URLPattern.URL.fm,a1,a2,a3) end,
} }
-- url copy dialog -- url links
function pfUI.chat:FormatLink(formatter,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) function pfUI.chat:FormatLink(formatter,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
if not (formatter and a1) then return end if not (formatter and a1) then return end
local newtext = string.format(formatter,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10) local newtext = string.format(formatter,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)
@@ -176,74 +185,11 @@ pfUI:RegisterModule("chat", function ()
return text return text
end end
pfUI.chat.urlcopy = CreateFrame("Frame", "pfURLCopy", UIParent) -- clicking a url link copies it
pfUI.chat.urlcopy:Hide() LinkUtil.RegisterLinkHandler("url", function(link, text, linkData)
pfUI.chat.urlcopy:SetWidth(270) CopyText(linkData.options)
pfUI.chat.urlcopy:SetHeight(65)
pfUI.chat.urlcopy:SetFrameStrata("FULLSCREEN")
pfUI.chat.urlcopy:SetPoint("CENTER", 0, 0)
CreateBackdrop(pfUI.chat.urlcopy, nil, nil, 0.8)
pfUI.chat.urlcopy:SetMovable(true)
pfUI.chat.urlcopy:EnableMouse(true)
pfUI.chat.urlcopy:RegisterForDrag("LeftButton")
pfUI.chat.urlcopy:SetScript("OnDragStart",function()
this:StartMoving()
end) end)
pfUI.chat.urlcopy:SetScript("OnDragStop",function()
this:StopMovingOrSizing()
end)
pfUI.chat.urlcopy:SetScript("OnShow", function()
this.text:HighlightText()
end)
pfUI.chat.urlcopy.text = CreateFrame("EditBox", "pfURLCopyEditBox", pfUI.chat.urlcopy)
pfUI.chat.urlcopy.text:SetTextColor(.2,1,.8,1)
pfUI.chat.urlcopy.text:SetJustifyH("CENTER")
pfUI.chat.urlcopy.text:SetWidth(250)
pfUI.chat.urlcopy.text:SetHeight(20)
pfUI.chat.urlcopy.text:SetPoint("TOP", pfUI.chat.urlcopy, "TOP", 0, -10)
pfUI.chat.urlcopy.text:SetFontObject(GameFontNormal)
CreateBackdrop(pfUI.chat.urlcopy.text)
pfUI.chat.urlcopy.text:SetScript("OnEscapePressed", function(self)
pfUI.chat.urlcopy:Hide()
end)
pfUI.chat.urlcopy.text:SetScript("OnEditFocusLost", function(self)
pfUI.chat.urlcopy:Hide()
end)
pfUI.chat.urlcopy.close = CreateFrame("Button", "pfURLCopyClose", pfUI.chat.urlcopy, "UIPanelButtonTemplate")
pfUI.api.SkinButton(pfUI.chat.urlcopy.close)
pfUI.chat.urlcopy.close:SetWidth(70)
pfUI.chat.urlcopy.close:SetHeight(18)
pfUI.chat.urlcopy.close:SetPoint("BOTTOMRIGHT", pfUI.chat.urlcopy, "BOTTOMRIGHT", -10, 10)
pfUI.chat.urlcopy.close:SetText(T["Close"])
pfUI.chat.urlcopy.close:SetScript("OnClick", function()
pfUI.chat.urlcopy:Hide()
end)
pfUI.chat.urlcopy.SetItemRef = SetItemRef
pfUI.chat.urlcopy.CopyText = function(text)
pfUI.chat.urlcopy.text:SetText(text)
pfUI.chat.urlcopy:Show()
end
function _G.SetItemRef(link, text, button)
if (strsub(link, 1, 3) == "url") then
if string.len(link) > 4 and string.sub(link,1,4) == "url:" then
pfUI.chat.urlcopy.CopyText(string.sub(link,5, string.len(link)))
end
return
end
pfUI.chat.urlcopy.SetItemRef(link, text, button)
end
pfUI.chat.right = CreateFrame("Frame", "pfChatRight", UIParent) pfUI.chat.right = CreateFrame("Frame", "pfChatRight", UIParent)
pfUI.chat.right:SetFrameStrata("BACKGROUND") pfUI.chat.right:SetFrameStrata("BACKGROUND")
pfUI.chat.right:SetWidth(C.chat.right.width) pfUI.chat.right:SetWidth(C.chat.right.width)
@@ -251,19 +197,11 @@ pfUI:RegisterModule("chat", function ()
pfUI.chat.right:SetPoint("BOTTOMRIGHT", -2*default_border,2*default_border) pfUI.chat.right:SetPoint("BOTTOMRIGHT", -2*default_border,2*default_border)
pfUI.chat.right:SetScript("OnShow", function() pfUI.chat:RefreshChat() end) pfUI.chat.right:SetScript("OnShow", function() pfUI.chat:RefreshChat() end)
UpdateMovable(pfUI.chat.right) UpdateMovable(pfUI.chat.right)
CreateBackdrop(pfUI.chat.right, default_border, nil, .8) ApplyPanelColors(pfUI.chat.right)
if C.chat.global.frameshadow == "1" then if C.chat.global.frameshadow == "1" then
CreateBackdropShadow(pfUI.chat.right) CreateBackdropShadow(pfUI.chat.right)
end end
if C.chat.global.custombg == "1" then
local r, g, b, a = strsplit(",", C.chat.global.background)
pfUI.chat.right.backdrop:SetBackdropColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
local r, g, b, a = strsplit(",", C.chat.global.border)
pfUI.chat.right.backdrop:SetBackdropBorderColor(tonumber(r), tonumber(g), tonumber(b), tonumber(a))
end
pfUI.chat.right.panelTop = CreateFrame("Frame", "rightChatPanelTop", pfUI.chat.right) pfUI.chat.right.panelTop = CreateFrame("Frame", "rightChatPanelTop", pfUI.chat.right)
pfUI.chat.right.panelTop:ClearAllPoints() pfUI.chat.right.panelTop:ClearAllPoints()
pfUI.chat.right.panelTop:SetHeight(C.global.font_size+default_border*2) pfUI.chat.right.panelTop:SetHeight(C.global.font_size+default_border*2)
@@ -277,21 +215,75 @@ pfUI:RegisterModule("chat", function ()
pfUI.chat:RegisterEvent("UI_SCALE_CHANGED") pfUI.chat:RegisterEvent("UI_SCALE_CHANGED")
local function ChatOnMouseWheel() local function ChatOnMouseWheel()
if (arg1 > 0) then if not IsShiftKeyDown() then
if IsShiftKeyDown() then this:ScrollByAmount(arg1 * C.chat.global.scrollspeed)
this:ScrollToTop() elseif arg1 > 0 then
else -- stops with the oldest line on top, as the wheel does; ScrollToTop
for i=1, C.chat.global.scrollspeed do -- would leave it alone on the bottom line
this:ScrollUp() this:ScrollByAmount(this:GetMaxScrollRange())
end else
end this:ScrollToBottom()
elseif (arg1 < 0) then end
if IsShiftKeyDown() then end
this:ScrollToBottom()
else -- [ Chat Background Alpha ]
for i=1, C.chat.global.scrollspeed do -- Blizzard's per-window transparency slider drives FCF_SetWindowAlpha, which only
this:ScrollDown() -- touches the ChatFrame*Background textures that pfUI hides on docked frames. Mirror
end -- the window's stored alpha onto the visible pfUI backdrop so the native slider
-- controls it directly.
local function ApplyChatBackgroundAlpha(panel, frame)
if not (panel and panel.backdrop and frame) then return end
local _, _, _, _, _, alpha = GetChatWindowInfo(frame:GetID())
alpha = tonumber(alpha)
if not alpha then return end
local r, g, b = panel.backdrop:GetBackdropColor()
panel.backdrop:SetBackdropColor(r, g, b, alpha)
end
function pfUI.chat:RefreshBackgroundAlpha()
-- Custom colors own the alpha. C.chat.global.background carries its own alpha, is
-- set by profiles and is shared with the meter skins, so the native slider must not
-- overwrite it -- doing so reverted the configured opacity on every refresh. The
-- slider only drives the panel when the user hasn't opted into pfUI's chat colors.
if C.chat.global.custombg == "1" then return end
-- left panel follows the currently selected docked tab
local selected = SELECTED_CHAT_FRAME
if not (selected and selected:GetParent() == pfUI.chat.left) then
selected = ChatFrame1
end
ApplyChatBackgroundAlpha(pfUI.chat.left, selected)
if C.chat.right.enable == "1" then
ApplyChatBackgroundAlpha(pfUI.chat.right, ChatFrame3)
end
end
-- live config apply, resolved by the gui as U["chat"]. Lets the color pickers
-- take effect on the spot instead of waiting for a /reload.
function pfUI.chat:UpdateConfig()
ApplyPanelColors(pfUI.chat.left)
ApplyPanelColors(pfUI.chat.right)
pfUI.chat:RefreshBackgroundAlpha()
end
function pfUI.chat:MigrateBackgroundAlpha()
-- Runs once per character. The previous SetupPositions default stored a hard 0 window
-- alpha, which now renders the pfUI backdrop fully transparent. Restore the historical
-- 0.8 look for any pfUI-managed window still sitting at 0. Only existing installs that
-- already ran chat setup carry that legacy 0; fresh installs get 0.8 from SetupPositions.
if pfUI_init.chatbgalpha then return end
if not pfUI_init["chat_position"] then return end
pfUI_init.chatbgalpha = true
local frames = { ChatFrame1, ChatFrame2 }
if C.chat.right.enable == "1" then table.insert(frames, ChatFrame3) end
for _, frame in ipairs(frames) do
local _, _, _, _, _, alpha = GetChatWindowInfo(frame:GetID())
alpha = tonumber(alpha)
if alpha and alpha <= 0 then
FCF_SetWindowAlpha(frame, 0.8)
end end
end end
end end
@@ -313,7 +305,8 @@ pfUI:RegisterModule("chat", function ()
CreateBackdrop(LanguageMenu) CreateBackdrop(LanguageMenu)
CreateBackdrop(VoiceMacroMenu) CreateBackdrop(VoiceMacroMenu)
local combatlogpanel = (CombatLogQuickButtonFrame_Custom and CombatLogQuickButtonFrame_Custom:GetHeight() or 0) -- the combatlog module's quick button bar sits above the docked log
local combatlogpanel = (ChatFrame2.CombatLogQuickButtonFrame and ChatFrame2.CombatLogQuickButtonFrame:GetHeight() or 0)
for i=1, NUM_CHAT_WINDOWS do for i=1, NUM_CHAT_WINDOWS do
local frame = _G["ChatFrame"..i] local frame = _G["ChatFrame"..i]
@@ -326,7 +319,7 @@ pfUI:RegisterModule("chat", function ()
end end
end end
if combat > 5 then if frame.CombatLogQuickButtonFrame or combat > 5 then
frame.pfCombatLog = true frame.pfCombatLog = true
else else
frame.pfCombatLog = nil frame.pfCombatLog = nil
@@ -393,7 +386,7 @@ pfUI:RegisterModule("chat", function ()
-- hide textures -- hide textures
for j,v in ipairs({tab:GetRegions()}) do for j,v in ipairs({tab:GetRegions()}) do
if j==5 then v:SetTexture(0,0,0,0) end if j==5 then v:SetColorTexture(0,0,0,0) end
v:SetHeight(C.global.font_size+default_border*2) v:SetHeight(C.global.font_size+default_border*2)
end end
@@ -429,7 +422,7 @@ pfUI:RegisterModule("chat", function ()
_G["ChatFrame" .. i .. "TabFlash"].Show = function() return end _G["ChatFrame" .. i .. "TabFlash"].Show = function() return end
end end
local _, class = UnitClass("player") local class = UnitClassBase("player")
local classColor = PFUI_CLASS_COLORS[class] local classColor = PFUI_CLASS_COLORS[class]
_G["ChatFrame" .. i .. "TabText"]:SetTextColor((classColor.r + .3) * .5, (classColor.g + .3) * .5, (classColor.b + .3) * .5, 1) _G["ChatFrame" .. i .. "TabText"]:SetTextColor((classColor.r + .3) * .5, (classColor.g + .3) * .5, (classColor.b + .3) * .5, 1)
_G["ChatFrame" .. i .. "TabText"]:SetFont(panelfont,panelfont_size, "OUTLINE") _G["ChatFrame" .. i .. "TabText"]:SetFont(panelfont,panelfont_size, "OUTLINE")
@@ -447,9 +440,13 @@ pfUI:RegisterModule("chat", function ()
for index, value in pairs(DOCKED_CHAT_FRAMES) do for index, value in pairs(DOCKED_CHAT_FRAMES) do
FCF_UpdateButtonSide(value) FCF_UpdateButtonSide(value)
end end
pfUI.chat:RefreshBackgroundAlpha()
end end
hooksecurefunc("FCF_SaveDock", pfUI.chat.RefreshChat) hooksecurefunc("FCF_SaveDock", pfUI.chat.RefreshChat)
hooksecurefunc("FCF_SetWindowAlpha", function() pfUI.chat:RefreshBackgroundAlpha() end)
hooksecurefunc("FCF_SelectDockFrame", function() pfUI.chat:RefreshBackgroundAlpha() end)
if C.chat.global.tabmouse == "1" then if C.chat.global.tabmouse == "1" then
pfUI.chat.mouseovertab = CreateFrame("Frame") pfUI.chat.mouseovertab = CreateFrame("Frame")
@@ -459,10 +456,10 @@ pfUI:RegisterModule("chat", function ()
if pfUI.chat.hideLock then return end if pfUI.chat.hideLock then return end
if MouseIsOver(pfUI.chat.left, 10, -10, -10, 10) then if pfUI.chat.left:IsMouseOver(10, -10, -10, 10) then
pfUI.chat.left.panelTop:Show() pfUI.chat.left.panelTop:Show()
FCF_DockUpdate() FCF_DockUpdate()
elseif MouseIsOver(pfUI.chat.right, 10, -10, -10, 10) then elseif pfUI.chat.right:IsMouseOver(10, -10, -10, 10) then
-- disable while dock is active -- disable while dock is active
if pfUI.chat.right:GetAlpha() == 0 then return end if pfUI.chat.right:GetAlpha() == 0 then return end
@@ -500,7 +497,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame1, 1) FCF_SetLocked(ChatFrame1, 1)
FCF_SetWindowName(ChatFrame1, GENERAL) FCF_SetWindowName(ChatFrame1, GENERAL)
FCF_SetWindowColor(ChatFrame1, 0, 0, 0) FCF_SetWindowColor(ChatFrame1, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame1, 0) FCF_SetWindowAlpha(ChatFrame1, 0.8)
FCF_SetChatWindowFontSize(ChatFrame1, 12) FCF_SetChatWindowFontSize(ChatFrame1, 12)
ChatFrame1:SetUserPlaced(1) ChatFrame1:SetUserPlaced(1)
@@ -508,7 +505,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame2, 1) FCF_SetLocked(ChatFrame2, 1)
FCF_SetWindowName(ChatFrame2, COMBAT_LOG) FCF_SetWindowName(ChatFrame2, COMBAT_LOG)
FCF_SetWindowColor(ChatFrame2, 0, 0, 0) FCF_SetWindowColor(ChatFrame2, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame2, 0) FCF_SetWindowAlpha(ChatFrame2, 0.8)
FCF_SetChatWindowFontSize(ChatFrame2, 12) FCF_SetChatWindowFontSize(ChatFrame2, 12)
ChatFrame2:SetUserPlaced(1) ChatFrame2:SetUserPlaced(1)
@@ -518,7 +515,7 @@ pfUI:RegisterModule("chat", function ()
FCF_SetLocked(ChatFrame3, 1) FCF_SetLocked(ChatFrame3, 1)
FCF_SetWindowName(ChatFrame3, T["Loot & Spam"]) FCF_SetWindowName(ChatFrame3, T["Loot & Spam"])
FCF_SetWindowColor(ChatFrame3, 0, 0, 0) FCF_SetWindowColor(ChatFrame3, 0, 0, 0)
FCF_SetWindowAlpha(ChatFrame3, 0) FCF_SetWindowAlpha(ChatFrame3, 0.8)
FCF_SetChatWindowFontSize(ChatFrame3, 12) FCF_SetChatWindowFontSize(ChatFrame3, 12)
FCF_UnDockFrame(ChatFrame3) FCF_UnDockFrame(ChatFrame3)
FCF_SetTabPosition(ChatFrame3, 0) FCF_SetTabPosition(ChatFrame3, 0)
@@ -566,6 +563,9 @@ pfUI:RegisterModule("chat", function ()
end end
pfUI.chat:SetScript("OnEvent", function() pfUI.chat:SetScript("OnEvent", function()
-- restore legacy chat windows stuck at 0 alpha before anything reads it
pfUI.chat:MigrateBackgroundAlpha()
-- set the default chat -- set the default chat
FCF_SelectDockFrame(SELECTED_CHAT_FRAME) FCF_SelectDockFrame(SELECTED_CHAT_FRAME)
@@ -675,7 +675,7 @@ pfUI:RegisterModule("chat", function ()
end end
-- read and parse whisper color settings -- read and parse whisper color settings
local cr, cg, cb, ca = strsplit(",", C.chat.global.whisper) local cr, cg, cb, ca = GetStringColor(C.chat.global.whisper)
cr, cg, cb = tonumber(cr), tonumber(cg), tonumber(cb) cr, cg, cb = tonumber(cr), tonumber(cg), tonumber(cb)
local wcol = rgbhex(cr, cg, cb) local wcol = rgbhex(cr, cg, cb)
@@ -706,36 +706,46 @@ pfUI:RegisterModule("chat", function ()
_G.CHAT_WHISPER_INFORM_GET = '[W]' .. default _G.CHAT_WHISPER_INFORM_GET = '[W]' .. default
end end
local r,g,b,a = strsplit(",", C.chat.text.timecolor) local r,g,b,a = GetStringColor(C.chat.text.timecolor)
local timecolorhex = rgbhex(r,g,b,a) local timecolorhex = rgbhex(r,g,b,a)
local r,g,b = strsplit(",", C.chat.text.unknowncolor) -- AddMessage puts the time between these at the start of each line
local unknowncolorhex = rgbhex(r,g,b) local timestampStart = timecolorhex .. tleft
local timestampEnd = tright .. "|r "
-- Suppress FriendsFrame's WHO_LIST_UPDATE handling for our DLL-issued -- [ StripTimestamp ]
-- name lookups so they don't pop the friends panel. User-issued /who -- Returns a chat line without the timestamp AddMessage put before it.
-- still works because IsWhoQueryPending only reports true for queries function pfUI.chat.StripTimestamp(text)
-- issued via C_FriendList.SendWhoQueryByName. if C.chat.text.time ~= "1" or text:sub(1, #timestampStart) ~= timestampStart then
local original_FriendsFrame_OnEvent = FriendsFrame_OnEvent return text
_G.FriendsFrame_OnEvent = function() end
if _G.event == "WHO_LIST_UPDATE" and C_FriendList.IsWhoQueryPending() then return end local _, last = text:find(timestampEnd, #timestampStart + 1, true)
return original_FriendsFrame_OnEvent() return last and text:sub(last + 1) or text
end end
local r,g,b = GetStringColor(C.chat.text.unknowncolor)
local unknowncolorhex = rgbhex(r,g,b)
local function GetPlayerLevel(name) local function GetPlayerLevel(name)
if not pfUI_playerDB then return nil end if not pfUI_playerDB then return nil end
if not pfUI_playerDB[name] then return nil end if not pfUI_playerDB[name] then return nil end
return pfUI_playerDB[name].level return pfUI_playerDB[name].level
end end
local function AddMessage(frame, text, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) -- Passes every argument after the text on: GetMessageInfo returns them all,
-- and a hook that drops some loses them for every frame after it.
local function AddMessage(frame, text, ...)
if not text then return end if not text then return end
-- skip chat parsing on combat log -- skip chat parsing on combat log
if frame.pfCombatLog then if frame.pfCombatLog then
return frame:HookAddMessage(text, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17) return frame:HookAddMessage(text, ...)
end end
-- payload of the CHAT_MSG event printing this line; nil for lines
-- that don't come from one (system text, addon output, history)
local event, _, sender, _, _, _, _, _, _, _, _, _, guid = GetCurrentChatEvent()
-- Remove prat CLINKs -- Remove prat CLINKs
text = gsub(text, "{CLINK:(%x+):([%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-):([^}]-)}", "|c%1|Hitem:%2|h[%3]|h|r") -- tbc text = gsub(text, "{CLINK:(%x+):([%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-:[%d-]-):([^}]-)}", "|c%1|Hitem:%2|h[%3]|h|r") -- tbc
text = gsub(text, "{CLINK:(%x+):([%d-]-:[%d-]-:[%d-]-:[%d-]-):([^}]-)}", "|c%1|Hitem:%2|h[%3]|h|r") -- vanilla text = gsub(text, "{CLINK:(%x+):([%d-]-:[%d-]-:[%d-]-:[%d-]-):([^}]-)}", "|c%1|Hitem:%2|h[%3]|h|r") -- vanilla
@@ -751,85 +761,89 @@ pfUI:RegisterModule("chat", function ()
text = pfUI.chat:HandleLink(text) text = pfUI.chat:HandleLink(text)
end end
-- display class colors if already indexed -- display class colors and player levels if already indexed
if C.chat.text.classcolor == "1" then local classcolor = C.chat.text.classcolor == "1"
for name in gfind(text, "|Hplayer:(.-)|h") do local playerlevel = C.chat.text.playerlevel == "1"
local real, _ = strsplit(":", name) if classcolor or playerlevel then
local color = unknowncolorhex -- the engine name-queries a chat sender before the event fires,
local match = false -- so the sender's GUID always resolves; other names in the text
local _, class = C_PlayerCache.GetPlayerInfoByName(real) -- fall back to the name-keyed lookups
-- local guid = GetCurrentChatGUID() local _, senderClass, senderRace, senderSex
-- if guid then if classcolor and guid and guid ~= "" then
-- _, class = GetPlayerInfoByGUID(guid) _, senderClass, _, senderRace, senderSex = GetPlayerInfoByGUID(guid)
-- end
if not class then
class = GetUnitInfo(real)
end
if class then
if class ~= UNKNOWN then
color = "|c" .. PFUI_CLASS_COLORS[class].colorStr
match = true
end
elseif C.chat.text.whosearchunknown == "1" then
C_FriendList.SendWhoQueryByName(name) -- cooldown + state managed by DLL
end
if C.chat.text.tintunknown == "1" or match then
text = string.gsub(text, "|Hplayer:"..name.."|h%["..real.."%]|h(.-:-)",
left..color.."|Hplayer:"..name.."|h" .. color .. real .. "|h|r"..right.."%1")
end
end end
end
-- display player levels if available
if C.chat.text.playerlevel == "1" then
for name in gfind(text, "|Hplayer:(.-)|h") do for name in gfind(text, "|Hplayer:(.-)|h") do
local real, _ = strsplit(":", name) local real, _ = strsplit(":", name)
local level = GetPlayerLevel(real) local color, icon = "", ""
if classcolor then
local class, raceKey, sex
if senderClass and real == sender then
class, raceKey, sex = senderClass, senderRace, senderSex
else
_, class, _, raceKey, sex = C_PlayerCache.GetPlayerInfoByName(real)
end
if not class then
class = GetUnitInfo(real)
end
if class and class ~= UNKNOWN then
color = "|c" .. PFUI_CLASS_COLORS[class].colorStr
if C.chat.text.factionicons == "1" then
icon = GetFactionIcon(raceKey)
end
if C.chat.text.raceicons == "1" then
icon = icon .. GetRaceIcon(raceKey, sex)
end
elseif C.chat.text.tintunknown == "1" then
color = unknowncolorhex
end
end
local suffix = ""
local level = playerlevel and GetPlayerLevel(real)
if level and level > 0 then if level and level > 0 then
local levelcolor = rgbhex(GetDifficultyColor(level)) suffix = " " .. rgbhex(GetDifficultyColor(level)) .. level .. "|r"
-- Add level after the player name, before the closing bracket elseif level then
text = string.gsub(text, "(|Hplayer:" .. name .. "|h.-|h|r)" .. right,
"%1 " .. levelcolor .. level .. "|r" .. right)
elseif level and level <= 0 then
-- Show ?? for unknown levels (e.g. -1 from UnitLevel) -- Show ?? for unknown levels (e.g. -1 from UnitLevel)
text = string.gsub(text, "(|Hplayer:" .. name .. "|h.-|h|r)" .. right, suffix = " |cffff0000??|r"
"%1 |cffff0000??|r" .. right) end
if color ~= "" or suffix ~= "" then
text = string.gsub(text, "|Hplayer:"..name.."|h%["..real.."%]|h(.-:-)",
left..icon..color.."|Hplayer:"..name.."|h" .. color .. real .. "|h|r"..suffix..right.."%1")
end end
end end
end end
-- reduce channel name to number -- reduce channel name to number
if C.chat.text.channelnumonly == "1" then if C.chat.text.channelnumonly == "1" and event == "CHAT_MSG_CHANNEL" then
local channel = string.gsub(text, ".*%[(.-)%]%s+(.*|Hplayer).+", "%1") text = string.gsub(text, "%[(%d+)%..-%] ", left .. "%1" .. right .. " ", 1)
if string.find(channel, "%d+%. ") then end
channel = string.gsub(channel, "(%d+)%..*", "channel%1")
channel = string.gsub(channel, "channel", "") -- detect the whisper prefix BEFORE prepending a timestamp; the timestamp
text = string.gsub(text, "%[%d+%..-%]%s+(.*|Hplayer)", left .. channel .. right .. " %1") -- pushes the whisper colour code off position 1 and the find below fails
end local isWhisper = C.chat.global.whispermod == "1" and string.find(text, wcol, 1) == 1
if isWhisper then
-- patch incoming whisper string to match the colors, before the
-- timestamp so it keeps the form StripTimestamp looks for
text = string.gsub(text, "|r", "|r" .. wcol)
end end
-- show timestamp in chat -- show timestamp in chat
if C.chat.text.time == "1" then if C.chat.text.time == "1" then
text = timecolorhex .. tleft .. date(C.chat.text.timeformat) .. tright .. "|r " .. text text = timestampStart .. date(C.chat.text.timeformat) .. timestampEnd .. text
end end
-- save chat history -- save chat history
if C.chat.global.whispermod == "1" and string.find(text, wcol, 1) == 1 then if isWhisper then
SaveChatHistory(frame:GetID(), string.gsub(text, wcol, ""), cr, cg, cb) SaveChatHistory(frame:GetID(), string.gsub(text, wcol, ""), cr, cg, cb)
else else
SaveChatHistory(frame:GetID(), text, a1, a2, a3) SaveChatHistory(frame:GetID(), text, ...)
end end
if C.chat.global.whispermod == "1" then frame:HookAddMessage(text, ...)
-- patch incoming whisper string to match the colors
if string.find(text, wcol, 1) == 1 then
text = string.gsub(text, "|r", "|r" .. wcol)
end
end
frame:HookAddMessage(text, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17)
end end
for i=1,NUM_CHAT_WINDOWS do for i=1,NUM_CHAT_WINDOWS do
@@ -839,12 +853,9 @@ pfUI:RegisterModule("chat", function ()
if not _G["ChatFrame"..i].HookAddMessage then if not _G["ChatFrame"..i].HookAddMessage then
if C.chat.text.history == "1" then if C.chat.text.history == "1" then
-- write history to chat -- write history to chat, newest first, above the lines already there
local history = GetChatHistory(i) for _, msg in ipairs(GetChatHistory(i)) do
for j=30,0,-1 do _G["ChatFrame"..i]:BackFillMessage(msg, .7,.7,.7)
if history[j] then
_G["ChatFrame"..i]:AddMessage(history[j], .7,.7,.7)
end
end end
end end
+50 -107
View File
@@ -1,5 +1,4 @@
pfUI:RegisterModule("chatcopy", function () pfUI:RegisterModule("chatcopy", function ()
local limit = 100
local f = CreateFrame("Frame") local f = CreateFrame("Frame")
f:RegisterEvent("PLAYER_ENTERING_WORLD") f:RegisterEvent("PLAYER_ENTERING_WORLD")
f:SetScript("OnEvent", function() f:SetScript("OnEvent", function()
@@ -15,26 +14,27 @@ pfUI:RegisterModule("chatcopy", function ()
button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Disabled") button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Disabled")
button.icon:SetAllPoints() button.icon:SetAllPoints()
-- show or hide the copy box of every chat frame
local function SetCopyMode(state)
button.state = state
for i=1, _G.NUM_CHAT_WINDOWS do
local scroll = _G["ChatFrame"..i].scroll
if scroll then
scroll:SetShown(state)
end
end
if state then
button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Up")
else
button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Disabled")
end
end
button:SetScript("OnClick", function() button:SetScript("OnClick", function()
if arg1 == "LeftButton" then if arg1 == "LeftButton" then
this.state = not this.state SetCopyMode(not this.state)
for i=1, _G.NUM_CHAT_WINDOWS do
local frame = _G["ChatFrame"..i]
local scroll = frame.scroll
if scroll and this.state then
scroll:Show()
elseif scroll then
scroll:Hide()
end
end
if this.state then
button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Up")
else
button.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Disabled")
end
elseif arg1 == "RightButton" then elseif arg1 == "RightButton" then
if ChatMenu:IsShown() then if ChatMenu:IsShown() then
ChatMenu:Hide() ChatMenu:Hide()
@@ -56,99 +56,42 @@ pfUI:RegisterModule("chatcopy", function ()
for i=1, _G.NUM_CHAT_WINDOWS do for i=1, _G.NUM_CHAT_WINDOWS do
local frame = _G["ChatFrame"..i] local frame = _G["ChatFrame"..i]
local name = frame:GetName()
local combat = 0 -- the chat frame's messages in an edit box to copy from
for i, msg in pairs(frame.messageTypeList) do local scroll = CreateFrame("Frame", "pfChatCopy" .. i, frame, "pfUIScrollingEditBoxTemplate")
if strfind(msg, "SPELL", 1) or strfind(msg, "COMBAT", 1) then scroll:SetAllPoints(frame)
combat = combat + 1 scroll.tex = scroll:CreateTexture(nil, "BACKGROUND")
scroll.tex:SetColorTexture(0,0,0,.95)
scroll.tex:SetPoint("TOPLEFT", -3, 3)
scroll.tex:SetPoint("BOTTOMRIGHT", 3, -3)
scroll:Hide()
scroll:RegisterCallback("OnEscapePressed", function()
SetCopyMode(false)
end, scroll)
scroll:HookScript("OnShow", function()
-- each line in its own color, which also replaces the |r resets inside it
local lines = {}
for index=1, frame:GetNumMessages() do
local text, r, g, b = frame:GetMessageInfo(index)
if C.chat.text.copytime == "0" then
text = pfUI.chat.StripTimestamp(text)
end
local color = rgbhex(r, g, b)
table.insert(lines, color .. text:gsub("|r", color))
end end
end local text = table.concat(lines, "\n")
if combat < 5 then scroll:SetFont(frame:GetFont())
-- initialize message cache scroll:SetText(text)
local history = {}
local AddMessage = frame.AddMessage
frame.AddMessage = function(self,msg,r,g,b)
if msg and r and g and b then
local col = rgbhex(r,g,b)
table.insert(history, 1, col..string.gsub(msg, "|r", col))
elseif msg then
table.insert(history, 1, "|cffffffff"..msg)
end
if history[limit] then -- the cursor at the end scrolls the box to the newest line
table.remove(history, limit) scroll:SetFocus()
end scroll:SetCursorPosition(#text)
AddMessage(self,msg,r,g,b) end)
end
-- read chat defaults frame.scroll = scroll
local font, size, flags = frame:GetFont()
-- build the frames
local scroll = CreateScrollFrame("ChatFrameScroll"..i, frame)
scroll:SetAllPoints(frame)
scroll.tex = scroll:CreateTexture(nil, "BACKGROUND")
scroll.tex:SetTexture(0,0,0,.95)
scroll.tex:SetPoint("TOPLEFT", -3, 3)
scroll.tex:SetPoint("BOTTOMRIGHT", 3, -3)
scroll:Hide()
local editbox = CreateFrame("EditBox", "pfChatCopyBox" .. i, scroll)
editbox:SetHeight(frame:GetHeight())
editbox:SetWidth(frame:GetWidth())
editbox:SetAllPoints(scroll)
editbox:SetTextColor(1,1,1,1)
editbox:SetFontObject(ChatFontNormal)
editbox:SetFont(font, size, flags)
editbox:SetAutoFocus(true)
editbox:SetMultiLine(true)
editbox:SetMaxLetters(0)
editbox:SetScript("OnMouseDown", function()
editbox.hasFocus = true
end)
editbox:SetScript("OnEscapePressed", function()
if editbox.hasFocus then
editbox:HighlightText(0, 0)
editbox:ClearFocus()
editbox.hasFocus = false
else
editbox:GetParent():Hide()
pfChatCopyButton.icon:SetTexture("Interface\\Buttons\\UI-GuildButton-PublicNote-Disabled")
pfChatCopyButton.state = false
end
end)
scroll:SetScrollChild(editbox)
scroll:SetScript("OnShow", function()
editbox:SetText("")
for i=limit,0,-1 do
if history[i] then
editbox:Insert("\n" .. history[i])
end
end
editbox:SetScript("OnUpdate", function()
if not this.count then this.count = 0 end
scroll:UpdateScrollChildRect()
scroll:SetVerticalScroll(scroll:GetVerticalScrollRange())
scroll:Scroll()
this.count = this.count + 1
-- the scroll frame takes a while to update
if this.count >= 3 then
this:SetScript("OnUpdate", nil)
this.count = 0
end
end)
end)
frame.scroll = scroll
end
end end
this:UnregisterAllEvents() this:UnregisterAllEvents()
File diff suppressed because it is too large Load Diff
File diff suppressed because it is too large Load Diff
+6 -6
View File
@@ -5,7 +5,7 @@ pfUI:RegisterModule("combopoints", function ()
ComboFrame:Hide() ComboFrame:Hide()
ComboFrame:UnregisterAllEvents() ComboFrame:UnregisterAllEvents()
local _, class = UnitClass("player") local class = UnitClassBase("player")
local combo_width = C["unitframes"]["combowidth"] local combo_width = C["unitframes"]["combowidth"]
local combo_height = C["unitframes"]["comboheight"] local combo_height = C["unitframes"]["comboheight"]
pfUI.combopoints = {} pfUI.combopoints = {}
@@ -23,15 +23,15 @@ pfUI:RegisterModule("combopoints", function ()
pfUI.combopoints[point]:SetPoint("CENTER", UIParent, "CENTER", (point - 3) * (combo_width + border*3), 10 ) pfUI.combopoints[point]:SetPoint("CENTER", UIParent, "CENTER", (point - 3) * (combo_width + border*3), 10 )
end end
pfUI.combopoints[point].tex = pfUI.combopoints[point]:CreateTexture("OVERLAY") pfUI.combopoints[point].tex = pfUI.combopoints[point]:CreateTexture(nil, "OVERLAY")
pfUI.combopoints[point].tex:SetAllPoints(pfUI.combopoints[point]) pfUI.combopoints[point].tex:SetAllPoints(pfUI.combopoints[point])
if point < 3 then if point < 3 then
pfUI.combopoints[point].tex:SetTexture(1, .3, .3, .75) pfUI.combopoints[point].tex:SetColorTexture(1, .3, .3, .75)
elseif point < 4 then elseif point < 4 then
pfUI.combopoints[point].tex:SetTexture(1, 1, .3, .75) pfUI.combopoints[point].tex:SetColorTexture(1, 1, .3, .75)
else else
pfUI.combopoints[point].tex:SetTexture(.3, 1, .3, .75) pfUI.combopoints[point].tex:SetColorTexture(.3, 1, .3, .75)
end end
UpdateMovable(pfUI.combopoints[point]) UpdateMovable(pfUI.combopoints[point])
@@ -52,7 +52,7 @@ pfUI:RegisterModule("combopoints", function ()
-- combo -- combo
if class == "DRUID" or class == "ROGUE" then if class == "DRUID" or class == "ROGUE" then
local combo = CreateFrame("Frame") local combo = CreateFrame("Frame")
combo:RegisterEvent("UNIT_COMBO_POINTS") combo:RegisterUnitEvent("UNIT_COMBO_POINTS", "player")
combo:RegisterEvent("PLAYER_COMBO_POINTS") combo:RegisterEvent("PLAYER_COMBO_POINTS")
combo:RegisterEvent("PLAYER_TARGET_CHANGED") combo:RegisterEvent("PLAYER_TARGET_CHANGED")
combo:RegisterEvent("PLAYER_ENTERING_WORLD") combo:RegisterEvent("PLAYER_ENTERING_WORLD")
-140
View File
@@ -1,140 +0,0 @@
pfUI:RegisterModule("cooldown", function ()
-- cache values
local lowcolor = {strsplit(",", C.appearance.cd.lowcolor)}
local normalcolor = {strsplit(",", C.appearance.cd.normalcolor)}
local minutecolor = {strsplit(",", C.appearance.cd.minutecolor)}
local hourcolor = {strsplit(",", C.appearance.cd.hourcolor)}
local daycolor = {strsplit(",", C.appearance.cd.daycolor)}
local parent, parent_name
local function pfCooldownOnUpdate()
parent = this:GetParent()
if not parent then this:Hide() end
parent_name = parent:GetName()
-- avoid to set cooldowns on invalid frames
if parent_name and _G[parent_name .. "Cooldown"] then
if not _G[parent_name .. "Cooldown"]:IsShown() then
this:Hide()
end
end
-- only run every 0.1 seconds from here on
if ( this.tick or .1) > GetTime() then return else this.tick = GetTime() + .1 end
-- fix own alpha value (should be inherited, but somehow isn't always)
if this:GetAlpha() ~= parent:GetAlpha() then
this:SetAlpha(parent:GetAlpha())
end
if this.start < GetTime() then
-- calculating remaining time as it should be
local remaining = this.duration - (GetTime() - this.start)
if remaining >= 0 then
this.text:SetText(GetColoredTimeString(remaining))
else
this:Hide()
end
else
-- I have absolutely no idea, but it works:
-- https://github.com/Stanzilla/WoWUIBugs/issues/47
local time = time()
local startupTime = time - GetTime()
-- just a simplification of: ((2^32) - (start * 1000)) / 1000
local cdTime = (2 ^ 32) / 1000 - this.start
local cdStartTime = startupTime - cdTime
local cdEndTime = cdStartTime + this.duration
local remaining = cdEndTime - time
if remaining >= 0 then
this.text:SetText(GetColoredTimeString(remaining))
else
this:Hide()
end
end
end
local height, size
local function pfCreateCoolDown(cooldown, start, duration)
cooldown.pfCooldownText = CreateFrame("Frame", "pfCooldownFrame", cooldown:GetParent())
cooldown.pfCooldownText:SetAllPoints(cooldown)
cooldown.pfCooldownText:SetFrameLevel(cooldown:GetParent():GetFrameLevel() + 2)
cooldown.pfCooldownText.text = cooldown.pfCooldownText:CreateFontString("pfCooldownFrameText", "OVERLAY")
if not cooldown.pfCooldownType then
size = tonumber(C.appearance.cd.font_size_foreign)
elseif cooldown.pfCooldownType == "BLIZZARD" then
size = tonumber(C.appearance.cd.font_size_blizz)
elseif cooldown.pfCooldownSize then
size = tonumber(cooldown.pfCooldownSize)
else
size = tonumber(C.appearance.cd.font_size)
end
-- enforce dynamic font size
if C.appearance.cd.dynamicsize == "1" and cooldown.GetParent then
height = cooldown:GetParent() and cooldown:GetParent():GetHeight() or cooldown:GetHeight() or 0
size = math.max((height > 0 and height * .64 or 16), size)
end
cooldown.pfCooldownText.text:SetFont(pfUI.media[C.appearance.cd.font], size, "OUTLINE")
cooldown.pfCooldownText.text:SetPoint("CENTER", cooldown.pfCooldownText, "CENTER", 0, 0)
cooldown.pfCooldownText:SetScript("OnUpdate", pfCooldownOnUpdate)
end
-- hook
local function SetCooldown(this, start, duration, enable)
-- abort on unknown frames
if C.appearance.cd.foreign == "0" and not this.pfCooldownType then
return
end
-- add support for omnicc's disable flag
if this.noCooldownCount then
return
end
-- realign cooldown frames
local parent = this.GetParent and this:GetParent()
if parent and parent:GetWidth() / 36 > 0 then
this:SetScale(parent:GetWidth() / 36)
this:SetPoint("TOPLEFT", parent, "TOPLEFT", -1, 1)
this:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", 1, -1)
end
-- don't draw global cooldowns
if this.pfCooldownType == "NOGCD" and duration < tonumber(C.appearance.cd.threshold) then
start, duration = 0, 0
end
-- disable GCDs on non pfUI frames
if not this.pfCooldownType and duration < tonumber(C.appearance.cd.threshold) then
start, duration = 0, 0
end
-- hide animation
if this.pfCooldownStyleAnimation == 0 then
this:SetAlpha(0)
elseif not this.pfCooldownStyleAnimation and C.appearance.cd.hideanim == "1" then
this:SetAlpha(0)
end
-- print time as text on cooldown frames
if ( not this.pfCooldownStyleText or this.pfCooldownStyleText == 1)
and start > 0 and duration > 0 and (not enable or enable > 0) then
if( not this.pfCooldownText ) then
pfCreateCoolDown(this, start, duration)
end
this.pfCooldownText.start = start
this.pfCooldownText.duration = duration
this.pfCooldownText:Show()
elseif(this.pfCooldownText) then
this.pfCooldownText:Hide()
end
end
-- vanilla does not have a cooldown frame type, so we hook the
-- regular SetTimer function that each one is calling.
hooksecurefunc("CooldownFrame_SetTimer", SetCooldown)
end)
+347 -87
View File
@@ -1,5 +1,252 @@
pfUI:RegisterModule("easteregg", function () pfUI:RegisterModule("easteregg", function ()
local today = date("%m%d") local today = date("%m%d")
-- A full screen scene for the time the player is AFK on a holiday. The
-- night fades in, and a click or coming back clears AFK and hides it.
local function CreateScene(name, greeting, info)
local scene = CreateFrame("Button", name, WorldFrame)
scene:SetFrameStrata("DIALOG")
scene:SetAllPoints()
scene:Hide()
scene.night = scene:CreateTexture(nil, "BACKGROUND")
scene.night:SetColorTexture(0,0,0,1)
scene.night:SetGradientAlpha("VERTICAL", 0,0,0,.5, 0,0,0,1)
scene.night:SetAllPoints()
scene.stext = scene:CreateFontString(nil, "ARTWORK", "GameFontWhite")
scene.stext:SetFont(STANDARD_TEXT_FONT, 14, "OUTLINE")
scene.stext:SetPoint("TOP", 0, -380)
scene.stext:SetText("|cff33ffccShagu|cffffffff wishes you a")
scene.text = scene:CreateFontString(nil, "ARTWORK", "GameFontWhite")
scene.text:SetFont(pfUI.media["font:BigNoodleTitling.ttf"], 38)
scene.text:SetPoint("TOP", 0, -400)
scene.text:SetText(greeting)
local exit = "|cff444444<Click> or '/afk' to exit"
scene.dtext = scene:CreateFontString(nil, "ARTWORK", "GameFontWhite")
scene.dtext:SetFont(STANDARD_TEXT_FONT, 14, "OUTLINE")
scene.dtext:SetPoint("TOP", 0, -430)
scene.dtext:SetText(info and info .. "\n\n" .. exit or exit)
-- Fade the night in by playing a fade-out backwards. The scene keeps an
-- alpha of 1, which comes back when the fade ends.
scene.dusk = scene:CreateAnimationGroup()
local fade = scene.dusk:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(.8)
scene:SetScript("OnShow", function()
this.dusk:Play(true)
end)
-- start over on the next AFK
scene:SetScript("OnHide", function()
this:StopAnimating()
end)
-- /afk toggles, so send it only while AFK is still set
scene:SetScript("OnClick", function()
if IsChatAFK() then SendChatMessage("", "AFK") end
this:Hide()
end)
scene:RegisterEvent("PLAYER_FLAGS_CHANGED")
scene:SetScript("OnEvent", function()
this:SetShown(UnitIsAFK('player'))
end)
return scene
end
-- happy valentine's day
if today == "0214" then
local valentine = CreateScene("pfValentine", "happy valentine's day!")
valentine.text:SetTextColor(1, .4, .6)
-- a rosy glow around the screen edges
local glow = CreateFrame("Frame", nil, valentine)
glow:SetAllPoints()
glow:SetBackdrop({ edgeFile = pfUI.media["img:glow"], edgeSize = 32 })
glow:SetBackdropBorderColor(1, .3, .5, 1)
-- A heart is a square turned onto its corner with a round lobe on each
-- upper edge. The client's minimap mask is a plain white disc, so it
-- tints into a lobe without a texture of our own. Smaller hearts are
-- farther away, so they are darker and rise slower.
local hearts = {}
for i = 1, 40 do
local width = math.random(10, 28)
local side = width / 1.7
local shade = .4 + width / 28 * .6
local r, g, b = shade, shade * math.random() * .4, shade * (.2 + math.random() * .3)
local heart = CreateFrame("Frame", nil, valentine)
heart:SetSize(width, width)
heart.width = width
local tip = heart:CreateTexture(nil, "ARTWORK")
tip:SetColorTexture(1, 1, 1)
tip:SetVertexColor(r, g, b)
tip:SetSize(side, side)
tip:SetPoint("CENTER", 0, -side * .07)
tip:SetRotation(math.pi / 4)
for _, x in ipairs({ -1, 1 }) do
local lobe = heart:CreateTexture(nil, "ARTWORK")
lobe:SetTexture("Textures\\MinimapMask")
lobe:SetVertexColor(r, g, b)
lobe:SetSize(side, side)
lobe:SetPoint("CENTER", x * side * .354, side * .28)
end
-- like the snow, but up from below the screen
heart.float = heart:CreateAnimationGroup()
heart.float:SetLooping("REPEAT")
heart.float:SetIgnoreFramerateThrottle(true)
heart.path = heart.float:CreateAnimation("Path")
heart.path:SetCurve("SMOOTH")
heart.points = {}
for point = 1, 6 do
heart.points[point] = heart.path:CreateControlPoint()
end
hearts[i] = heart
end
local function LetThemFloat()
local width, height = valentine:GetWidth(), valentine:GetHeight()
for _, heart in ipairs(hearts) do
local rise = height + heart.width
local duration = rise / (20 + heart.width * 2)
local sway = math.random(-30, 30)
heart:ClearAllPoints()
heart:SetPoint("TOP", valentine, "BOTTOMLEFT", math.random() * width, 0)
heart.path:SetDuration(duration)
heart.path:SetStartDelay(math.random() * duration)
for point, control in ipairs(heart.points) do
control:SetOffset(point % 2 == 1 and sway or -sway, rise * point / 6)
end
heart.float:Play()
end
end
-- Cupid hovers by the side, turned towards the middle
local cupid = CreateFrame("PlayerModel", nil, valentine)
cupid:SetSize(260, 260)
cupid:SetPoint("BOTTOMRIGHT", -60, 60)
cupid:SetScript("OnShow", function()
this:SetDisplayInfo(15990)
this:SetFacing(-.5)
end)
cupid:Hide()
valentine.dusk:SetScript("OnFinished", function()
LetThemFloat()
cupid:Show()
end)
valentine:HookScript("OnHide", function()
cupid:Hide()
end)
end
-- happy hallow's end
if today == "1031" then
local halloween = CreateScene("pfHallowsEnd", "happy hallow's end!")
halloween.text:SetTextColor(1, .5, 0)
-- Candlelight glows in from the screen edges. It flickers in uneven
-- steps of { duration, change } that end where they began, so the loop
-- never jumps.
local candle = CreateFrame("Frame", nil, halloween)
candle:SetAllPoints()
candle:SetBackdrop({ edgeFile = pfUI.media["img:glow"], edgeSize = 32 })
candle:SetBackdropBorderColor(1, .5, .1, 1)
candle.flicker = candle:CreateAnimationGroup()
candle.flicker:SetLooping("REPEAT")
local steps = {
{ .18, -.25 }, { .09, .1 }, { .22, -.2 }, { .14, .3 }, { .3, -.1 },
{ .11, -.15 }, { .2, .2 }, { .16, -.3 }, { .26, .25 }, { .12, .15 },
}
for order, step in ipairs(steps) do
local duration, change = unpack(step)
local fade = candle.flicker:CreateAnimation("Alpha")
fade:SetOrder(order)
fade:SetDuration(duration)
fade:SetChange(change)
fade:SetSmoothing("IN_OUT")
end
-- Once the night has fallen, undead rise along the bottom one after
-- another, a different few on every AFK. They are creature displays, so
-- they need no creature cache. A model frame aims its camera at the
-- middle of the model's bounds, so the frame size alone sets how big one
-- is. Bounds that reach far above the body, like the lich's, leave it
-- standing too low, so it is left out.
local undead = {
158, -- skeleton
201, -- green skeleton
1245, -- skeleton mage
137, -- ghoul
18114, -- white-handed ghoul
1200, -- zombie
1201, -- green zombie
1202, -- sea-green zombie
915, -- banshee
10690, -- green banshee
146, -- ghost
4629, -- shade
7533, -- gargoyle
7534, -- black gargoyle
7854, -- blue gargoyle
}
local function Rise()
this:SetDisplayInfo(this.display)
this:SetFacing(this.facing)
end
local risen = {}
local rising = halloween:CreateAnimationGroup()
for i = 1, 7 do
local size = math.random(180, 240)
local model = CreateFrame("PlayerModel", nil, halloween)
model:SetSize(size, size)
model:SetPoint("BOTTOM", halloween, "BOTTOM", (i - 4) * 150 + math.random(-20, 20), math.random(-10, 20))
model.facing = (math.random() - .5) * .8
model:SetScript("OnShow", Rise)
model:Hide()
risen[i] = model
local rise = rising:CreateAnimation()
rise:SetOrder(i)
rise:SetDuration(.3)
rise:SetScript("OnFinished", function() model:Show() end)
end
halloween.dusk:SetScript("OnFinished", function()
-- shuffle as many undead to the front as there are models
for i, model in ipairs(risen) do
local j = math.random(i, #undead)
undead[i], undead[j] = undead[j], undead[i]
model.display = undead[i]
end
candle.flicker:Play()
rising:Play()
end)
halloween:HookScript("OnHide", function()
for _, model in ipairs(risen) do
model:Hide()
end
end)
end
-- merry x-mas! -- merry x-mas!
if today == "1224" or today == "1225" then if today == "1224" or today == "1225" then
local title = (UnitFactionGroup("player") == "Horde") and PVP_RANK_18_0 or PVP_RANK_18_1 local title = (UnitFactionGroup("player") == "Horde") and PVP_RANK_18_0 or PVP_RANK_18_1
@@ -27,89 +274,116 @@ pfUI:RegisterModule("easteregg", function ()
_G.MARKED_AFK = "You are now |cff33ffcc" .. title .. "|r (AFK)." _G.MARKED_AFK = "You are now |cff33ffcc" .. title .. "|r (AFK)."
_G.MARKED_AFK_MESSAGE = "You are now |cff33ffcc" .. title .. "|r (AFK): %s" _G.MARKED_AFK_MESSAGE = "You are now |cff33ffcc" .. title .. "|r (AFK): %s"
_G.CLEARED_AFK = "You are no longer |cff33ffcc" .. title .. "|r (AFK).\n|cff33ffccShagu|cffffffff wishes you a merry christmas. Thanks for using |cff33ffccpf|cffffffffUI|cffffffff!|r" _G.CLEARED_AFK = "You are no longer |cff33ffcc" .. title .. "|r (AFK).\n|cff33ffccShagu|cffffffff wishes you a merry christmas. Thanks for using |cff33ffccpf|cffffffffUI|cffffffff!|r"
local snow = CreateScene("pfSnowfall", "merry christmas!")
snow.text:SetTextColor(1, .25, .25)
-- Flakes fall past the screen for good and sway on the way down. Before
-- each fall a flake waits above the screen for a while, which spreads
-- them out.
local flakes = {}
for i = 1, 200 do
local flake = snow:CreateTexture(nil, "OVERLAY")
flake.fall = flake:CreateAnimationGroup()
flake.fall:SetLooping("REPEAT")
flake.fall:SetIgnoreFramerateThrottle(true)
flake.path = flake.fall:CreateAnimation("Path")
flake.path:SetCurve("SMOOTH")
flake.points = {}
for point = 1, 6 do
flake.points[point] = flake.path:CreateControlPoint()
end
flakes[i] = flake
end
local function LetItSnow()
local width, height = snow:GetWidth(), snow:GetHeight()
for _, flake in ipairs(flakes) do
-- bigger flakes are closer, so they are brighter and fall faster
local size = math.random(2, 5)
local fall = height + size
local duration = fall / (40 + size * 20)
local sway = math.random(-20, 20)
flake:SetSize(size, size)
flake:SetColorTexture(1, 1, 1, .3 + size * .14)
flake:ClearAllPoints()
flake:SetPoint("BOTTOM", snow, "TOPLEFT", math.random() * width, 0)
flake.path:SetDuration(duration)
flake.path:SetStartDelay(math.random() * duration)
for point, control in ipairs(flake.points) do
control:SetOffset(point % 2 == 1 and sway or -sway, -fall * point / 6)
end
flake.fall:Play()
end
end
-- Snow piles up at the bottom for as long as the player stays AFK. The
-- drift plays a shrink backwards, so it grows to its full height over
-- ten minutes and keeps it once the group ends.
local pile = snow:CreateTexture(nil, "ARTWORK")
pile:SetPoint("BOTTOMLEFT", 0, 0)
pile:SetPoint("BOTTOMRIGHT", 0, 0)
pile:SetHeight(120)
pile:SetColorTexture(1, 1, 1, 1)
pile:SetGradientAlpha("VERTICAL", 1,1,1,.9, 1,1,1,0)
pile:Hide()
pile.grow = pile:CreateAnimationGroup()
local grow = pile.grow:CreateAnimation("Scale")
grow:SetOrigin("BOTTOM", 0, 0)
grow:SetScale(1, .01)
grow:SetDuration(600)
snow.dusk:SetScript("OnFinished", function()
LetItSnow()
pile:Show()
pile.grow:Play(true)
end)
snow:HookScript("OnHide", function()
pile:Hide()
end)
end end
-- happy new year -- happy new year
if today == "1231" or today == "0101" then if today == "1231" or today == "0101" then
local fireworks = CreateFrame("Button", "pfFireworks", WorldFrame) local fireworks = CreateScene("pfFireworks", "happy new year!",
fireworks:SetFrameStrata("DIALOG") "Another year with |cff33ffccpf|rUI has passed.\nThanks for continuing to use it!")
fireworks:SetAllPoints()
fireworks:Hide()
fireworks.night = fireworks:CreateTexture("LOW") -- Each explosion grows by 100px and fades out over 5/3s, then goes back
fireworks.night:SetTexture(0,0,0,1) -- to the pool.
fireworks.night:SetGradientAlpha("VERTICAL", 0,0,0,.5, 0,0,0,1) local explosions = CreateTexturePool(fireworks, "OVERLAY")
fireworks.night:SetAllPoints()
fireworks.stext = fireworks:CreateFontString("Status", "LOW", "GameFontWhite") local function Explode(x, y, size, r, g, b, a)
fireworks.stext:SetFont(STANDARD_TEXT_FONT, 14, "OUTLINE") local tex = explosions:Acquire()
fireworks.stext:SetPoint("TOP", 0, -380) if not tex.burst then
fireworks.stext:SetText("|cff33ffccShagu|cffffffff wishes you a") tex.burst = tex:CreateAnimationGroup()
tex.burst:SetIgnoreFramerateThrottle(true)
fireworks.text = fireworks:CreateFontString("Status", "LOW", "GameFontWhite") tex.burst.grow = tex.burst:CreateAnimation("Scale")
fireworks.text:SetFont(pfUI.media["font:BigNoodleTitling.ttf"], 38) tex.burst.grow:SetDuration(5/3)
fireworks.text:SetPoint("TOP", 0, -400) local fade = tex.burst:CreateAnimation("Alpha")
fireworks.text:SetText("happy new year!") fade:SetChange(-1)
fade:SetDuration(5/3)
fireworks.dtext = fireworks:CreateFontString("Status", "LOW", "GameFontWhite") tex.burst:SetScript("OnFinished", function() explosions:Release(tex) end)
fireworks.dtext:SetFont(STANDARD_TEXT_FONT, 14, "OUTLINE")
fireworks.dtext:SetPoint("TOP", 0, -430)
fireworks.dtext:SetText("Another year with |cff33ffccpf|rUI has passed.\nThanks for continuing to use it!\n\n|cff444444<Click> or '/afk' to exit")
fireworks:SetScript("OnClick", function()
this:Hide()
end)
-- trigger fireworks when being AFK
fireworks:RegisterEvent("PLAYER_FLAGS_CHANGED")
fireworks:SetScript("OnEvent", function()
local isAFK = UnitIsAFK('player')
if isAFK then
this:SetAlpha(0)
end end
this:SetShown(isAFK)
end)
-- basic explosion animation tex:SetPoint("CENTER", fireworks, "TOPLEFT", x, y)
local function animation() tex:SetSize(size, size)
local fps = (60 / math.max(GetFramerate(), 1)) tex:SetColorTexture(r, g, b, a)
this:SetWidth(this:GetWidth()+fps) tex.burst.grow:SetScale((size + 100) / size, (size + 100) / size)
this:SetHeight(this:GetHeight()+fps) tex:Show()
this:SetAlpha(this:GetAlpha()-fps*.01) tex.burst:Play()
if this:GetAlpha() <= 0 then
this.free = true
this:Hide()
end
end end
-- cache explosions to reuse frames fireworks:HookScript("OnHide", function()
local explosions = {} explosions:ReleaseAll()
local function GetExplosion() end)
for id, frame in pairs(explosions) do
if frame.free then
frame.free = nil
return frame
end
end
local frame = CreateFrame("Frame", nil, fireworks)
frame:SetScript("OnUpdate", animation)
frame.tex = frame:CreateTexture("HIGH")
frame.tex:SetAllPoints()
table.insert(explosions, frame)
return frame
end
-- create random amount of fireworks at random positions -- create random amount of fireworks at random positions
local width, height = GetScreenWidth(), GetScreenHeight()
fireworks:SetScript("OnUpdate", function() fireworks:SetScript("OnUpdate", function()
-- fade in the night if this.dusk:IsPlaying() then return end
if this:GetAlpha() < 1 then
this:SetAlpha(this:GetAlpha() + .02)
return
end
-- let the "happy new year" blink -- let the "happy new year" blink
local r,g,b = this.text:GetTextColor() local r,g,b = this.text:GetTextColor()
@@ -117,28 +391,14 @@ pfUI:RegisterModule("easteregg", function ()
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + math.random() - .2 end if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + math.random() - .2 end
local x,y = math.random(1, width), -1*math.random(1,height) local x,y = math.random(1, this:GetWidth()), -1*math.random(1, this:GetHeight())
-- create the base explosion -- create the base explosion
local f = GetExplosion() Explode(x, y, 25, 1, 1, 1, .5)
f:ClearAllPoints()
f:SetPoint("CENTER", fireworks, "TOPLEFT", x, y)
f:SetWidth(25)
f:SetHeight(25)
f.tex:SetTexture(1,1,1,.5)
f:SetAlpha(1)
f:Show()
-- create random amount of colored explosions -- create random amount of colored explosions
for i=1, math.random(20) do for i=1, math.random(20) do
local f = GetExplosion() Explode(x+(math.random(0,100)-50), y+(math.random(0,100)-50), 2, math.random(), math.random(), math.random(), 1)
f:ClearAllPoints()
f:SetPoint("CENTER", fireworks, "TOPLEFT", x+(math.random(0,100)-50), y+(math.random(0,100)-50))
f:SetWidth(2)
f:SetHeight(2)
f.tex:SetTexture(math.random(),math.random(),math.random(),1)
f:SetAlpha(1)
f:Show()
end end
end) end)
end end
+227 -63
View File
@@ -1,20 +1,82 @@
local function getAdjustedTickTimer() -- One server clock drives every power: Player::RegenerateAll fires every
local adjustedEnergyTick = 2 -- REGEN_TIME_FULL (2s), re-arms with `+=`, and is never reset by casting. The
-- five-second rule (SetLastManaUse on any mana-costing cast) changes what a tick
-- pays, never when it lands; mp5 and the player's MOD_MANA_REGEN_INTERRUPT share
-- still come in. That share can't be computed here -- item sources are equip
-- auras absent from the buff list and m_modManaRegenInterrupt is never sent --
-- so the spark shows it instead: dim through the window until a tick lands.
--
-- The sweep free-runs on that clock and phase-locks to observed gains. A gain
-- mid-sweep (Illumination, Judgement of Wisdom, potions, a Mana Spring totem on
-- its own phase) is not the tick and never moves it.
-- Check rogue talents and compute energy tick timing reduction for Combat spec (1.18.0 Blade Rush Talent) local FIVE_SECOND_RULE = 5
if UnitClass("player") == "Rogue" then
local _, _, _, _, currRank = GetTalentInfo(2, 16)
local bladeRushRank = currRank or 0
if bladeRushRank > 0 then -- gains farther than this from the predicted boundary are not the tick
local agility = UnitStat("player", 2) -- 2 is agility stat index local TICK_TOLERANCE = .25
local reductionPerAgi = 0.0006 * bladeRushRank -- 0.0006 for rank 1, 0.0012 for rank 2
local totalReduction = agility * reductionPerAgi -- arrival jitter; a tick inside this band confirms the sweep rather than
adjustedEnergyTick = adjustedEnergyTick - totalReduction -- re-anchoring it, or the spark hitches at every wrap
local TICK_JITTER = .08
-- Player::RegenerateAll:
-- mod = GetTotalAuraModifier(SPELL_AURA_MOD_ENERGY_REGEN_TIME)
-- if mod > 0 then mod = mod * agility / 10 end
-- m_regenTimer += max(1, REGEN_TIME_FULL - mod) -- milliseconds
local REGEN_TIME_FULL = 2
local ENERGY_REGEN_TIME_AURA = 217 -- SPELL_AURA_MOD_ENERGY_REGEN_TIME
-- fixed magnitude is basePoints + baseDice (stored 11 -> 12); a die above 1 is
-- a roll the client can't know, so it counts as nothing rather than a guess
local amountCache = {}
local function auraAmount(spellID)
local amount = amountCache[spellID]
if amount then return amount end
amount = 0
local effects = C_Spell.GetSpellEffectInfo(spellID) -- nil for an id with no record
if effects then
for i = 1, 3 do
local fx = effects[i]
if fx.auraName == ENERGY_REGEN_TIME_AURA and fx.dieSides <= 1 then
amount = fx.basePoints + fx.baseDice
break
end
end end
end end
amountCache[spellID] = amount
return amount
end
return adjustedEnergyTick -- A passive is in effect exactly while known (current rank only, never in the
-- buff list); anything castable or cast on us counts only while it is up.
local function getEnergyRegenTimeMod()
local sum = 0
for _, spellID in ipairs(C_SpellBook.GetPlayerSpellsByAura(ENERGY_REGEN_TIME_AURA)) do
if C_Spell.IsSpellPassive(spellID) then
sum = sum + auraAmount(spellID)
end
end
for i = 1, 32 do
local spellID = select(10, C_UnitAuras.UnitAura("player", i, "HELPFUL"))
if not spellID then break end
sum = sum + auraAmount(spellID)
end
return sum
end
-- cleared on SPELLS_CHANGED (passives) and PLAYER_AURAS_CHANGED (buffs), and
-- recomputed by the next tick that asks. Agility stays live: it's one call.
local energyRegenTimeMod
local function getAdjustedTickTimer()
if not energyRegenTimeMod then
energyRegenTimeMod = getEnergyRegenTimeMod()
end
if energyRegenTimeMod == 0 then return REGEN_TIME_FULL end
-- ms on the server, seconds here; the 1ms floor is the server's and this is a divisor
local reduction = energyRegenTimeMod * UnitStat("player", 2) / 10000
return math.max(0.001, REGEN_TIME_FULL - reduction)
end end
pfUI:RegisterModule("energytick", function() pfUI:RegisterModule("energytick", function()
@@ -22,64 +84,120 @@ pfUI:RegisterModule("energytick", function()
return return
end end
-- inside the module body on purpose: C is on pfUI.env, not _G
local function getBarWidth()
return C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width
end
local rawborder, default_border = GetBorderSize("unitframes")
local cbtexture = pfUI.media[C.appearance.castbar.texture]
-- style is read once: switching it in the GUI needs a /reload, same as the
-- other structural (not cosmetic) toggles in this file
local fsrOverlay = C.unitframes.player.fsrstyle == "1"
-- was this gain the regen tick? if so, re-anchor the sweep on it
local function lockTick(frame)
local now, period = GetTime(), getAdjustedTickTimer()
if frame.start then
-- signed distance to the nearest predicted boundary
local err = mod(now - frame.start, period)
if err > period / 2 then err = err - period end
if math.abs(err) <= TICK_TOLERANCE then
-- correct only what lies beyond normal jitter
if err > TICK_JITTER then
frame.start = frame.start + (err - TICK_JITTER)
elseif err < -TICK_JITTER then
frame.start = frame.start + (err + TICK_JITTER)
end
frame.max, frame.rejected = period, nil
return true
end
-- two rejected gains one period apart are the real clock: relock to it
local periodic = frame.rejected and math.abs(now - frame.rejected - period) <= TICK_TOLERANCE
if not periodic then
frame.rejected = now
return false
end
end
frame.start, frame.max, frame.rejected = now, period, nil
return true
end
local energytick = CreateFrame("Frame", nil, pfUI.uf.player.power.bar) local energytick = CreateFrame("Frame", nil, pfUI.uf.player.power.bar)
energytick:SetAllPoints(pfUI.uf.player.power.bar) energytick:SetAllPoints(pfUI.uf.player.power.bar)
energytick:RegisterEvent("PLAYER_ENTERING_WORLD") energytick:RegisterEvent("PLAYER_ENTERING_WORLD")
energytick:RegisterEvent("UNIT_DISPLAYPOWER") energytick:RegisterUnitEvent("UNIT_DISPLAYPOWER", "player")
energytick:RegisterEvent("UNIT_ENERGY") energytick:RegisterUnitEvent("UNIT_POWER_UPDATE", "player")
energytick:RegisterEvent("UNIT_MANA") energytick:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
energytick:RegisterEvent("CHAT_MSG_SPELL_SELF_BUFF") energytick:RegisterUnitEvent("UNIT_SPELLCAST_CHANNEL_STOP", "player")
energytick:RegisterEvent("CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS") energytick:RegisterEvent("SPELLS_CHANGED")
energytick:RegisterEvent("PLAYER_AURAS_CHANGED")
energytick:SetScript("OnEvent", function() energytick:SetScript("OnEvent", function()
if UnitPowerType("player") == 0 and C.unitframes.player.manatick == "1" then if UnitPowerType("player") == Enum.PowerType.Mana and C.unitframes.player.manatick == "1" then
this.mode = "MANA" this.mode = "MANA"
this:Show() this:Show()
elseif UnitPowerType("player") == 3 and C.unitframes.player.energy == "1" then elseif UnitPowerType("player") == Enum.PowerType.Energy and C.unitframes.player.energy == "1" then
this.mode = "ENERGY" this.mode = "ENERGY"
this:Show() this:Show()
else else
this.mode = nil
this:Hide() this:Hide()
end end
-- Filter nur eigene Energy-Gewinne von Talents/Buffs if event == "SPELLS_CHANGED" or event == "PLAYER_AURAS_CHANGED" then
if event == "CHAT_MSG_SPELL_SELF_BUFF" or event == "CHAT_MSG_SPELL_PERIODIC_SELF_BUFFS" then energyRegenTimeMod = nil
if string.find(arg1, "You gain") and string.find(arg1, "Energy from") then return
this.ignoreNextGain = true end
-- a shift swaps the power the gains are measured on
if event == "PLAYER_ENTERING_WORLD" or event == "UNIT_DISPLAYPOWER" then
this.lastPower = UnitPower("player")
end
-- the rule arms on the cast (Spell::TakePower: mana powerType, cost > 0),
-- not on a mana drop -- Mana Burn lowers mana without arming it
if event == "UNIT_SPELLCAST_SUCCEEDED" and arg1 == "player" then
local cost = C_Spell.GetSpellPowerCost(arg3)
cost = cost and cost[1]
if cost and cost.type == Enum.PowerType.Mana and cost.cost > 0 then
this.fsrSpell, this.fsrEnd = arg3, GetTime() + FIVE_SECOND_RULE
this.fsrGain = nil
end end
return return
end end
if event == "PLAYER_ENTERING_WORLD" then -- Unit::Update won't expire the rule while the spending spell still channels
this.lastMana = UnitMana("player") if event == "UNIT_SPELLCAST_CHANNEL_STOP" and arg1 == "player" then
if this.fsrSpell and this.fsrSpell == arg3 then
this.fsrEnd, this.fsrGain = GetTime() + FIVE_SECOND_RULE, nil
end
return
end end
if (event == "UNIT_MANA" or event == "UNIT_ENERGY") and arg1 == "player" then -- only the shown power: a cat druid's mana regen is not an energy gain
this.currentMana = UnitMana("player") if event == "UNIT_POWER_UPDATE" and arg2 == this.mode then
local diff = 0 local power = UnitPower("player")
if this.lastMana then local diff = this.lastPower and (power - this.lastPower) or 0
diff = this.currentMana - this.lastMana this.lastPower = power
-- only a gain can be the tick; a spend never touches the phase
if diff > 0 and lockTick(this) then
-- a tick inside the window proves regen continues through it
if this.fsrEnd and this.fsrEnd > GetTime() then
this.fsrGain = true
end
end end
if this.mode == "MANA" and diff < 0 then -- phase is kept while hidden; OnUpdate catches up by whole periods
this.target = 5 if this.mode == "MANA" and power >= UnitPowerMax("player") then
elseif this.mode == "MANA" and diff > 0 then this:Hide()
if UnitMana("player") >= UnitManaMax("player") then
this.start = nil
this.spark:SetAlpha(0)
this:Hide()
elseif this.max ~= 5 and diff > (this.badtick and this.badtick * 1.2 or 5) then
this.target = 2
else
this.badtick = diff
end
elseif this.mode == "ENERGY" and diff >= 0 then
if not this.ignoreNextGain then
this.target = getAdjustedTickTimer()
end
this.ignoreNextGain = false
end end
this.lastMana = this.currentMana
end end
end) end)
@@ -90,37 +208,79 @@ pfUI:RegisterModule("energytick", function()
end end
this.tick = GetTime() + 0.020 -- ~50 FPS this.tick = GetTime() + 0.020 -- ~50 FPS
if this.target then -- five-second rule drains to nothing. The display is cosmetic and can be
this.start, this.max = GetTime(), this.target -- hidden on its own; the window itself (fsrEnd/fsrGain) keeps running
this.target = nil -- either way -- it still dims the sweep spark below.
this.spark:SetAlpha(1) local remaining = this.fsrEnd and (this.fsrEnd - GetTime()) or 0
this:Show() if this.mode == "MANA" and remaining > 0 then
if C.unitframes.player.showfsr == "1" then
if fsrOverlay then
this.fsrbar:SetWidth(getBarWidth() * remaining / FIVE_SECOND_RULE)
else
this.fsrbar:SetValue(remaining)
end
this.fsrbar:Show()
else
this.fsrbar:Hide()
end
else
this.fsrSpell, this.fsrEnd, this.fsrGain = nil, nil, nil
this.fsrbar:Hide()
end end
if not this.start then if not this.start then
this.spark:SetAlpha(0)
return
end
if this.mode == "MANA" and UnitPower("player") >= UnitPowerMax("player") then
this.spark:SetAlpha(0)
return return
end end
this.current = GetTime() - this.start this.current = GetTime() - this.start
-- roll over by whole periods, not from now: restarting bakes frame
-- overshoot into the phase as drift the lock then has to chase
if this.current > this.max then if this.current > this.max then
-- Don't restart tick timer if mana is full this.start = this.start + this.max * math.floor(this.current / this.max)
if this.mode == "MANA" and UnitMana("player") >= UnitManaMax("player") then this.max = getAdjustedTickTimer()
this.start = nil this.current = GetTime() - this.start
this.spark:SetAlpha(0)
return
end
this.start, this.max, this.current = GetTime(), getAdjustedTickTimer(), 0
end end
local pos = (C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width) -- dim while the rule is up and nothing has ticked inside it yet
* (this.current / this.max) this.spark:SetAlpha((remaining > 0 and not this.fsrGain) and .4 or 1)
if not C.unitframes.player.pheight then if not C.unitframes.player.pheight then
return return
end end
local pos = getBarWidth() * (this.current / this.max)
this.spark:SetPoint("LEFT", pos - ((C.unitframes.player.pheight + 5) / 2), 0) this.spark:SetPoint("LEFT", pos - ((C.unitframes.player.pheight + 5) / 2), 0)
end) end)
if fsrOverlay then
-- classic style: a translucent shade on top of the power bar's own fill
energytick.fsrbar = energytick:CreateTexture(nil, "ARTWORK")
energytick.fsrbar:SetColorTexture(1, 1, 1, .15)
energytick.fsrbar:SetPoint("TOPLEFT", 0, 0)
energytick.fsrbar:SetPoint("BOTTOMLEFT", 0, 0)
else
-- a real bar below the power bar, not an overlay on top of it -- the same
-- treatment nameplate castbars get relative to the health bar, so the
-- window can't be mistaken for missing mana
energytick.fsrbar = CreateFrame("StatusBar", nil, pfUI.uf.player)
energytick.fsrbar:SetStatusBarTexture(cbtexture)
energytick.fsrbar:SetMinMaxValues(0, FIVE_SECOND_RULE)
energytick.fsrbar:SetPoint("TOPLEFT", pfUI.uf.player.power.bar, "BOTTOMLEFT", 0, -default_border * 2)
energytick.fsrbar:SetPoint("TOPRIGHT", pfUI.uf.player.power.bar, "BOTTOMRIGHT", 0, -default_border * 2)
energytick.fsrbar:SetHeight(tonumber(C.unitframes.player.fsrheight) or 4)
energytick.fsrbar:SetStatusBarColor(GetStringColor(C.appearance.castbar.fsrcolor))
CreateBackdrop(energytick.fsrbar, default_border)
CreateBackdropShadow(energytick.fsrbar)
end
energytick.fsrbar:Hide()
energytick.spark = energytick:CreateTexture(nil, "OVERLAY") energytick.spark = energytick:CreateTexture(nil, "OVERLAY")
energytick.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark") energytick.spark:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark")
energytick.spark:SetHeight(C.unitframes.player.pheight + 15) energytick.spark:SetHeight(C.unitframes.player.pheight + 15)
@@ -131,6 +291,10 @@ pfUI:RegisterModule("energytick", function()
function pfUI.uf.player.UpdateConfig() function pfUI.uf.player.UpdateConfig()
energytick.spark:SetHeight(C.unitframes.player.pheight + 15) energytick.spark:SetHeight(C.unitframes.player.pheight + 15)
energytick.spark:SetWidth(C.unitframes.player.pheight + 5) energytick.spark:SetWidth(C.unitframes.player.pheight + 5)
if not fsrOverlay then
energytick.fsrbar:SetHeight(tonumber(C.unitframes.player.fsrheight) or 4)
energytick.fsrbar:SetStatusBarColor(GetStringColor(C.appearance.castbar.fsrcolor))
end
hookUpdateConfig(pfUI.uf.player) hookUpdateConfig(pfUI.uf.player)
end end
end) end)
+54 -1
View File
@@ -86,6 +86,12 @@ pfUI:RegisterModule("eqcompare", function ()
end end
end end
local function HideCompareItem(self)
local shoppingTooltip1, shoppingTooltip2 = unpack(self.shoppingTooltips or { ShoppingTooltip1, ShoppingTooltip2 })
shoppingTooltip1:Hide()
shoppingTooltip2:Hide()
end
local prevMerchant = ShoppingTooltip1.SetMerchantCompareItem local prevMerchant = ShoppingTooltip1.SetMerchantCompareItem
local function SetMerchantCompareItem(self, index, compareItem) local function SetMerchantCompareItem(self, index, compareItem)
if compareItem == 1 then if compareItem == 1 then
@@ -130,9 +136,35 @@ pfUI:RegisterModule("eqcompare", function ()
SetTradeTargetItem = GetTradeTargetItemLink SetTradeTargetItem = GetTradeTargetItemLink
} }
-- Guda anchors its item tooltips with ANCHOR_NONE and its own SetPoint, and
-- the tooltip module then moves every ANCHOR_NONE tooltip to its configured
-- spot. Reading the rect inside the Set* call picks the side against the
-- position the tooltip is about to leave, so place the compare a frame later.
local deferred
HookAddon("Guda", function()
deferred = true
end)
-- the item each hooked tooltip shows, for MODIFIER_STATE_CHANGED. Every Set*
-- clears the tooltip before it builds, so OnTooltipCleared drops the link
-- of the previous content before the hook stores the new one.
local links = {}
local function forget()
links[this] = nil
end
local function makeHook(getter) local function makeHook(getter)
return function(tooltip, arg1, arg2, arg3) return function(tooltip, arg1, arg2, arg3)
ShowCompareItem(tooltip, getter(arg1, arg2, arg3)) local link = getter(arg1, arg2, arg3)
links[tooltip] = link
if not deferred then
return ShowCompareItem(tooltip, link)
end
RunNextFrame(function()
if tooltip:IsShown() then
ShowCompareItem(tooltip, link)
end
end)
end end
end end
@@ -140,8 +172,29 @@ pfUI:RegisterModule("eqcompare", function ()
for setter, getter in pairs(TooltipHooks) do for setter, getter in pairs(TooltipHooks) do
hooksecurefunc(tooltip, setter, makeHook(getter)) hooksecurefunc(tooltip, setter, makeHook(getter))
end end
tooltip:HookScript("OnTooltipCleared", forget)
tooltip:HookScript("OnHide", forget)
end end
-- pressing or releasing shift over an item toggles its comparison at once.
-- Merchant and auction comparisons show regardless of shift and never set
-- a link, so they stay up.
pfUI.events:RegisterFrameEventAndCallback("MODIFIER_STATE_CHANGED", function(_, key)
if key ~= "LSHIFT" and key ~= "RSHIFT" then return end
local shift = IsShiftKeyDown()
for tooltip, link in pairs(links) do
-- a hidden tooltip got its item from a scan, not a hover
if tooltip:IsShown() then
if shift then
ShowCompareItem(tooltip, link, shift)
elseif C.tooltip.compare.showalways ~= "1" or C_Item.IsEquippedItem(link) then
HideCompareItem(tooltip)
end
end
end
end)
HookTooltip(GameTooltip) HookTooltip(GameTooltip)
pfUI.eqcompare.HookTooltip = HookTooltip pfUI.eqcompare.HookTooltip = HookTooltip
+1423 -445
View File
File diff suppressed because it is too large Load Diff
+5 -8
View File
@@ -1,10 +1,6 @@
pfUI:RegisterModule("farmmode", function () pfUI:RegisterModule("farmmode", function ()
local function ToggleFarmMode() local function ToggleFarmMode()
if pfUI.farmmap:IsShown() then pfUI.farmmap:SetShown(not pfUI.farmmap:IsShown())
pfUI.farmmap:Hide()
else
pfUI.farmmap:Show()
end
end end
local function MoveNodes(layer) local function MoveNodes(layer)
@@ -41,8 +37,9 @@ pfUI:RegisterModule("farmmode", function ()
pfUI.farmmap:RegisterForDrag("LeftButton") pfUI.farmmap:RegisterForDrag("LeftButton")
pfUI.farmmap:SetScript("OnMouseWheel", function() pfUI.farmmap:SetScript("OnMouseWheel", function()
if IsControlKeyDown() then if IsControlKeyDown() then
this:SetWidth(this:GetWidth() + (arg1 > 0 and 10 or -10)) local adjust = (arg1 > 0 and 10 or -10)
this:SetHeight(this:GetHeight() + (arg1 > 0 and 10 or -10)) local width, height = this:GetSize()
this:SetSize(width + adjust, height + adjust)
Minimap_ZoomIn() Minimap_ZoomIn()
Minimap_ZoomOut() Minimap_ZoomOut()
elseif IsShiftKeyDown() then elseif IsShiftKeyDown() then
@@ -135,7 +132,7 @@ pfUI:RegisterModule("farmmode", function ()
pfUI.farmmap.button.txt = pfUI.farmmap.button:CreateFontString("pfFarmMapText", "LOW", "GameFontWhite") pfUI.farmmap.button.txt = pfUI.farmmap.button:CreateFontString("pfFarmMapText", "LOW", "GameFontWhite")
pfUI.farmmap.button.txt:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") pfUI.farmmap.button.txt:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
pfUI.farmmap.button.txt:SetPoint("CENTER", 0, 0) pfUI.farmmap.button.txt:SetPoint("CENTER", 0, 0)
pfUI.farmmap.button.txt:SetText("|cff33ffcc FARM MODE") pfUI.farmmap.button.txt:SetText("|cff33ffcc " .. T["FARM MODE"])
end end
CreateBackdrop(pfUI.farmmap) CreateBackdrop(pfUI.farmmap)
+2 -2
View File
@@ -1,6 +1,6 @@
pfUI:RegisterModule("feigndeath", function () pfUI:RegisterModule("feigndeath", function ()
local oldUnitHealth = UnitHealth local oldUnitHealth = _G.UnitHealth
function UnitHealth(unit) _G.UnitHealth = function(unit)
if UnitIsFeignDeath(unit) then if UnitIsFeignDeath(unit) then
local hp = GetUnitField(unit, "health") local hp = GetUnitField(unit, "health")
if hp and hp > 0 then return hp end if hp and hp > 0 then return hp end
+9 -14
View File
@@ -127,7 +127,7 @@ pfUI:RegisterModule("firstrun", function ()
-- welcome dialog -- welcome dialog
pfUI.firstrun:AddStep("init", function() pfUI.firstrun:AddStep("init", function()
local f = CreateFirstRunPage() local f = CreateFirstRunPage()
f.text:SetText(string.format(T["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."], GetAddOnMetadata(pfUI.name, "X-Website"))) f.text:SetFormattedText(T["Welcome to |cff33ffccpf|cffffffffUI|r!\n\nI'm the first run wizard that will guide you through some basic configuration. If you're lazy, feel free to hit the \"Defaults\" button. If you wish to run this dialog again, go to the settings and hit the \"Reset Firstrun\" button.\n\nVisit |cff33ffcc%s|r to check for the latest version."], GetAddOnMetadata(pfUI.name, "X-Website"))
return f return f
end) end)
@@ -137,8 +137,7 @@ pfUI:RegisterModule("firstrun", function ()
f.text:SetText(T["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."]) f.text:SetText(T["A new installation of |cff33ffccpf|rUI ships with 4 prebuilt design profiles. Click below if you wish to load one of these profiles."])
f.Modern = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Modern = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Modern:SetWidth(120) f.Modern:SetSize(120, 20)
f.Modern:SetHeight(20)
f.Modern:SetPoint("BOTTOM", -65, 100) f.Modern:SetPoint("BOTTOM", -65, 100)
f.Modern:SetTextColor(1,1,1) f.Modern:SetTextColor(1,1,1)
f.Modern:SetText("Modern") f.Modern:SetText("Modern")
@@ -151,8 +150,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Modern) SkinButton(f.Modern)
f.Nostalgia = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Nostalgia = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Nostalgia:SetWidth(120) f.Nostalgia:SetSize(120, 20)
f.Nostalgia:SetHeight(20)
f.Nostalgia:SetPoint("BOTTOM", 65, 100) f.Nostalgia:SetPoint("BOTTOM", 65, 100)
f.Nostalgia:SetTextColor(1,1,1) f.Nostalgia:SetTextColor(1,1,1)
f.Nostalgia:SetText("Nostalgia") f.Nostalgia:SetText("Nostalgia")
@@ -165,8 +163,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Nostalgia) SkinButton(f.Nostalgia)
f.Legacy = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Legacy = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Legacy:SetWidth(120) f.Legacy:SetSize(120, 20)
f.Legacy:SetHeight(20)
f.Legacy:SetPoint("BOTTOM", 65, 75) f.Legacy:SetPoint("BOTTOM", 65, 75)
f.Legacy:SetTextColor(1,1,1) f.Legacy:SetTextColor(1,1,1)
f.Legacy:SetText("Legacy") f.Legacy:SetText("Legacy")
@@ -179,8 +176,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinButton(f.Legacy) SkinButton(f.Legacy)
f.Slim = CreateFrame("Button", nil, f, "UIPanelButtonTemplate") f.Slim = CreateFrame("Button", nil, f, "UIPanelButtonTemplate")
f.Slim:SetWidth(120) f.Slim:SetSize(120, 20)
f.Slim:SetHeight(20)
f.Slim:SetPoint("BOTTOM", -65, 75) f.Slim:SetPoint("BOTTOM", -65, 75)
f.Slim:SetTextColor(1,1,1) f.Slim:SetTextColor(1,1,1)
f.Slim:SetText("Slim") f.Slim:SetText("Slim")
@@ -197,8 +193,7 @@ pfUI:RegisterModule("firstrun", function ()
f.Slider.text:SetPoint("TOP", f.Slider, "BOTTOM", 0, 2) f.Slider.text:SetPoint("TOP", f.Slider, "BOTTOM", 0, 2)
f.Slider.text:SetText(T["Scale"]) f.Slider.text:SetText(T["Scale"])
f.Slider:SetWidth(240) f.Slider:SetSize(240, 20)
f.Slider:SetHeight(20)
f.Slider:SetPoint("BOTTOM", 0, 50) f.Slider:SetPoint("BOTTOM", 0, 50)
f.Slider:SetOrientation('HORIZONTAL') f.Slider:SetOrientation('HORIZONTAL')
f.Slider:SetMinMaxValues(0.5, 2.0) f.Slider:SetMinMaxValues(0.5, 2.0)
@@ -263,7 +258,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
pfUI.chat.SetupRightChat(f.checkbox:GetChecked()) pfUI.chat.SetupRightChat(f.checkbox:GetChecked())
end end
@@ -283,7 +278,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
if f.checkbox:GetChecked() then if f.checkbox:GetChecked() then
pfUI.chat.SetupPositions() pfUI.chat.SetupPositions()
end end
@@ -305,7 +300,7 @@ pfUI:RegisterModule("firstrun", function ()
SkinCheckbox(f.checkbox, 18) SkinCheckbox(f.checkbox, 18)
f.NextScript = function() f.NextScript = function()
if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") end if not pfUI.chat then message("Couldn't apply settings. Chat module is disabled.") return end
if f.checkbox:GetChecked() then if f.checkbox:GetChecked() then
pfUI.chat.SetupChannels() pfUI.chat.SetupChannels()
end end
+14 -37
View File
@@ -2,63 +2,40 @@ pfUI:RegisterModule("focus", function ()
-- do not go further on disabled UFs -- do not go further on disabled UFs
if C.unitframes.disable == "1" then return end if C.unitframes.disable == "1" then return end
pfUI.uf.focus = pfUI.uf:CreateUnitFrame("Focus", nil, C.unitframes.focus, .2) pfUI.uf.focus = pfUI.uf:CreateUnitFrame("Focus", nil, C.unitframes.focus)
pfUI.uf.focus:UpdateFrameSize() pfUI.uf.focus:UpdateFrameSize()
pfUI.uf.focus:SetPoint("BOTTOMLEFT", UIParent, "BOTTOM", 220, 220) pfUI.uf.focus:SetPoint("BOTTOMLEFT", UIParent, "BOTTOM", 220, 220)
UpdateMovable(pfUI.uf.focus) UpdateMovable(pfUI.uf.focus)
pfUI.uf.focus:Hide() pfUI.uf.focus:Hide()
pfUI.uf.focustarget = pfUI.uf:CreateUnitFrame("FocusTarget", nil, C.unitframes.focustarget, .2) pfUI.uf.focustarget = pfUI.uf:CreateUnitFrame("FocusTarget", nil, C.unitframes.focustarget)
pfUI.uf.focustarget:UpdateFrameSize() pfUI.uf.focustarget:UpdateFrameSize()
pfUI.uf.focustarget:SetPoint("BOTTOMLEFT", pfUI.uf.focus, "TOP", 0, 10) pfUI.uf.focustarget:SetPoint("BOTTOMLEFT", pfUI.uf.focus, "TOP", 0, 10)
UpdateMovable(pfUI.uf.focustarget) UpdateMovable(pfUI.uf.focustarget)
pfUI.uf.focustarget:Hide() pfUI.uf.focustarget:Hide()
-- PLAYER_FOCUS_CHANGED drives immediate refresh on focus assign / clear. -- PLAYER_FOCUS_CHANGED drives immediate refresh on focus assign / clear.
-- The frame's 0.2s tick keeps health/power/aura data fresh between events. -- Between events, ClassicAPI fires UNIT_* (health/mana/aura/...) with
local refresher = CreateFrame("Frame") -- arg1 == "focus", so the bars update event-driven like target.
refresher:RegisterEvent("PLAYER_FOCUS_CHANGED") -- focustarget is a chained unit like targettarget: UNIT_TARGET follows the
refresher:SetScript("OnEvent", function() -- focus retargeting, and a new focus only needs its visibility re-checked,
pfUI.uf.focus.instantRefresh = true -- which queues the full refresh when its target is a different unit.
pfUI.events:RegisterFrameEventAndCallback("PLAYER_FOCUS_CHANGED", function()
pfUI.uf:RefreshUnit(pfUI.uf.focus, "all") pfUI.uf:RefreshUnit(pfUI.uf.focus, "all")
pfUI.uf.focustarget.instantRefresh = true pfUI.uf.focustarget:UpdateVisibility()
pfUI.uf:RefreshUnit(pfUI.uf.focustarget, "all")
end) end)
end) end)
-- /focus and /clearfocus live in ClassicAPI's SlashCommandsRegistry now. -- /focus and /clearfocus live in ClassicAPI's SlashCommandsRegistry now.
-- /focusname is pfUI-specific because the engine has no name→GUID -- `/focus Name` takes the nearest prefix match; /focusname tries the exact
-- lookup for off-screen units — we resolve via a short target-swap. -- name first, so "Bob" still wins over a nearer "Bobby".
pfUI.api.RegisterSlashCommand("PFFOCUSNAME", { '/focusname', '/pffocusname' }, function(msg) pfUI.api.RegisterSlashCommand("PFFOCUSNAME", { '/focusname', '/pffocusname' }, function(msg)
if msg == "" then return end if msg == "" then return end
local prevGUID = UnitGUID("target") local unit = UnitTokenFromName(msg, true) or UnitTokenFromName(msg)
local prevPlayer = UnitIsUnit("target", "player") if unit then
FocusUnit(unit)
-- Suppress async "Unknown unit" errors fired by TargetByName misses.
UIErrorsFrame:UnregisterEvent("UI_ERROR_MESSAGE")
-- Try exact match first, then prefix match via /target.
TargetByName(msg, true)
if not UnitExists("target") then
SlashCmdList.TARGET(msg)
end
if UnitExists("target") then
FocusUnit("target")
end
RunNextFrame(function()
UIErrorsFrame:RegisterEvent("UI_ERROR_MESSAGE")
end)
if prevGUID and prevGUID ~= "0x0000000000000000" then
TargetUnit(prevGUID)
elseif prevPlayer then
TargetUnit("player")
else
ClearTarget()
end end
end, true) end, true)
+93
View File
@@ -0,0 +1,93 @@
-- Friend notes
-- Client-side notes for friends via ClassicAPI's C_FriendList note API
-- (SetFriendNotes / GetFriendInfo(.notes)). Adds an "Edit Note" entry to the
-- friend right-click menu (the "FRIEND" UnitPopup) and shows the note in a
-- tooltip when you hover a friend in the list.
pfUI:RegisterModule("friendnotes", function ()
local EDIT_TOKEN = "PFUI_FRIEND_NOTE"
-- Note editor. In 1.12 StaticPopup, OnAccept runs with `this` = the OK
-- button (the dialog is this:GetParent()); the friend name arrives as the
-- data argument passed to StaticPopup_Show.
StaticPopupDialogs["PFUI_FRIEND_NOTE_EDIT"] = {
text = SET_FRIENDNOTE_LABEL,
button1 = SAVE,
button2 = CANCEL,
hasEditBox = 1,
maxLetters = 128,
OnAccept = function(name)
C_FriendList.SetFriendNotes(name, _G[this:GetParent():GetName().."EditBox"]:GetText())
end,
EditBoxOnEnterPressed = function(name)
C_FriendList.SetFriendNotes(name, this:GetText())
this:GetParent():Hide()
end,
EditBoxOnEscapePressed = function() this:GetParent():Hide() end,
timeout = 0, whileDead = 1, hideOnEscape = 1,
}
local function OpenNoteEditor(name)
if not name or name == "" then return end
local info = C_FriendList.GetFriendInfo(name)
local dialog = StaticPopup_Show("PFUI_FRIEND_NOTE_EDIT", name, nil, name)
if not dialog then return end
local editbox = _G[dialog:GetName().."EditBox"]
editbox:SetText((info and info.notes) or "")
editbox:HighlightText()
editbox:SetFocus()
end
-- Add "Edit Note" to the friend right-click menu, just before Cancel.
UnitPopupButtons[EDIT_TOKEN] = { text = SET_NOTE, dist = 0 }
local friendMenu = UnitPopupMenus["FRIEND"]
table.insert(friendMenu, table.getn(friendMenu), EDIT_TOKEN)
UnitPopupMenus["PFUI_FRIENDNOTE"] = { EDIT_TOKEN, "CANCEL" }
local function OfflineNoteDropDown_Initialize()
UnitPopup_ShowMenu(_G[UIDROPDOWNMENU_OPEN_MENU], "PFUI_FRIENDNOTE", nil, FriendsDropDown.name)
end
local FriendsFrame_ShowDropdown_orig = FriendsFrame_ShowDropdown
_G.FriendsFrame_ShowDropdown = function(name, connected)
if connected then return FriendsFrame_ShowDropdown_orig(name, connected) end
HideDropDownMenu(1)
FriendsDropDown.initialize = OfflineNoteDropDown_Initialize
FriendsDropDown.displayMode = "MENU"
FriendsDropDown.name = name
ToggleDropDownMenu(1, nil, FriendsDropDown, "cursor")
end
-- Route our entry to the editor and close the menu; delegate the rest. A
-- bare assignment lands on pfUI.env, so set the global explicitly.
local UnitPopup_OnClick_orig = UnitPopup_OnClick
_G.UnitPopup_OnClick = function()
if this and this.value == EDIT_TOKEN then
local dropdown = _G[UIDROPDOWNMENU_INIT_MENU]
local name = dropdown and dropdown.name
CloseDropDownMenus()
OpenNoteEditor(name)
return
end
return UnitPopup_OnClick_orig()
end
-- Show the note in a tooltip while hovering a friend in the list. Friend
-- buttons carry their friend index via SetID (see FriendsFrame_Update).
local function FriendButton_OnEnter()
local index = this:GetID()
if not index or index < 1 then return end
local info = C_FriendList.GetFriendInfoByIndex(index)
if not info or not info.notes or info.notes == "" then return end
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(info.name or "")
GameTooltip:AddLine(info.notes, 1, 1, 1, 1)
GameTooltip:Show()
end
for i = 1, FRIENDS_TO_DISPLAY do
local button = _G["FriendsFrameFriendButton"..i]
if button then
button:HookScript("OnEnter", FriendButton_OnEnter)
button:HookScript("OnLeave", GameTooltip_Hide)
end
end
end)
+1 -1
View File
@@ -456,7 +456,7 @@ pfUI:RegisterSkin("Friends", function ()
end end
-- all RaidFrame buttons are in Blizzard_RaidUI in Turtle WoW -- all RaidFrame buttons are in Blizzard_RaidUI in Turtle WoW
HookAddonOrVariable("Blizzard_RaidUI", function() HookAddon("Blizzard_RaidUI", function()
if RaidFrameRaidInfoButton then SkinButton(RaidFrameRaidInfoButton) end if RaidFrameRaidInfoButton then SkinButton(RaidFrameRaidInfoButton) end
if RaidFrameConvertToRaidButton then SkinButton(RaidFrameConvertToRaidButton) end if RaidFrameConvertToRaidButton then SkinButton(RaidFrameConvertToRaidButton) end
if RaidFrameReadyCheckButton then SkinButton(RaidFrameReadyCheckButton) end if RaidFrameReadyCheckButton then SkinButton(RaidFrameReadyCheckButton) end
+1 -1
View File
@@ -35,7 +35,7 @@ pfUI:RegisterModule("group", function ()
end end
if C.unitframes.grouptarget.visible == "1" and active then if C.unitframes.grouptarget.visible == "1" and active then
pfUI.uf.group[i].target = pfUI.uf.group[i].target or pfUI.uf:CreateUnitFrame("Party" .. i .. "Target", nil, C.unitframes.grouptarget, 0.2) pfUI.uf.group[i].target = pfUI.uf.group[i].target or pfUI.uf:CreateUnitFrame("Party" .. i .. "Target", nil, C.unitframes.grouptarget)
pfUI.uf.group[i].target:UpdateFrameSize() pfUI.uf.group[i].target:UpdateFrameSize()
pfUI.uf.group[i].target:SetPoint("TOPLEFT", pfUI.uf.group[i], "TOPRIGHT", 3*default_border, 0) pfUI.uf.group[i].target:SetPoint("TOPLEFT", pfUI.uf.group[i], "TOPRIGHT", 3*default_border, 0)
pfUI.uf.group[i].target:UpdateConfig() pfUI.uf.group[i].target:UpdateConfig()
+1 -5
View File
@@ -37,11 +37,7 @@ pfUI:RegisterModule("gryphons", function ()
frame.texture:SetTexCoord(1, 0, 0, 1) frame.texture:SetTexCoord(1, 0, 0, 1)
end end
if texture then frame:SetShown(texture)
frame:Show()
else
frame:Hide()
end
end end
end end
+274 -211
View File
@@ -1,5 +1,5 @@
pfUI:RegisterModule("gui", function () pfUI:RegisterModule("gui", function ()
local Reload, U, CreateConfig, CreateTabFrame, CreateArea, CreateGUIEntry, EntryUpdate local Reload, U, CreateConfig, CreateTabFrame, CreateArea, CreateGUIEntry, EntryOnEnter, EntryOnLeave
-- "searchDB" gets populated when CreateConfig is called. The table holds -- "searchDB" gets populated when CreateConfig is called. The table holds
-- information about the title, its parent buttons and the frame itself: -- information about the title, its parent buttons and the frame itself:
@@ -47,24 +47,12 @@ pfUI:RegisterModule("gui", function ()
end end
end}) end})
function EntryUpdate() function EntryOnEnter()
-- detect and skip during dropdowns this.tex:Show()
local focus = GetMouseFocus() end
if focus and focus.parent and focus.parent.menu then
if this.over then
this.tex:Hide()
this.over = nil
end
return
end
if MouseIsOver(this) and not this.over then function EntryOnLeave()
this.tex:Show() this.tex:Hide()
this.over = true
elseif not MouseIsOver(this) and this.over then
this.tex:Hide()
this.over = nil
end
end end
function CreateConfig(ufunc, caption, category, config, widget, values, skip, named, type) function CreateConfig(ufunc, caption, category, config, widget, values, skip, named, type)
@@ -115,9 +103,13 @@ pfUI:RegisterModule("gui", function ()
if not widget or (widget and widget ~= "button") then if not widget or (widget and widget ~= "button") then
if widget ~= "header" then if widget ~= "header" then
frame:SetScript("OnUpdate", EntryUpdate) -- light up while the cursor is over the row; its widgets pass
-- their mouse motion on to it below
frame:SetMouseMotionEnabled(true)
frame:SetScript("OnEnter", EntryOnEnter)
frame:SetScript("OnLeave", EntryOnLeave)
frame.tex = frame:CreateTexture(nil, "BACKGROUND") frame.tex = frame:CreateTexture(nil, "BACKGROUND")
frame.tex:SetTexture(1,1,1,.05) frame.tex:SetColorTexture(1,1,1,.05)
frame.tex:SetAllPoints() frame.tex:SetAllPoints()
frame.tex:Hide() frame.tex:Hide()
end end
@@ -182,14 +174,14 @@ pfUI:RegisterModule("gui", function ()
frame.color:SetHeight(12) frame.color:SetHeight(12)
CreateBackdrop(frame.color) CreateBackdrop(frame.color)
frame.color:SetPoint("RIGHT" , -5, 1) frame.color:SetPoint("RIGHT" , -5, 1)
frame.color.prev = frame.color.backdrop:CreateTexture("OVERLAY") frame.color.prev = frame.color.backdrop:CreateTexture(nil, "OVERLAY")
frame.color.prev:SetAllPoints(frame.color) frame.color.prev:SetAllPoints(frame.color)
local cr, cg, cb, ca = strsplit(",", category[config]) local cr, cg, cb, ca = strsplit(",", category[config])
if not cr or not cg or not cb or not ca then if not cr or not cg or not cb or not ca then
cr, cg, cb, ca = 1, 1, 1, 1 cr, cg, cb, ca = 1, 1, 1, 1
end end
frame.color.prev:SetTexture(cr,cg,cb,ca) frame.color.prev:SetColorTexture(cr,cg,cb,ca)
frame.color:SetScript("OnClick", function() frame.color:SetScript("OnClick", function()
local cr, cg, cb, ca = strsplit(",", category[config]) local cr, cg, cb, ca = strsplit(",", category[config])
@@ -207,7 +199,7 @@ pfUI:RegisterModule("gui", function ()
b = round(b, 3) b = round(b, 3)
a = round(a, 3) a = round(a, 3)
preview:SetTexture(r,g,b,a) preview:SetColorTexture(r,g,b,a)
if not this:GetParent():IsShown() then if not this:GetParent():IsShown() then
category[config] = r .. "," .. g .. "," .. b .. "," .. a category[config] = r .. "," .. g .. "," .. b .. "," .. a
@@ -217,7 +209,7 @@ pfUI:RegisterModule("gui", function ()
end end
function ColorPickerFrame.cancelFunc() function ColorPickerFrame.cancelFunc()
preview:SetTexture(cr,cg,cb,ca) preview:SetColorTexture(cr,cg,cb,ca)
end end
ColorPickerFrame.opacityFunc = ColorPickerFrame.func ColorPickerFrame.opacityFunc = ColorPickerFrame.func
@@ -343,45 +335,43 @@ pfUI:RegisterModule("gui", function ()
-- use dropdown widget -- use dropdown widget
if widget == "dropdown" and values then if widget == "dropdown" and values then
frame.input = CreateDropDownButton(nil, frame) local function IsSelected(value)
frame.input:SetBackdrop(nil) return category[config] == value
frame.input.menuframe:SetParent(pfUI.gui) end
local function SetSelected(value)
if category[config] ~= value then
category[config] = value
if ufunc then ufunc() else pfUI.gui.settingChanged = true end
pfUI.events:TriggerEvent("config:changed", category, config)
end
end
frame.input = CreateFrame("DropdownButton", nil, frame, "pfUIDropdownTemplate")
frame.input:SetPoint("RIGHT", frame, "RIGHT", 0, 0) frame.input:SetPoint("RIGHT", frame, "RIGHT", 0, 0)
frame.input:SetWidth(180) frame.input:SetWidth(180)
frame.input:SetMenu(function() frame.input:SetupMenu(function(dropdown, rootDescription)
local menu = {} for _, k in pairs(_G.type(values) == "function" and values() or values) do
for i, k in pairs(_G.type(values) == "function" and values() or values) do
local entry = {}
-- get human readable -- get human readable
local value, text = strsplit(":", k) local value, text = strsplit(":", k)
text = text or value rootDescription:CreateRadio(text or value, IsSelected, SetSelected, value)
entry.text = text
entry.func = function()
if category and category[config] ~= value then
category[config] = value
if ufunc then ufunc() else pfUI.gui.settingChanged = true end
pfUI.events:TriggerEvent("config:changed", category, config)
end
end
if category and category[config] == value then
frame.input.current = i
end
table.insert(menu, entry)
end end
return menu
end) end)
frame.input:SetSelection(frame.input.current)
end end
-- use list widget -- use list widget
if widget == "list" then if widget == "list" then
-- index of the selected entry among the "#" separated ones
local selected
local function IsSelected(index)
return index == selected
end
local function Select(index)
selected = index
end
frame.del = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate") frame.del = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
SkinButton(frame.del) SkinButton(frame.del)
frame.del:SetWidth(16) frame.del:SetWidth(16)
@@ -391,15 +381,16 @@ pfUI:RegisterModule("gui", function ()
frame.del:SetText("-") frame.del:SetText("-")
frame.del:SetTextColor(1,.5,.5,1) frame.del:SetTextColor(1,.5,.5,1)
frame.del:SetScript("OnClick", function() frame.del:SetScript("OnClick", function()
local sel = frame.input:GetSelection() if not selected then return end
local newconf = "" local newconf = ""
for id, val in pairs({strsplit("#", category[config])}) do for id, val in ipairs({strsplit("#", category[config])}) do
if id ~= sel then newconf = newconf .. "#" .. val end if id ~= selected and val ~= "" then newconf = newconf .. "#" .. val end
end end
selected = nil
category[config] = newconf category[config] = newconf
if ufunc then ufunc() else pfUI.gui.settingChanged = true end if ufunc then ufunc() else pfUI.gui.settingChanged = true end
pfUI.events:TriggerEvent("config:changed", category, config) pfUI.events:TriggerEvent("config:changed", category, config)
frame.input:UpdateMenu() frame.input:GenerateMenu()
end) end)
frame.add = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate") frame.add = CreateFrame("Button", nil, frame, "UIPanelButtonTemplate")
@@ -415,24 +406,26 @@ pfUI:RegisterModule("gui", function ()
category[config] = category[config] .. "#" .. this:GetParent().input:GetText() category[config] = category[config] .. "#" .. this:GetParent().input:GetText()
if ufunc then ufunc() else pfUI.gui.settingChanged = true end if ufunc then ufunc() else pfUI.gui.settingChanged = true end
pfUI.events:TriggerEvent("config:changed", category, config) pfUI.events:TriggerEvent("config:changed", category, config)
frame.input:UpdateMenu() frame.input:GenerateMenu()
end, false, true) end, false, true)
end) end)
frame.input = CreateDropDownButton(nil, frame) frame.input = CreateFrame("DropdownButton", nil, frame, "pfUIDropdownTemplate")
frame.input:SetBackdrop(nil)
frame.input.menuframe:SetParent(pfUI.gui)
frame.input:SetPoint("RIGHT", frame.add, "LEFT", -2, 0) frame.input:SetPoint("RIGHT", frame.add, "LEFT", -2, 0)
frame.input:SetWidth(140) frame.input:SetWidth(140)
frame.input:SetMenu(function() frame.input:SetupMenu(function(dropdown, rootDescription)
local menu = {} for id, val in ipairs({strsplit("#", category[config])}) do
for i, val in pairs({strsplit("#", category[config])}) do if val ~= "" then
table.insert(menu, { text = val }) rootDescription:CreateRadio(val, IsSelected, Select, id)
end
end end
return menu
end) end)
end end
for _, child in ipairs({ frame:GetChildren() }) do
child:SetPropagateMouseMotion(true)
end
return frame return frame
end end
@@ -497,31 +490,32 @@ pfUI:RegisterModule("gui", function ()
f.button = parent[title] f.button = parent[title]
f.bg = f:CreateTexture(nil, "BACKGROUND") f.bg = f:CreateTexture(nil, "BACKGROUND")
f.bg:SetTexture(1,1,1,.05) f.bg:SetColorTexture(1,1,1,.05)
f.bg:SetAllPoints() f.bg:SetAllPoints()
f:SetScript("OnShow", function() f:SetScript("OnShow", function()
this.indexed = true this.indexed = true
this.button.text:SetTextColor(.2,1,.8,1) this.button.text:SetTextColor(.2,1,.8,1)
this.button.bg:SetTexture(1,1,1,1) this.button.bg:SetColorTexture(1,1,1,1)
this.button.bg:SetGradientAlpha("HORIZONTAL", 0,0,0,0, 1,1,1,.05) this.button.bg:SetGradientAlpha("HORIZONTAL", 0,0,0,0, 1,1,1,.05)
end) end)
f:SetScript("OnHide", function() f:SetScript("OnHide", function()
this.button.text:SetTextColor(1,1,1,1) this.button.text:SetTextColor(1,1,1,1)
this.button.bg:SetTexture(0,0,0,0) this.button.bg:SetColorTexture(0,0,0,0)
end) end)
-- are we a frame with contents? -- are we a frame with contents?
if func then if func then
f.scroll = CreateScrollFrame(nil, f) f.scroll = CreateFrame("ScrollFrame", nil, f, "pfUIScrollFrameTemplate")
SetAllPointsOffset(f.scroll, f, 2) SetAllPointsOffset(f.scroll, f, 2)
f.scroll.content = CreateScrollChild(nil, f.scroll) f.scroll.content = f.scroll.Content
f.scroll.content.parent = f.scroll f.scroll.content.parent = f.scroll
f.scroll.content:SetScript("OnShow", function() f.scroll.content:SetScript("OnShow", function()
if not this.setup then if not this.setup then
func() func()
this.setup = true this.setup = true
this.parent:UpdateScrollChildRect()
end end
end) end)
end end
@@ -694,7 +688,10 @@ pfUI:RegisterModule("gui", function ()
SkinButton(pfUI.gui.share) SkinButton(pfUI.gui.share)
-- searchbar -- searchbar
local function SearchEntryClick() local results -- the result list, made with the search page on the first search
local highlighted -- the config row the last clicked result points at
local function SearchResultClick()
-- clear search focus -- clear search focus
pfUI.gui.search:ClearFocus() pfUI.gui.search:ClearFocus()
@@ -704,35 +701,44 @@ pfUI:RegisterModule("gui", function ()
end end
-- highlight matched entry -- highlight matched entry
if not this.obj[-1].highlight then if highlighted then highlighted.highlight:Hide() end
this.obj[-1].highlight = this.obj[-1]:CreateTexture(nil, "OVERLAY") highlighted = this.obj[-1]
this.obj[-1].highlight:SetAllPoints() if not highlighted.highlight then
this.obj[-1].highlight:SetTexture(.2,1,.8,.2) highlighted.highlight = highlighted:CreateTexture(nil, "OVERLAY")
highlighted.highlight:SetAllPoints()
highlighted.highlight:SetColorTexture(.2,1,.8,.2)
end end
this.obj[-1].highlight:Show() highlighted.highlight:Show()
end end
local function CreateSearchEntry(parent, i) local function InitSearchResult(f, obj)
local f = CreateFrame("Button", nil, parent) -- one-time setup of a pooled row
f:SetPoint("TOPLEFT", 5, -5 + (i-1)*-25) if not f.text then
f:SetWidth(565) f:SetScript("OnClick", SearchResultClick)
f:SetHeight(20) f:SetScript("OnEnter", EntryOnEnter)
f:SetScript("OnClick", SearchEntryClick) f:SetScript("OnLeave", EntryOnLeave)
f:SetScript("OnUpdate", EntryUpdate)
f.text = f:CreateFontString("Status", "LOW", "GameFontWhite") f.text = f:CreateFontString(nil, "LOW", "GameFontWhite")
f.text:SetFont(pfUI.font_default, pfUI_config.global.font_size, "OUTLINE") f.text:SetFont(pfUI.font_default, pfUI_config.global.font_size, "OUTLINE")
f.text:SetAllPoints() f.text:SetAllPoints()
f.text:SetJustifyH("LEFT") f.text:SetJustifyH("LEFT")
f.text:SetJustifyV("CENTER") f.text:SetJustifyV("CENTER")
f.text:SetTextColor(.5,.5,.5) f.text:SetTextColor(.5,.5,.5)
f.tex = f:CreateTexture(nil, "BACKGROUND") f.tex = f:CreateTexture(nil, "BACKGROUND")
f.tex:SetTexture(1,1,1,.05) f.tex:SetColorTexture(1,1,1,.05)
f.tex:SetAllPoints() f.tex:SetAllPoints()
f.tex:Hide() f.tex:Hide()
end
return f f.obj = obj
-- the path of submenus, then the entry
local caption = ""
for x=table.getn(obj),1,-1 do
caption = caption .. "|cff33ffcc" .. obj[x].text:GetText() .. "|r » "
end
f.text:SetText(caption .. "|cffffffff" .. obj[0])
end end
pfUI.gui.search = CreateFrame("EditBox", nil, pfUI.gui) pfUI.gui.search = CreateFrame("EditBox", nil, pfUI.gui)
@@ -759,54 +765,34 @@ pfUI:RegisterModule("gui", function ()
local defval = "["..T["Search"].."]" local defval = "["..T["Search"].."]"
-- initialize search window -- initialize search window
CreateGUIEntry(defval, nil, function() end) if not results then
CreateGUIEntry(defval)
results = CreateFrame("Frame", nil, pfUI.gui.frames[defval].area, "pfUIScrollBoxListTemplate")
SetAllPointsOffset(results, pfUI.gui.frames[defval].area, 2)
local view = CreateScrollBoxListLinearView(0, 0, 0, 0, 5)
view:SetElementExtent(20)
view:SetElementInitializer("Button", InitSearchResult)
ScrollUtil.InitScrollBoxListWithScrollBar(results.ScrollBox, results.ScrollBar, view)
end
pfUI.gui.frames[defval]:Click() pfUI.gui.frames[defval]:Click()
local scroll = pfUI.gui.frames[defval].area.scroll.content if highlighted then
local parent = pfUI.gui.frames[defval].area.scroll highlighted.highlight:Hide()
scroll.results = scroll.results or {} highlighted = nil
for i=1,table.getn(scroll.results) do
scroll.results[i]:Hide()
if scroll.results[i].obj and scroll.results[i].obj[-1].highlight then
scroll.results[i].obj[-1].highlight:Hide()
end
end end
if strlen(this:GetText()) < 1 then return end -- the matching entries, from the top of the list
local matches = {}
local i = 1
local search = strlower(this:GetText()) local search = strlower(this:GetText())
for name, obj in pairs(searchDB) do if search ~= "" then
local title = obj[0] and strlower(obj[0]) for _, obj in pairs(searchDB) do
if strfind(title, search) then if strfind(strlower(obj[0]), search, 1, true) then
-- build caption string table.insert(matches, obj)
local caption = ""
for x=table.getn(obj),1,-1 do
caption = caption .. "|cff33ffcc" .. obj[x].text:GetText() .. "|r » "
end end
caption = caption .. "|cffffffff" .. obj[0]
-- build search entry button
scroll.results[i] = scroll.results[i] or CreateSearchEntry(scroll, i)
scroll.results[i].obj = obj
scroll.results[i].text:SetText(caption)
scroll.results[i]:Show()
i = i + 1
end end
end end
results.ScrollBox:SetDataProvider(CreateDataProvider(matches))
-- reload scroll frames
scroll:Hide()
scroll:SetHeight(i * 25 )
scroll:Show()
parent:SetScrollChild(scroll)
QueueFunction(function()
parent:SetVerticalScroll(0)
parent:UpdateScrollState()
parent:Scroll()
end)
end) end)
pfUI.gui.search:SetScript("OnEditFocusGained", function(self) pfUI.gui.search:SetScript("OnEditFocusGained", function(self)
@@ -921,14 +907,6 @@ pfUI:RegisterModule("gui", function ()
"HORIZONTAL:" .. T["Horizontal"], "HORIZONTAL:" .. T["Horizontal"],
"VERTICAL:" .. T["Vertical"], "VERTICAL:" .. T["Vertical"],
}, },
["uf_animationspeed"] = {
"1:" .. T["Instant"],
"2:" .. T["Very Fast"],
"3:" .. T["Fast"],
"5:" .. T["Medium"],
"8:" .. T["Slow"],
"13:" .. T["Very Slow"],
},
["xpanchors"] = { ["xpanchors"] = {
"__NONONIL__:" .. T["No Anchor"], "__NONONIL__:" .. T["No Anchor"],
"pfChatLeft:" .. T["Left Chat Frame"], "pfChatLeft:" .. T["Left Chat Frame"],
@@ -961,7 +939,7 @@ pfUI:RegisterModule("gui", function ()
"16:" .. T["Very Slow"], "16:" .. T["Very Slow"],
}, },
["uf_rangecheck_mode"] = { ["uf_rangecheck_mode"] = {
"vanilla:" .. T["Vanilla (Spellbook)"], "vanilla:" .. T["ClassicAPI (UnitInRange)"],
"unitxp:" .. T["UnitXP (Precise)"], "unitxp:" .. T["UnitXP (Precise)"],
}, },
["uf_raidlayout"] = { ["uf_raidlayout"] = {
@@ -979,6 +957,12 @@ pfUI:RegisterModule("gui", function ()
"TOP:" .. T["Center"], "TOP:" .. T["Center"],
"TOPRIGHT:" .. T["Right"] "TOPRIGHT:" .. T["Right"]
}, },
["uf_portrait_style"] = {
"3d:" .. T["3D"],
"2d:" .. T["2D"],
"classround:" .. T["Class Icon (Round)"],
"classsquare:" .. T["Class Icon (Square)"]
},
["uf_portrait_position"] = { ["uf_portrait_position"] = {
"bar:" .. T["Healthbar Embedded"], "bar:" .. T["Healthbar Embedded"],
"left:" .. T["Left"], "left:" .. T["Left"],
@@ -1068,6 +1052,7 @@ pfUI:RegisterModule("gui", function ()
"unitrev:" .. T["Unit String (Reverse)"], "unitrev:" .. T["Unit String (Reverse)"],
"name:" .. T["Name"], "name:" .. T["Name"],
"nameshort:" .. T["Name (Short)"], "nameshort:" .. T["Name (Short)"],
"ownername:" .. T["Owner Name"],
"level:" .. T["Level"], "level:" .. T["Level"],
"class:" .. T["Class"], "class:" .. T["Class"],
"namehealth:" .. T["Name | Health Missing"], "namehealth:" .. T["Name | Health Missing"],
@@ -1298,7 +1283,7 @@ pfUI:RegisterModule("gui", function ()
-- draw pfUI logo -- draw pfUI logo
local function draw(p, fx, fy, tx, ty, r, g, b, a) local function draw(p, fx, fy, tx, ty, r, g, b, a)
local t = p:CreateTexture(nil, "OVERLAY") local t = p:CreateTexture(nil, "OVERLAY")
t:SetTexture(r,g,b,a) t:SetColorTexture(r,g,b,a)
t:SetPoint("TOPLEFT", fx, fy) t:SetPoint("TOPLEFT", fx, fy)
t:SetPoint("BOTTOMRIGHT", p, "TOPLEFT", tx, ty) t:SetPoint("BOTTOMRIGHT", p, "TOPLEFT", tx, ty)
end end
@@ -1325,14 +1310,14 @@ pfUI:RegisterModule("gui", function ()
this.version = this:CreateFontString("Status", "LOW", "GameFontWhite") this.version = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.version:SetFont(pfUI.font_default, C.global.font_size) this.version:SetFont(pfUI.font_default, C.global.font_size)
this.version:SetPoint("TOPRIGHT", 375, -170) this.version:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -170)
this.version:SetWidth(200) this.version:SetWidth(200)
this.version:SetJustifyH("RIGHT") this.version:SetJustifyH("RIGHT")
this.update = this:CreateFontString("Status", "LOW", "GameFontWhite") this.update = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.update:SetFont(pfUI.font_default, C.global.font_size) this.update:SetFont(pfUI.font_default, C.global.font_size)
this.update:SetPoint("TOPLEFT", 200, -140) this.update:SetPoint("TOPLEFT", 200, -140)
this.update:SetPoint("TOPRIGHT", 375, -140) this.update:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -140)
this.update:SetJustifyH("CENTER") this.update:SetJustifyH("CENTER")
this.update:SetTextColor(.2,1,.8) this.update:SetTextColor(.2,1,.8)
@@ -1345,7 +1330,7 @@ pfUI:RegisterModule("gui", function ()
this.screen = this:CreateFontString("Status", "LOW", "GameFontWhite") this.screen = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.screen:SetFont(pfUI.font_default, C.global.font_size) this.screen:SetFont(pfUI.font_default, C.global.font_size)
this.screen:SetPoint("TOPRIGHT", 375, -200) this.screen:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -200)
this.screen:SetWidth(200) this.screen:SetWidth(200)
this.screen:SetJustifyH("RIGHT") this.screen:SetJustifyH("RIGHT")
@@ -1358,7 +1343,7 @@ pfUI:RegisterModule("gui", function ()
this.scale = this:CreateFontString("Status", "LOW", "GameFontWhite") this.scale = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.scale:SetFont(pfUI.font_default, C.global.font_size) this.scale:SetFont(pfUI.font_default, C.global.font_size)
this.scale:SetPoint("TOPRIGHT", 375, -220) this.scale:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -220)
this.scale:SetWidth(200) this.scale:SetWidth(200)
this.scale:SetJustifyH("RIGHT") this.scale:SetJustifyH("RIGHT")
@@ -1371,7 +1356,7 @@ pfUI:RegisterModule("gui", function ()
this.client = this:CreateFontString("Status", "LOW", "GameFontWhite") this.client = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.client:SetFont(pfUI.font_default, C.global.font_size) this.client:SetFont(pfUI.font_default, C.global.font_size)
this.client:SetPoint("TOPRIGHT", 375, -250) this.client:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -250)
this.client:SetWidth(200) this.client:SetWidth(200)
this.client:SetJustifyH("RIGHT") this.client:SetJustifyH("RIGHT")
@@ -1383,7 +1368,7 @@ pfUI:RegisterModule("gui", function ()
this.langc:SetText(T["Language"] .. ":") this.langc:SetText(T["Language"] .. ":")
this.lang = this:CreateFontString("Status", "LOW", "GameFontWhite") this.lang = this:CreateFontString("Status", "LOW", "GameFontWhite")
this.lang:SetFont(pfUI.font_default, C.global.font_size) this.lang:SetFont(pfUI.font_default, C.global.font_size)
this.lang:SetPoint("TOPRIGHT", 375, -270) this.lang:SetPoint("TOPRIGHT", this, "TOPLEFT", 375, -270)
this.lang:SetWidth(200) this.lang:SetWidth(200)
this.lang:SetJustifyH("RIGHT") this.lang:SetJustifyH("RIGHT")
@@ -1412,7 +1397,7 @@ pfUI:RegisterModule("gui", function ()
donate:SetHeight(20) donate:SetHeight(20)
donate:SetText(T["Donate"]) donate:SetText(T["Donate"])
donate:SetScript("OnClick", function() donate:SetScript("OnClick", function()
pfUI.chat.urlcopy.CopyText("https://buymeacoffee.com/brues") CopyText("https://buymeacoffee.com/brues")
end) end)
SkinButton(donate) SkinButton(donate)
@@ -1422,7 +1407,7 @@ pfUI:RegisterModule("gui", function ()
github:SetHeight(20) github:SetHeight(20)
github:SetText(T["GitHub"]) github:SetText(T["GitHub"])
github:SetScript("OnClick", function() github:SetScript("OnClick", function()
pfUI.chat.urlcopy.CopyText(GetAddOnMetadata(pfUI.name, "X-Website")) CopyText(GetAddOnMetadata(pfUI.name, "X-Website"))
end) end)
SkinButton(github) SkinButton(github)
@@ -1432,7 +1417,7 @@ pfUI:RegisterModule("gui", function ()
website:SetHeight(20) website:SetHeight(20)
website:SetText(T["Website"]) website:SetText(T["Website"])
website:SetScript("OnClick", function() website:SetScript("OnClick", function()
pfUI.chat.urlcopy.CopyText(GetAddOnMetadata(pfUI.name, "X-Website")) CopyText(GetAddOnMetadata(pfUI.name, "X-Website"))
end) end)
SkinButton(website) SkinButton(website)
end) end)
@@ -1612,21 +1597,51 @@ pfUI:RegisterModule("gui", function ()
end) end)
CreateGUIEntry(T["Settings"], T["Cooldown"], function() CreateGUIEntry(T["Settings"], T["Cooldown"], function()
CreateConfig(U["buff"], T["Show Milliseconds When Timer Runs Out"], C.appearance.cd, "milliseconds", "checkbox") -- every kind of cooldown CreateCooldown makes, as C.cooldown groups.
CreateConfig(nil, T["Cooldown Color (Less than 3 Sec)"], C.appearance.cd, "lowcolor", "color") -- Other addons' cooldowns only lose numbers or sweep (see
CreateConfig(nil, T["Cooldown Color (Seconds)"], C.appearance.cd, "normalcolor", "color") -- api/cooldown.lua), so giving them back takes a reload
CreateConfig(nil, T["Cooldown Color (Minutes)"], C.appearance.cd, "minutecolor", "color") local kinds = {
CreateConfig(nil, T["Cooldown Color (Hours)"], C.appearance.cd, "hourcolor", "color") { "actionbar", T["Action Bars"] },
CreateConfig(nil, T["Cooldown Color (Days)"], C.appearance.cd, "daycolor", "color") { "bags", T["Bags"] },
CreateConfig(nil, T["Use Dynamic Font Size"], C.appearance.cd, "dynamicsize", "checkbox") { "blizzard", T["Spellbook And Character"] },
CreateConfig(nil, T["Cooldown Text Font"], C.appearance.cd, "font", "dropdown", pfUI.gui.dropdowns.fonts) { "unitframe", T["Unit Frame Auras"] },
CreateConfig(nil, T["Cooldown Text Font Size"], C.appearance.cd, "font_size") { "indicator", T["Buff Indicators"] },
CreateConfig(nil, T["Cooldown Text Font Size (Blizzard Frames)"], C.appearance.cd, "font_size_blizz") { "nameplate", T["Nameplate Debuffs"] },
CreateConfig(nil, T["Cooldown Text Font Size (Foreign Frames)"], C.appearance.cd, "font_size_foreign") { "buff", T["Player Buffs"] },
CreateConfig(nil, T["Cooldown Text Time Threshold"], C.appearance.cd, "threshold") { "tooltip", T["Tooltip Auras"] },
CreateConfig(nil, T["Enable Durations On Blizzard Frames"], C.appearance.cd, "blizzard", "checkbox") { "totem", T["Totems"] },
CreateConfig(nil, T["Enable Durations On Foreign Frames"], C.appearance.cd, "foreign", "checkbox") { "lossofcontrol", T["Loss Of Control"] },
CreateConfig(nil, T["Hide Foreign Cooldown Animations"], C.appearance.cd, "hideanim", "checkbox") { "foreign", T["Other Addons"] },
}
CreateConfig(nil, COUNTDOWN_FOR_COOLDOWNS_TEXT, "CVAR", "countdownForCooldowns", "checkbox")
CreateConfig(UpdateCooldowns, T["Font"], C.cooldown, "font", "dropdown", pfUI.gui.dropdowns.fonts)
CreateConfig(nil, T["Font Size"], C.cooldown, "font_size")
CreateConfig(nil, T["Scale Font Size With Icon"], C.cooldown, "dynamicsize", "checkbox")
CreateConfig(UpdateCooldowns, T["Hide Numbers On Spell Cooldowns Up To (Seconds)"], C.cooldown, "threshold")
CreateConfig(UpdateCooldowns, T["Show Tenths Below 5 Seconds"], C.cooldown, "milliseconds", "checkbox")
CreateConfig(UpdateCooldowns, T["Cooldown Color (5 Seconds Or Less)"], C.cooldown, "lowcolor", "color")
CreateConfig(UpdateCooldowns, T["Cooldown Color (Seconds)"], C.cooldown, "normalcolor", "color")
CreateConfig(UpdateCooldowns, T["Cooldown Color (Minutes)"], C.cooldown, "minutecolor", "color")
CreateConfig(UpdateCooldowns, T["Cooldown Color (Hours)"], C.cooldown, "hourcolor", "color")
CreateConfig(UpdateCooldowns, T["Cooldown Color (Days)"], C.cooldown, "daycolor", "color")
CreateConfig(nil, T["Show Numbers On"], nil, nil, "header")
for _, kind in ipairs(kinds) do
CreateConfig(kind[1] ~= "foreign" and UpdateCooldowns or nil, kind[2], C.cooldown[kind[1]], "text", "checkbox")
end
CreateConfig(nil, T["Show Sweep On"], nil, nil, "header")
for _, kind in ipairs(kinds) do
CreateConfig(kind[1] ~= "foreign" and UpdateCooldowns or nil, kind[2], C.cooldown[kind[1]], "animation", "checkbox")
end
CreateConfig(nil, T["Reverse Sweep On"], nil, nil, "header")
for _, kind in ipairs(kinds) do
if kind[1] ~= "foreign" then
CreateConfig(UpdateCooldowns, kind[2], C.cooldown[kind[1]], "reverse", "checkbox")
end
end
end) end)
CreateGUIEntry(T["Settings"], T["Screenshot"], function() CreateGUIEntry(T["Settings"], T["Screenshot"], function()
@@ -2063,17 +2078,14 @@ pfUI:RegisterModule("gui", function ()
CreateGUIEntry(T["Unit Frames"], T["General"], function() CreateGUIEntry(T["Unit Frames"], T["General"], function()
CreateConfig(nil, T["Disable pfUI Unit Frames"], C.unitframes, "disable", "checkbox") CreateConfig(nil, T["Disable pfUI Unit Frames"], C.unitframes, "disable", "checkbox")
CreateConfig(nil, T["Healthbar Animation Speed"], C.unitframes, "animation_speed", "dropdown", pfUI.gui.dropdowns.uf_animationspeed) CreateConfig(nil, T["Animate Health And Power Bars"], C.unitframes, "animatebars", "checkbox")
CreateConfig(nil, T["Portrait Alpha"], C.unitframes, "portraitalpha") CreateConfig(nil, T["Portrait Alpha"], C.unitframes, "portraitalpha")
CreateConfig(nil, T["Always Use 2D Portraits"], C.unitframes, "always2dportrait", "checkbox") CreateConfig(nil, T["Portrait Style"], C.unitframes, "portraitstyle", "dropdown", pfUI.gui.dropdowns.uf_portrait_style)
CreateConfig(nil, T["Enable 2D Portraits As Fallback"], C.unitframes, "portraittexture", "checkbox") CreateConfig(nil, T["Enable 2D Portraits As Fallback"], C.unitframes, "portraittexture", "checkbox")
CreateConfig(nil, T["Unit Frame Layout"], C.unitframes, "layout", "dropdown", pfUI.gui.dropdowns.uf_layout) CreateConfig(nil, T["Unit Frame Layout"], C.unitframes, "layout", "dropdown", pfUI.gui.dropdowns.uf_layout)
CreateConfig(nil, T["Combopoint Width"], C.unitframes, "combowidth") CreateConfig(nil, T["Combopoint Width"], C.unitframes, "combowidth")
CreateConfig(nil, T["Combopoint Height"], C.unitframes, "comboheight") CreateConfig(nil, T["Combopoint Height"], C.unitframes, "comboheight")
CreateConfig(nil, T["Show Resting"], C.unitframes.player, "showRest", "checkbox") CreateConfig(nil, T["Show Resting"], C.unitframes.player, "showRest", "checkbox")
CreateConfig(nil, T["Enable Energy Ticks"], C.unitframes.player, "energy", "checkbox")
CreateConfig(nil, T["Enable Mana Ticks"], C.unitframes.player, "manatick", "checkbox")
CreateConfig(nil, T["Detect Enemy Buffs"], C.unitframes, "buffdetect", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Raid Mark Icon Style"], C.unitframes, "blizzard_raidicons", "dropdown", function() return {"1:Original Blizzard", "0:pfUI Design"} end) CreateConfig(nil, T["Raid Mark Icon Style"], C.unitframes, "blizzard_raidicons", "dropdown", function() return {"1:Original Blizzard", "0:pfUI Design"} end)
CreateConfig(nil, T["Swing Timer"], nil, nil, "header") CreateConfig(nil, T["Swing Timer"], nil, nil, "header")
@@ -2089,6 +2101,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Offhand Bar Color"], C.unitframes, "swingtimerohcolor", "color") CreateConfig(nil, T["Offhand Bar Color"], C.unitframes, "swingtimerohcolor", "color")
CreateConfig(nil, T["Ranged Bar Color"], C.unitframes, "swingtimerrangedcolor", "color") CreateConfig(nil, T["Ranged Bar Color"], C.unitframes, "swingtimerrangedcolor", "color")
CreateConfig(nil, T["Ranged Warn Color (Hunter)"], C.unitframes, "swingtimerrangedwarncolor", "color") CreateConfig(nil, T["Ranged Warn Color (Hunter)"], C.unitframes, "swingtimerrangedwarncolor", "color")
CreateConfig(nil, T["Out Of Range Color"], C.unitframes, "swingtimeroutrangecolor", "color")
CreateConfig(nil, T["Show On Next Attack Queue Color"], C.unitframes, "swingtimerhsqueue", "checkbox") CreateConfig(nil, T["Show On Next Attack Queue Color"], C.unitframes, "swingtimerhsqueue", "checkbox")
CreateConfig(nil, T["Show Attack Speed"], C.unitframes, "swingtimerattackspeed", "checkbox") CreateConfig(nil, T["Show Attack Speed"], C.unitframes, "swingtimerattackspeed", "checkbox")
@@ -2119,9 +2132,9 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Enable 40y-Range Check"], C.unitframes, "rangecheck", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Enable 40y-Range Check"], C.unitframes, "rangecheck", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Range Check Mode"], C.unitframes, "rangecheck_mode", "dropdown", pfUI.gui.dropdowns.uf_rangecheck_mode, nil, nil, nil) CreateConfig(nil, T["Range Check Mode"], C.unitframes, "rangecheck_mode", "dropdown", pfUI.gui.dropdowns.uf_rangecheck_mode, nil, nil, nil)
CreateConfig(nil, T["UnitXP Range Threshold (yards)"], C.unitframes, "rangecheck_distance", nil, nil, nil, nil, nil) CreateConfig(nil, T["UnitXP Range Threshold (yards)"], C.unitframes, "rangecheck_distance", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Use Raid Frames To Display Group Members"], C.unitframes, "raidforgroup", "checkbox") CreateConfig(nil, T["Show Self In Raid Frames When Solo"], C.unitframes, "selfinraid", "checkbox")
CreateConfig(nil, T["Always Show Self In Raid Frames"], C.unitframes, "selfinraid", "checkbox")
CreateConfig(nil, T["Show Self In Group Frames"], C.unitframes, "selfingroup", "checkbox") CreateConfig(nil, T["Show Self In Group Frames"], C.unitframes, "selfingroup", "checkbox")
CreateConfig(nil, T["Use Raid Frames To Display Group Members"], C.unitframes, "raidforgroup", "checkbox")
CreateConfig(nil, T["Hide Group Frames While In Raid"], C.unitframes.group, "hide_in_raid", "checkbox") CreateConfig(nil, T["Hide Group Frames While In Raid"], C.unitframes.group, "hide_in_raid", "checkbox")
CreateConfig(nil, T["Max Amount Of Raid Frames"], C.unitframes, "maxraid", "dropdown", pfUI.gui.dropdowns.maxraid) CreateConfig(nil, T["Max Amount Of Raid Frames"], C.unitframes, "maxraid", "dropdown", pfUI.gui.dropdowns.maxraid)
@@ -2142,6 +2155,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Druid Settings"], nil, nil, "header") CreateConfig(nil, T["Druid Settings"], nil, nil, "header")
CreateConfig(nil, T["Show Druid Mana Bar"], C.unitframes, "druidmanabar", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Show Druid Mana Bar"], C.unitframes, "druidmanabar", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Show Druid Mana Bar Text"], C.unitframes, "druidmanatext", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar Height"], C.unitframes, "druidmanaheight", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar Height"], C.unitframes, "druidmanaheight", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar Width (-1 = auto)"], C.unitframes, "druidmanawidth", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar Width (-1 = auto)"], C.unitframes, "druidmanawidth", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Druid Mana Bar X-Offset"], C.unitframes, "druidmanaoffx", nil, nil, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar X-Offset"], C.unitframes, "druidmanaoffx", nil, nil, nil, nil, nil)
@@ -2150,6 +2164,10 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Druid Mana Bar Texture"], C.unitframes, "druidmanatexture", "dropdown", pfUI.gui.dropdowns.uf_bartexture, nil, nil, nil) CreateConfig(nil, T["Druid Mana Bar Texture"], C.unitframes, "druidmanatexture", "dropdown", pfUI.gui.dropdowns.uf_bartexture, nil, nil, nil)
CreateConfig(nil, T["Target Indicators"], nil, nil, "header")
CreateConfig(nil, T["Target Indicator Font Size"], C.unitframes, "indicator_font_size", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Show Line of Sight Indicator"], C.unitframes, "los_indicator", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["SuperWoW Settings"], nil, nil, "header") CreateConfig(nil, T["SuperWoW Settings"], nil, nil, "header")
CreateConfig(nil, T["Track Group on Minimap"], C.unitframes, "track_group", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Track Group on Minimap"], C.unitframes, "track_group", "checkbox", nil, nil, nil, nil)
@@ -2160,8 +2178,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Reactive Indicator Size"], C.unitframes, "reactive_size", nil, nil, nil, nil, nil) CreateConfig(nil, T["Reactive Indicator Size"], C.unitframes, "reactive_size", nil, nil, nil, nil, nil)
CreateConfig(nil, T["UnitXP Settings"], nil, nil, "header") CreateConfig(nil, T["UnitXP Settings"], nil, nil, "header")
CreateConfig(nil, T["Font Size for all UnitXP texts"], C.unitframes, "unitxp_font_size", nil, nil, nil, nil, nil)
CreateConfig(nil, T["Show Line of Sight Indicator"], C.unitframes, "los_indicator", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Show Behind Indicator"], C.unitframes, "behind_indicator", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Show Behind Indicator"], C.unitframes, "behind_indicator", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Show Distance of Target"], C.unitframes, "distance_indicator", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Show Distance of Target"], C.unitframes, "distance_indicator", "checkbox", nil, nil, nil, nil)
CreateConfig(nil, T["Hide yd characters"], C.unitframes, "hide_distance_yd", "checkbox", nil, nil, nil, nil) CreateConfig(nil, T["Hide yd characters"], C.unitframes, "hide_distance_yd", "checkbox", nil, nil, nil, nil)
@@ -2184,6 +2200,7 @@ pfUI:RegisterModule("gui", function ()
[10] = { "grouptarget", T["Group-Target"]}, [10] = { "grouptarget", T["Group-Target"]},
[11] = { "grouppet", T["Group-Pet"] }, [11] = { "grouppet", T["Group-Pet"] },
[12] = { "raid", T["Raid"] }, [12] = { "raid", T["Raid"] },
[13] = { "raidpet", T["Raid-Pet"] },
} }
CreateGUIEntry(T["Unit Frames"], T["Click Casting"], function() CreateGUIEntry(T["Unit Frames"], T["Click Casting"], function()
@@ -2233,10 +2250,10 @@ pfUI:RegisterModule("gui", function ()
U.ptarget = U["pettarget"] U.ptarget = U["pettarget"]
U.grouptarget = U["group"] U.grouptarget = U["group"]
U.grouppet = U["group"] U.grouppet = U["group"]
U.raidpet = U["raid"]
-- build config entries -- build config entries
CreateConfig(U[c], T["Display Frame"] .. ": " .. t, C.unitframes[c], "visible", "checkbox") CreateConfig(U[c], T["Display Frame"] .. ": " .. t, C.unitframes[c], "visible", "checkbox")
CreateConfig(U[c], T["Enable Mouseover Tooltip"], C.unitframes[c], "showtooltip", "checkbox")
CreateConfig(U[c], T["Default Transparency"], C.unitframes[c], "alpha_visible", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Default Transparency"], C.unitframes[c], "alpha_visible", "dropdown", pfUI.gui.dropdowns.percent_small)
CreateConfig(U[c], T["Out Of Range Transparency"], C.unitframes[c], "alpha_outrange", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Out Of Range Transparency"], C.unitframes[c], "alpha_outrange", "dropdown", pfUI.gui.dropdowns.percent_small)
CreateConfig(U[c], T["Offline Transparency"], C.unitframes[c], "alpha_offline", "dropdown", pfUI.gui.dropdowns.percent_small) CreateConfig(U[c], T["Offline Transparency"], C.unitframes[c], "alpha_offline", "dropdown", pfUI.gui.dropdowns.percent_small)
@@ -2277,6 +2294,13 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding") CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding")
CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout) CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout)
CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation) CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation)
CreateConfig(U["raid"], T["Collapse Empty Slots"], C.unitframes[c], "collapse", "checkbox")
elseif c == "raidpet" then
CreateConfig(U[c], T["Layout"], nil, nil, "header")
CreateConfig(U["raid"], T["Raid Padding"], C.unitframes[c], "raidpadding")
CreateConfig(U["raid"], T["Raid Layout"], C.unitframes[c], "raidlayout", "dropdown", pfUI.gui.dropdowns.uf_raidlayout)
CreateConfig(U["raid"], T["Raid Fill Direction"], C.unitframes[c], "raidfill", "dropdown", pfUI.gui.dropdowns.orientation)
CreateConfig(U["raid"], T["Collapse Empty Slots"], C.unitframes[c], "collapse", "checkbox")
end end
CreateConfig(U[c], T["Healthbar"], nil, nil, "header") CreateConfig(U[c], T["Healthbar"], nil, nil, "header")
@@ -2310,6 +2334,15 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U[c], T["Right Text Y Offset"], C.unitframes[c], "txtpowerrightoffy") CreateConfig(U[c], T["Right Text Y Offset"], C.unitframes[c], "txtpowerrightoffy")
CreateConfig(U[c], T["Power Bar Anchor"], C.unitframes[c], "panchor", "dropdown", pfUI.gui.dropdowns.uf_powerbar_position) CreateConfig(U[c], T["Power Bar Anchor"], C.unitframes[c], "panchor", "dropdown", pfUI.gui.dropdowns.uf_powerbar_position)
if c == "player" then
CreateConfig(nil, T["Energy/Mana Ticks"], nil, nil, "header")
CreateConfig(nil, T["Enable Energy Ticks"], C.unitframes[c], "energy", "checkbox")
CreateConfig(nil, T["Enable Mana Ticks"], C.unitframes[c], "manatick", "checkbox")
CreateConfig(nil, T["Show Five Second Rule"], C.unitframes[c], "showfsr", "checkbox")
CreateConfig(nil, T["Five Second Rule Style"], C.unitframes[c], "fsrstyle", "dropdown", function() return {"0:Separate Bar", "1:Overlay"} end)
CreateConfig(nil, T["Five Second Rule Height"], C.unitframes[c], "fsrheight")
end
CreateConfig(U[c], T["Combat Text"], nil, nil, "header") CreateConfig(U[c], T["Combat Text"], nil, nil, "header")
CreateConfig(U[c], T["Show Combat Text"], C.unitframes[c], "hitindicator", "checkbox") CreateConfig(U[c], T["Show Combat Text"], C.unitframes[c], "hitindicator", "checkbox")
CreateConfig(U[c], T["Combat Text Font"], C.unitframes[c], "hitindicatorfont", "dropdown", pfUI.gui.dropdowns.fonts) CreateConfig(U[c], T["Combat Text Font"], C.unitframes[c], "hitindicatorfont", "dropdown", pfUI.gui.dropdowns.fonts)
@@ -2321,21 +2354,23 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U[c], T["Automatic Level Text Color"], C.unitframes[c], "levelcolor", "checkbox") CreateConfig(U[c], T["Automatic Level Text Color"], C.unitframes[c], "levelcolor", "checkbox")
CreateConfig(U[c], T["Automatic Class Text Color"], C.unitframes[c], "classcolor", "checkbox") CreateConfig(U[c], T["Automatic Class Text Color"], C.unitframes[c], "classcolor", "checkbox")
CreateConfig(U[c], T["Timer"], nil, nil, "header")
CreateConfig(U[c], T["Show Timer Text"], C.unitframes[c], "cooldown_text", "checkbox")
CreateConfig(Reload, T["Show Timer Animation"], C.unitframes[c], "cooldown_anim", "checkbox")
CreateConfig(U[c], T["Buffs"], nil, nil, "header") CreateConfig(U[c], T["Buffs"], nil, nil, "header")
CreateConfig(U[c], T["Buff Position"], C.unitframes[c], "buffs", "dropdown", pfUI.gui.dropdowns.uf_buff_position) CreateConfig(U[c], T["Buff Position"], C.unitframes[c], "buffs", "dropdown", pfUI.gui.dropdowns.uf_buff_position)
CreateConfig(U[c], T["Buff Size"], C.unitframes[c], "buffsize") CreateConfig(U[c], T["Buff Size"], C.unitframes[c], "buffsize")
CreateConfig(U[c], T["Buff Limit"], C.unitframes[c], "bufflimit") CreateConfig(U[c], T["Buff Limit"], C.unitframes[c], "bufflimit")
CreateConfig(U[c], T["Buffs Per Row"], C.unitframes[c], "buffperrow") CreateConfig(U[c], T["Buffs Per Row"], C.unitframes[c], "buffperrow")
CreateConfig(U[c], T["Own Buff Size"], C.unitframes[c], "ownbuffsize")
CreateConfig(U[c], T["Buff X-Spacing"], C.unitframes[c], "buffspacingx")
CreateConfig(U[c], T["Buff Y-Spacing"], C.unitframes[c], "buffspacingy")
CreateConfig(U[c], T["Debuffs"], nil, nil, "header") CreateConfig(U[c], T["Debuffs"], nil, nil, "header")
CreateConfig(U[c], T["Debuff Position"], C.unitframes[c], "debuffs", "dropdown", pfUI.gui.dropdowns.uf_buff_position) CreateConfig(U[c], T["Debuff Position"], C.unitframes[c], "debuffs", "dropdown", pfUI.gui.dropdowns.uf_buff_position)
CreateConfig(U[c], T["Debuff Size"], C.unitframes[c], "debuffsize") CreateConfig(U[c], T["Debuff Size"], C.unitframes[c], "debuffsize")
CreateConfig(U[c], T["Debuff Limit"], C.unitframes[c], "debufflimit") CreateConfig(U[c], T["Debuff Limit"], C.unitframes[c], "debufflimit")
CreateConfig(U[c], T["Debuffs Per Row"], C.unitframes[c], "debuffperrow") CreateConfig(U[c], T["Debuffs Per Row"], C.unitframes[c], "debuffperrow")
CreateConfig(U[c], T["Own Debuff Size"], C.unitframes[c], "owndebuffsize")
CreateConfig(U[c], T["Debuff X-Spacing"], C.unitframes[c], "debuffspacingx")
CreateConfig(U[c], T["Debuff Y-Spacing"], C.unitframes[c], "debuffspacingy")
if c ~= "player" then if c ~= "player" then
end end
@@ -2348,7 +2383,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U[c], T["Buff/Debuff Indicators"], nil, nil, "header") CreateConfig(U[c], T["Buff/Debuff Indicators"], nil, nil, "header")
CreateConfig(U[c], T["Enable Indicators"], C.unitframes[c], "buff_indicator", "checkbox") CreateConfig(U[c], T["Enable Indicators"], C.unitframes[c], "buff_indicator", "checkbox")
CreateConfig(U[c], T["Show Time Left"], C.unitframes[c], "indicator_time", "checkbox")
CreateConfig(U[c], T["Show Stacks"], C.unitframes[c], "indicator_stacks", "checkbox") CreateConfig(U[c], T["Show Stacks"], C.unitframes[c], "indicator_stacks", "checkbox")
CreateConfig(U[c], T["Indicator Size"], C.unitframes[c], "indicator_size") CreateConfig(U[c], T["Indicator Size"], C.unitframes[c], "indicator_size")
CreateConfig(U[c], T["Indicator Spacing"], C.unitframes[c], "indicator_spacing", "dropdown", pfUI.gui.dropdowns.spacing) CreateConfig(U[c], T["Indicator Spacing"], C.unitframes[c], "indicator_spacing", "dropdown", pfUI.gui.dropdowns.spacing)
@@ -2401,6 +2435,22 @@ pfUI:RegisterModule("gui", function ()
CreateGUIEntry(T["Character"], T["Inventory"], function() CreateGUIEntry(T["Character"], T["Inventory"], function()
CreateConfig(nil, T["Show Durability"], C.character.inventory, "durability", "checkbox") CreateConfig(nil, T["Show Durability"], C.character.inventory, "durability", "checkbox")
CreateConfig(nil, T["Always Show Equipment Slot Flyouts"], C.character.inventory, "equipflyout", "checkbox")
end)
CreateGUIEntry(T["Character"], T["Equipment Manager"], function()
CreateConfig(nil, T["Automatic Set Switching"], nil, nil, "header")
CreateConfig(U["equipmentmanager"], T["Enable Automatic Set Switching"], C.equipmentmanager, "autoswitch", "checkbox")
CreateConfig(U["equipmentmanager"], T["Announce Automatic Set Switches In Chat"], C.equipmentmanager, "announce", "checkbox")
CreateConfig(nil, T["Items Not In Any Set"], nil, nil, "header")
CreateConfig(U["equipmentmanager"], T["Minimum Item Quality"], C.equipmentmanager, "unusedquality", "dropdown", {
"0:" .. ITEM_QUALITY0_DESC,
"1:" .. ITEM_QUALITY1_DESC,
"2:" .. ITEM_QUALITY2_DESC,
"3:" .. ITEM_QUALITY3_DESC,
"4:" .. ITEM_QUALITY4_DESC,
})
CreateConfig(U["equipmentmanager"], T["Include Bank Items"], C.equipmentmanager, "unusedbank", "checkbox")
end) end)
CreateGUIEntry(T["Character"], T["Reputation"], function() CreateGUIEntry(T["Character"], T["Reputation"], function()
@@ -2419,11 +2469,12 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Hide Chat When Bags Are Opened"], C.appearance.bags, "hidechat", "checkbox") CreateConfig(nil, T["Hide Chat When Bags Are Opened"], C.appearance.bags, "hidechat", "checkbox")
CreateConfig(nil, T["Bagslots Per Row"], C.appearance.bags, "bagrowlength") CreateConfig(nil, T["Bagslots Per Row"], C.appearance.bags, "bagrowlength")
CreateConfig(nil, T["Bankslots Per Row"], C.appearance.bags, "bankrowlength") CreateConfig(nil, T["Bankslots Per Row"], C.appearance.bags, "bankrowlength")
CreateConfig(nil, T["Enable Full-Text Search"], C.appearance.bags, "fulltext")
CreateConfig(nil, T["Item Slot Size"], C.appearance.bags, "icon_size") CreateConfig(nil, T["Item Slot Size"], C.appearance.bags, "icon_size")
CreateConfig(nil, T["Auto Sell Grey Items"], C.global, "autosell", "checkbox") CreateConfig(nil, T["Auto Sell Grey Items"], C.global, "autosell", "checkbox")
CreateConfig(nil, T["Auto Repair Items"], C.global, "autorepair", "checkbox") CreateConfig(nil, T["Auto Repair Items"], C.global, "autorepair", "checkbox")
CreateConfig(nil, T["Auto Sort When Opening Bags"], C.appearance.bags, "autoSortOnOpen", "checkbox") CreateConfig(nil, T["Auto Sort When Opening Bags"], C.appearance.bags, "autoSortOnOpen", "checkbox")
CreateConfig(nil, T["Reverse Sort Direction (Last Bag First)"], C.appearance.bags, "sortreverse", "checkbox")
CreateConfig(nil, T["Reverse Sort Priority (Hearthstone Last)"], C.appearance.bags, "sortprioreverse", "checkbox")
end) end)
CreateGUIEntry(T["Loot"], nil, function() CreateGUIEntry(T["Loot"], nil, function()
@@ -2468,7 +2519,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["buff"], T["Number Of Buffs Per Row"], C.buffs, "buffrowsize") CreateConfig(U["buff"], T["Number Of Buffs Per Row"], C.buffs, "buffrowsize")
CreateConfig(U["buff"], T["Number Of Debuffs Per Row"], C.buffs, "debuffrowsize") CreateConfig(U["buff"], T["Number Of Debuffs Per Row"], C.buffs, "debuffrowsize")
CreateConfig(U["buff"], T["Show Duration Inside Buff"], C.buffs, "textinside", "checkbox") CreateConfig(U["buff"], T["Show Duration Inside Buff"], C.buffs, "textinside", "checkbox")
CreateConfig(U["buff"], T["Buff Font Size"], C.buffs, "fontsize") CreateConfig(U["buff"], T["Stack Count Font Size"], C.buffs, "fontsize")
end) end)
CreateGUIEntry(T["Buffs"], T["Totem Icons"], function() CreateGUIEntry(T["Buffs"], T["Totem Icons"], function()
@@ -2543,9 +2594,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["bars"], T["Button Animation"], C.bars, "animation", "dropdown", pfUI.gui.dropdowns.actionbuttonanimations) CreateConfig(U["bars"], T["Button Animation"], C.bars, "animation", "dropdown", pfUI.gui.dropdowns.actionbuttonanimations)
CreateConfig(U["bars"], T["Button Animation Trigger"], C.bars, "animmode", "dropdown", pfUI.gui.dropdowns.animationmode) CreateConfig(U["bars"], T["Button Animation Trigger"], C.bars, "animmode", "dropdown", pfUI.gui.dropdowns.animationmode)
CreateConfig(U["bars"], T["Show Animation On Hidden Bars"], C.bars, "animalways", "checkbox") CreateConfig(U["bars"], T["Show Animation On Hidden Bars"], C.bars, "animalways", "checkbox")
if not pfUI:MacroAddonsLoaded() then
CreateConfig(U["bars"], T["Scan Macros For Spells"], C.bars, "macroscan", "checkbox", nil, nil, nil, nil)
end
CreateConfig(U["bars"], T["Show Reagent Count"], C.bars, "reagents", "checkbox") CreateConfig(U["bars"], T["Show Reagent Count"], C.bars, "reagents", "checkbox")
CreateConfig(U["bars"], T["Highlight Equipped Items"], C.bars, "showequipped", "checkbox") CreateConfig(U["bars"], T["Highlight Equipped Items"], C.bars, "showequipped", "checkbox")
CreateConfig(U["bars"], T["Equipped Item Color"], C.bars, "eqcolor", "color") CreateConfig(U["bars"], T["Equipped Item Color"], C.bars, "eqcolor", "color")
@@ -2567,7 +2615,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["bars"], T["Item Count Text Color"], C.bars, "count_color", "color") CreateConfig(U["bars"], T["Item Count Text Color"], C.bars, "count_color", "color")
CreateConfig(U["bars"], T["Keybind Text Size"], C.bars, "bind_size") CreateConfig(U["bars"], T["Keybind Text Size"], C.bars, "bind_size")
CreateConfig(U["bars"], T["Keybind Text Color"], C.bars, "bind_color", "color") CreateConfig(U["bars"], T["Keybind Text Color"], C.bars, "bind_color", "color")
CreateConfig(nil, T["Cooldown Text Size"], C.bars, "cd_size")
CreateConfig(nil, T["Auto Paging"], nil, nil, "header") CreateConfig(nil, T["Auto Paging"], nil, nil, "header")
CreateConfig(U["bars"], T["Switch Pages On Alt Key Press"], C.bars, "pagemasteralt", "checkbox") CreateConfig(U["bars"], T["Switch Pages On Alt Key Press"], C.bars, "pagemasteralt", "checkbox")
@@ -2660,8 +2707,8 @@ pfUI:RegisterModule("gui", function ()
elseif is_horizontal then elseif is_horizontal then
if uneven ~= "Left" and uneven ~= "Right" then C.bars["bar"..id].uneven = "Left" end if uneven ~= "Left" and uneven ~= "Right" then C.bars["bar"..id].uneven = "Left" end
end end
if uneven_frame and uneven_frame.input and uneven_frame.input.UpdateMenu then if uneven_frame then
uneven_frame.input:UpdateMenu() uneven_frame.input:GenerateMenu()
end end
if U["bars"] then U["bars"]() end if U["bars"] then U["bars"]() end
end end
@@ -2750,27 +2797,40 @@ pfUI:RegisterModule("gui", function ()
end) end)
CreateGUIEntry(T["Tooltip"], nil, function() CreateGUIEntry(T["Tooltip"], nil, function()
CreateConfig(nil, T["General"], nil, nil, "header")
CreateConfig(nil, T["Tooltip Position"], C.tooltip, "position", "dropdown", pfUI.gui.dropdowns.tooltip_position) CreateConfig(nil, T["Tooltip Position"], C.tooltip, "position", "dropdown", pfUI.gui.dropdowns.tooltip_position)
CreateConfig(nil, T["Tooltip Text Font"], C.tooltip, "font_tooltip", "dropdown", pfUI.gui.dropdowns.fonts) CreateConfig(nil, T["Tooltip Text Font"], C.tooltip, "font_tooltip", "dropdown", pfUI.gui.dropdowns.fonts)
CreateConfig(nil, T["Tooltip Text Font Size"], C.tooltip, "font_tooltip_size") CreateConfig(nil, T["Tooltip Text Font Size"], C.tooltip, "font_tooltip_size")
CreateConfig(nil, T["Cursor Tooltip Align"], C.tooltip, "cursoralign", "dropdown", pfUI.gui.dropdowns.tooltip_align) CreateConfig(nil, T["Cursor Tooltip Align"], C.tooltip, "cursoralign", "dropdown", pfUI.gui.dropdowns.tooltip_align)
CreateConfig(nil, T["Cursor Tooltip Offset"], C.tooltip, "cursoroffset") CreateConfig(nil, T["Cursor Tooltip Offset"], C.tooltip, "cursoroffset")
CreateConfig(nil, T["Enable Extended Guild Information"], C.tooltip, "extguild", "checkbox")
CreateConfig(nil, T["Always Show Health In Percent"], C.tooltip, "alwaysperc", "checkbox")
CreateConfig(nil, T["Show Item IDs"], C.tooltip, "itemid", "checkbox")
CreateConfig(nil, T["Show Movement Speed"], C.tooltip, "movespeed", "checkbox")
CreateConfig(nil, T["Custom Transparency"], C.tooltip, "alpha") CreateConfig(nil, T["Custom Transparency"], C.tooltip, "alpha")
CreateConfig(nil, T["Status Bar Texture"], C.tooltip.statusbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture) CreateConfig(nil, T["Status Bar Texture"], C.tooltip.statusbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture)
CreateConfig(nil, T["Items"], nil, nil, "header")
CreateConfig(nil, T["Always Show Item Comparison"], C.tooltip.compare, "showalways", "checkbox") CreateConfig(nil, T["Always Show Item Comparison"], C.tooltip.compare, "showalways", "checkbox")
CreateConfig(nil, T["Always Show Extended Vendor Values"], C.tooltip.vendor, "showalways", "checkbox") CreateConfig(nil, T["Always Show Extended Vendor Values"], C.tooltip.vendor, "showalways", "checkbox")
CreateConfig(U["questitem"], T["Show Related Quest On Questitems"], C.tooltip.questitem, "showquest", "checkbox") CreateConfig(U["questitem"], T["Show Related Quest On Questitems"], C.tooltip.questitem, "showquest", "checkbox")
CreateConfig(U["questitem"], T["Show Required Questitem Count"], C.tooltip.questitem, "showcount", "checkbox") CreateConfig(U["questitem"], T["Show Required Questitem Count"], C.tooltip.questitem, "showcount", "checkbox")
CreateConfig(nil, T["Show Item IDs"], C.tooltip, "itemid", "checkbox")
CreateConfig(nil, T["Spells"], nil, nil, "header")
CreateConfig(nil, T["Show Aura Caster"], C.tooltip, "aurasource", "checkbox")
CreateConfig(nil, T["Show Spell IDs"], C.tooltip, "spellid", "checkbox")
CreateConfig(nil, T["Units"], nil, nil, "header")
CreateConfig(nil, T["Enable Extended Guild Information"], C.tooltip, "extguild", "checkbox")
CreateConfig(nil, T["Always Show Health In Percent"], C.tooltip, "alwaysperc", "checkbox")
CreateConfig(nil, T["Show Movement Speed"], C.tooltip, "movespeed", "checkbox")
CreateConfig(nil, T["Show Unit Buffs"], C.tooltip, "showbuffs", "checkbox")
CreateConfig(nil, T["Show Unit IDs"], C.tooltip, "unitid", "checkbox")
end) end)
CreateGUIEntry(T["Castbar"], T["General"], function() CreateGUIEntry(T["Castbar"], T["General"], function()
CreateConfig(nil, T["Use Unit Fonts"], C.castbar, "use_unitfonts", "checkbox") CreateConfig(nil, T["Use Unit Fonts"], C.castbar, "use_unitfonts", "checkbox")
CreateConfig(nil, T["Casting Color"], C.appearance.castbar, "castbarcolor", "color") CreateConfig(nil, T["Casting Color"], C.appearance.castbar, "castbarcolor", "color")
CreateConfig(nil, T["Channeling Color"], C.appearance.castbar, "channelcolor", "color") CreateConfig(nil, T["Channeling Color"], C.appearance.castbar, "channelcolor", "color")
CreateConfig(nil, T["Uninterruptible Color"], C.appearance.castbar, "shieldcolor", "color")
CreateConfig(nil, T["Five Second Rule Color"], C.appearance.castbar, "fsrcolor", "color")
CreateConfig(nil, T["Castbar Texture"], C.appearance.castbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture) CreateConfig(nil, T["Castbar Texture"], C.appearance.castbar, "texture", "dropdown", pfUI.gui.dropdowns.uf_bartexture)
CreateConfig(nil, T["Disable Blizzard Castbar"], C.castbar.player, "hide_blizz", "checkbox") CreateConfig(nil, T["Disable Blizzard Castbar"], C.castbar.player, "hide_blizz", "checkbox")
end) end)
@@ -2828,6 +2888,8 @@ pfUI:RegisterModule("gui", function ()
end) end)
CreateGUIEntry(T["Chat"], nil, function() CreateGUIEntry(T["Chat"], nil, function()
-- a nop updater skips the reload prompt; the nop settings below
-- are read by AddMessage on every chat line
CreateConfig(nil, T["Enable \"Loot & Spam\" Chat Window"], C.chat.right, "enable", "checkbox") CreateConfig(nil, T["Enable \"Loot & Spam\" Chat Window"], C.chat.right, "enable", "checkbox")
CreateConfig(nil, T["Inputbox Width"], C.chat.text, "input_width") CreateConfig(nil, T["Inputbox Width"], C.chat.text, "input_width")
CreateConfig(nil, T["Inputbox Height"], C.chat.text, "input_height") CreateConfig(nil, T["Inputbox Height"], C.chat.text, "input_height")
@@ -2836,16 +2898,20 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Show Items On Mouseover"], C.chat.text, "mouseover", "checkbox") CreateConfig(nil, T["Show Items On Mouseover"], C.chat.text, "mouseover", "checkbox")
CreateConfig(nil, T["Chat Default Brackets"], C.chat.text, "bracket", nil, nil, nil, nil, "STRING") CreateConfig(nil, T["Chat Default Brackets"], C.chat.text, "bracket", nil, nil, nil, nil, "STRING")
CreateConfig(nil, T["Enable Timestamps"], C.chat.text, "time", "checkbox") CreateConfig(nil, T["Enable Timestamps"], C.chat.text, "time", "checkbox")
CreateConfig(nil, T["Timestamp Format"], C.chat.text, "timeformat", nil, nil, nil, nil, "STRING") CreateConfig(nop, T["Timestamp Format"], C.chat.text, "timeformat", nil, nil, nil, nil, "STRING")
CreateConfig(nil, T["Timestamp Brackets"], C.chat.text, "timebracket", nil, nil, nil, nil, "STRING") CreateConfig(nil, T["Timestamp Brackets"], C.chat.text, "timebracket", nil, nil, nil, nil, "STRING")
CreateConfig(nil, T["Timestamp Color"], C.chat.text, "timecolor", "color") CreateConfig(nil, T["Timestamp Color"], C.chat.text, "timecolor", "color")
CreateConfig(nil, T["Hide Channel Names"], C.chat.text, "channelnumonly", "checkbox") -- read each time chat copy opens, so no reload
CreateConfig(nop, T["Show Timestamps In Chat Copy"], C.chat.text, "copytime", "checkbox")
CreateConfig(nop, T["Hide Channel Names"], C.chat.text, "channelnumonly", "checkbox")
CreateConfig(nil, T["Generate Playerlinks"], C.chat.text, "playerlinks", "checkbox") CreateConfig(nil, T["Generate Playerlinks"], C.chat.text, "playerlinks", "checkbox")
CreateConfig(nil, T["Enable URL Detection"], C.chat.text, "detecturl", "checkbox") CreateConfig(nop, T["Enable URL Detection"], C.chat.text, "detecturl", "checkbox")
CreateConfig(nil, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox") CreateConfig(nop, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox")
CreateConfig(nil, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox") local _, playerRace = UnitRace("player")
CreateConfig(nil, T["Who Search Unknown Classes (|cffffaaaaExperimental|r)"], C.chat.text, "whosearchunknown", "checkbox") CreateConfig(nop, T["Show Faction Icons"] .. " " .. GetFactionIcon(playerRace), C.chat.text, "factionicons", "checkbox")
CreateConfig(nil, T["Colorize Unknown Classes"], C.chat.text, "tintunknown", "checkbox") CreateConfig(nop, T["Show Race Icons"] .. " " .. GetRaceIcon(playerRace, UnitSex("player")), C.chat.text, "raceicons", "checkbox")
CreateConfig(nop, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox")
CreateConfig(nop, T["Colorize Unknown Classes"], C.chat.text, "tintunknown", "checkbox")
CreateConfig(nil, T["Unknown Class Color"], C.chat.text, "unknowncolor", "color") CreateConfig(nil, T["Unknown Class Color"], C.chat.text, "unknowncolor", "color")
CreateConfig(nil, T["Left Chat Width"], C.chat.left, "width") CreateConfig(nil, T["Left Chat Width"], C.chat.left, "width")
CreateConfig(nil, T["Left Chat Height"], C.chat.left, "height") CreateConfig(nil, T["Left Chat Height"], C.chat.left, "height")
@@ -2856,16 +2922,16 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Only Show Chat Dock On Mouseover"], C.chat.global, "tabmouse", "checkbox") CreateConfig(nil, T["Only Show Chat Dock On Mouseover"], C.chat.global, "tabmouse", "checkbox")
CreateConfig(nil, T["Enable Chat Tab Flashing"], C.chat.global, "chatflash", "checkbox") CreateConfig(nil, T["Enable Chat Tab Flashing"], C.chat.global, "chatflash", "checkbox")
CreateConfig(nil, T["Enable Frame Shadow"], C.chat.global, "frameshadow", "checkbox") CreateConfig(nil, T["Enable Frame Shadow"], C.chat.global, "frameshadow", "checkbox")
CreateConfig(nil, T["Enable Custom Colors"], C.chat.global, "custombg", "checkbox") CreateConfig(U["chat"], T["Enable Custom Colors"], C.chat.global, "custombg", "checkbox")
CreateConfig(nil, T["Chat Background Color"], C.chat.global, "background", "color") CreateConfig(U["chat"], T["Chat Background Color"], C.chat.global, "background", "color")
CreateConfig(nil, T["Chat Border Color"], C.chat.global, "border", "color") CreateConfig(U["chat"], T["Chat Border Color"], C.chat.global, "border", "color")
CreateConfig(nil, T["Enable Custom Incoming Whispers Layout"], C.chat.global, "whispermod", "checkbox") CreateConfig(nil, T["Enable Custom Incoming Whispers Layout"], C.chat.global, "whispermod", "checkbox")
CreateConfig(nil, T["Incoming Whispers Color"], C.chat.global, "whisper", "color") CreateConfig(nil, T["Incoming Whispers Color"], C.chat.global, "whisper", "color")
CreateConfig(nil, T["Enable Sticky Chat"], C.chat.global, "sticky", "checkbox") CreateConfig(nil, T["Enable Sticky Chat"], C.chat.global, "sticky", "checkbox")
CreateConfig(nil, T["Maximum Number Of Chat Lines"], C.chat.global, "maxlines") CreateConfig(nil, T["Maximum Number Of Chat Lines"], C.chat.global, "maxlines")
CreateConfig(nil, T["Enable Chat Fade"], C.chat.global, "fadeout", "checkbox") CreateConfig(nil, T["Enable Chat Fade"], C.chat.global, "fadeout", "checkbox")
CreateConfig(nil, T["Seconds Before Chat Fade"], C.chat.global, "fadetime") CreateConfig(nil, T["Seconds Before Chat Fade"], C.chat.global, "fadetime")
CreateConfig(nil, T["Mousewheel Scroll Speed"], C.chat.global, "scrollspeed") CreateConfig(nop, T["Mousewheel Scroll Speed"], C.chat.global, "scrollspeed")
CreateConfig(nil, T["Enable Chat Bubbles"], "CVAR", "chatBubbles", "checkbox") CreateConfig(nil, T["Enable Chat Bubbles"], "CVAR", "chatBubbles", "checkbox")
CreateConfig(nil, T["Enable Party Chat Bubbles"], "CVAR", "chatBubblesParty", "checkbox") CreateConfig(nil, T["Enable Party Chat Bubbles"], "CVAR", "chatBubblesParty", "checkbox")
CreateConfig(nil, T["Enable Chat Bubble Borders"], C.chat.bubbles, "borders", "checkbox") CreateConfig(nil, T["Enable Chat Bubble Borders"], C.chat.bubbles, "borders", "checkbox")
@@ -2919,9 +2985,6 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["nameplates"], T["Debuff Icon Offset"], C.nameplates, "debuffoffset") CreateConfig(U["nameplates"], T["Debuff Icon Offset"], C.nameplates, "debuffoffset")
CreateConfig(U["nameplates"], T["Debuff Icon Size"], C.nameplates, "debuffsize") CreateConfig(U["nameplates"], T["Debuff Icon Size"], C.nameplates, "debuffsize")
CreateConfig(U["nameplates"], T["Show Debuff Stacks"], C.nameplates.debuffs, "showstacks", "checkbox") CreateConfig(U["nameplates"], T["Show Debuff Stacks"], C.nameplates.debuffs, "showstacks", "checkbox")
CreateConfig(U["nameplates"], T["Enable Debuff Timers"], C.nameplates, "debufftimers", "checkbox")
CreateConfig(U["nameplates"], T["Show Timer Text"], C.nameplates, "debufftext", "checkbox")
CreateConfig(Reload, T["Show Timer Animation"], C.nameplates, "debuffanim", "checkbox")
CreateConfig(U["nameplates"], T["Filter Mode"], C.nameplates.debuffs, "filter", "dropdown", pfUI.gui.dropdowns.buffbarfilter) CreateConfig(U["nameplates"], T["Filter Mode"], C.nameplates.debuffs, "filter", "dropdown", pfUI.gui.dropdowns.buffbarfilter)
CreateConfig(U["nameplates"], T["Blacklist"], C.nameplates.debuffs, "blacklist", "list") CreateConfig(U["nameplates"], T["Blacklist"], C.nameplates.debuffs, "blacklist", "list")
@@ -2975,6 +3038,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Use Chat Colors for Meters"], C.thirdparty, "chatbg", "checkbox") CreateConfig(nil, T["Use Chat Colors for Meters"], C.thirdparty, "chatbg", "checkbox")
CreateConfig(nil, "ShaguDPS (" .. T["Skin"] .. ")", C.thirdparty.shagudps, "skin", "checkbox") CreateConfig(nil, "ShaguDPS (" .. T["Skin"] .. ")", C.thirdparty.shagudps, "skin", "checkbox")
CreateConfig(nil, "ShaguDPS (" .. T["Dock"] .. ")", C.thirdparty.shagudps, "dock", "checkbox") CreateConfig(nil, "ShaguDPS (" .. T["Dock"] .. ")", C.thirdparty.shagudps, "dock", "checkbox")
CreateConfig(nil, "GreedMeter (" .. T["Dock"] .. ")", C.thirdparty.greedmeter, "dock", "checkbox")
CreateConfig(nil, "DPSMate (" .. T["Skin"] .. ")", C.thirdparty.dpsmate, "skin", "checkbox") CreateConfig(nil, "DPSMate (" .. T["Skin"] .. ")", C.thirdparty.dpsmate, "skin", "checkbox")
CreateConfig(nil, "DPSMate (" .. T["Dock"] .. ")", C.thirdparty.dpsmate, "dock", "checkbox") CreateConfig(nil, "DPSMate (" .. T["Dock"] .. ")", C.thirdparty.dpsmate, "dock", "checkbox")
CreateConfig(nil, "SWStats (" .. T["Skin"] .. ")", C.thirdparty.swstats, "skin", "checkbox") CreateConfig(nil, "SWStats (" .. T["Skin"] .. ")", C.thirdparty.swstats, "skin", "checkbox")
@@ -3003,8 +3067,7 @@ pfUI:RegisterModule("gui", function ()
CreateGUIEntry(T["Components"], T["Modules"], function() CreateGUIEntry(T["Components"], T["Modules"], function()
table.sort(pfUI.modules) table.sort(pfUI.modules)
for i,m in pairs(pfUI.modules) do for i,m in pairs(pfUI.modules) do
-- skip gui and macrotweak when macro addons are loaded if m ~= "gui" then
if m ~= "gui" and not (m == "macrotweak" and pfUI:MacroAddonsLoaded()) then
-- create disabled entry if not existing and display -- create disabled entry if not existing and display
pfUI:UpdateConfig("disabled", nil, m, "0") pfUI:UpdateConfig("disabled", nil, m, "0")
CreateConfig(nil, T["Disable Module"] .. " " .. m, C.disabled, m, "checkbox") CreateConfig(nil, T["Disable Module"] .. " " .. m, C.disabled, m, "checkbox")
+22 -6
View File
@@ -51,7 +51,7 @@ pfUI:RegisterModule("hoverbind", function ()
pfUI.hoverbind.edit:SetAllPoints(UIParent) pfUI.hoverbind.edit:SetAllPoints(UIParent)
pfUI.hoverbind.edit.tex = pfUI.hoverbind.edit:CreateTexture("pfKeyBindShade", "BACKGROUND") pfUI.hoverbind.edit.tex = pfUI.hoverbind.edit:CreateTexture("pfKeyBindShade", "BACKGROUND")
pfUI.hoverbind.edit.tex:SetAllPoints(pfUI.hoverbind.edit) pfUI.hoverbind.edit.tex:SetAllPoints(pfUI.hoverbind.edit)
pfUI.hoverbind.edit.tex:SetTexture(0,0,0,.5) pfUI.hoverbind.edit.tex:SetColorTexture(0,0,0,.5)
pfUI.hoverbind.edit:SetScript("OnClick", function() pfUI.hoverbind.edit:SetScript("OnClick", function()
pfUI.hoverbind:Hide() pfUI.hoverbind:Hide()
end) end)
@@ -105,6 +105,10 @@ pfUI:RegisterModule("hoverbind", function ()
end end
end end
local function BindingName(command)
return _G["BINDING_NAME_" .. command] or command
end
function pfUI.hoverbind:GetPrefix() function pfUI.hoverbind:GetPrefix()
return string.format("%s%s%s", return string.format("%s%s%s",
(IsAltKeyDown() and modifiers.ALT or ""), (IsAltKeyDown() and modifiers.ALT or ""),
@@ -157,17 +161,29 @@ pfUI:RegisterModule("hoverbind", function ()
if arg1 == "ESCAPE" and not binding then pfUI.hoverbind:Hide() return end if arg1 == "ESCAPE" and not binding then pfUI.hoverbind:Hide() return end
if binding then if binding then
if arg1 == "ESCAPE" then if arg1 == "ESCAPE" then
-- Remove existing binding -- Remove all existing bindings
local key = (GetBindingKey(binding)) local keys = { GetBindingKey(binding) }
if (key) then for _, key in ipairs(keys) do
SetBinding(key) SetBinding(key)
end
if keys[1] then
SaveBindings(GetCurrentBindingSet()) SaveBindings(GetCurrentBindingSet())
end end
else else
-- Create new binding -- Create new binding
local key = map and map[arg1] or arg1 local key = prefix .. (map and map[arg1] or arg1)
if (SetBinding(prefix..key, binding)) then local previous = GetBindingAction(key)
if (SetBinding(key, binding)) then
SaveBindings(GetCurrentBindingSet()) SaveBindings(GetCurrentBindingSet())
if previous and previous ~= "" and previous ~= binding then
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. key .. "|r " .. T["was unbound from"] .. " " .. BindingName(previous))
end
local active = GetBindingAction(key, true)
if active ~= binding then
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffcc" .. key .. "|r " .. T["is currently overridden by"] .. " " .. BindingName(active))
end
end end
end end
end end
+34 -9
View File
@@ -1,10 +1,8 @@
pfUI:RegisterModule("hunterbar", function () pfUI:RegisterModule("hunterbar", function ()
local _,class = UnitClass("player") if UnitClassBase("player") ~= "HUNTER" or C.bars.hunterbar == "0" then return end
if class ~= "HUNTER" or C.bars.hunterbar == "0" then return end
-- Wing Clip (any rank) and Arcane Shot (any rank) spell IDs. -- Wing Clip (any rank) and Arcane Shot (any rank) spell IDs.
-- IsSpellInRange(spellId) works with any spell ID via Nampower, -- C_Spell.IsSpellInRange works with any spell ID, no actionbar slot needed.
-- no actionbar slot needed.
local WINGCLIP_ID = 2974 -- melee range indicator (~5 yd) local WINGCLIP_ID = 2974 -- melee range indicator (~5 yd)
local ARCANESHOT_ID = 3044 -- ranged range indicator (~35 yd) local ARCANESHOT_ID = 3044 -- ranged range indicator (~35 yd)
@@ -12,22 +10,37 @@ pfUI:RegisterModule("hunterbar", function ()
-- Only swap BACK to melee bar when Wing Clip is actually in range. -- Only swap BACK to melee bar when Wing Clip is actually in range.
-- This prevents rapid bar-flipping in the transition zone. -- This prevents rapid bar-flipping in the transition zone.
local THROTTLE = 0.02 -- seconds between range checks (was every frame)
pfUI.hunterbar = CreateFrame("Frame", "pfHunterBar", UIParent) pfUI.hunterbar = CreateFrame("Frame", "pfHunterBar", UIParent)
-- track which page we last forced so we don't spam ChangeActionBarPage() -- track which page we last forced so we don't spam ChangeActionBarPage()
pfUI.hunterbar.lastPage = nil pfUI.hunterbar.lastPage = nil
pfUI.hunterbar.elapsed = 0
-- Idle until there's a live, attackable target. A hidden frame runs no
-- OnUpdate, so the range polling only ticks while it can matter.
pfUI.hunterbar:Hide()
pfUI.hunterbar:SetScript("OnUpdate", function() pfUI.hunterbar:SetScript("OnUpdate", function()
-- only act when there is a live, attackable target this.elapsed = this.elapsed + arg1
if this.elapsed < THROTTLE then return end
this.elapsed = 0
-- Target died or turned unattackable without a target-change event
-- (it dropped to a corpse); stop ticking until the next target.
if not UnitExists("target") or not UnitCanAttack("player", "target") then if not UnitExists("target") or not UnitCanAttack("player", "target") then
this:Hide()
return return
end end
local wingclipInRange = IsSpellInRange(WINGCLIP_ID, "target") -- C_Spell.IsSpellInRange returns true / false / nil (rangeless). The
local arcaneshotInRange = IsSpellInRange(ARCANESHOT_ID, "target") -- explicit == true / == false tests leave the bar unchanged on nil.
local wingclipInRange = C_Spell.IsSpellInRange(WINGCLIP_ID, "target")
local arcaneshotInRange = C_Spell.IsSpellInRange(ARCANESHOT_ID, "target")
-- swap to ranged bar: out of melee range AND arcane shot (8yd) in range -- swap to ranged bar: out of melee range AND arcane shot (8yd) in range
if wingclipInRange == 0 and arcaneshotInRange == 1 then if wingclipInRange == false and arcaneshotInRange == true then
if this.lastPage ~= 2 then if this.lastPage ~= 2 then
this.lastPage = 2 this.lastPage = 2
_G.CURRENT_ACTIONBAR_PAGE = 2 _G.CURRENT_ACTIONBAR_PAGE = 2
@@ -35,7 +48,7 @@ pfUI:RegisterModule("hunterbar", function ()
end end
-- swap to melee bar: in melee range AND arcane shot (8yd) out of range -- swap to melee bar: in melee range AND arcane shot (8yd) out of range
elseif wingclipInRange == 1 and arcaneshotInRange == 0 then elseif wingclipInRange == true and arcaneshotInRange == false then
if this.lastPage ~= 1 then if this.lastPage ~= 1 then
this.lastPage = 1 this.lastPage = 1
_G.CURRENT_ACTIONBAR_PAGE = 1 _G.CURRENT_ACTIONBAR_PAGE = 1
@@ -43,4 +56,16 @@ pfUI:RegisterModule("hunterbar", function ()
end end
end end
end) end)
-- Start ticking only when we gain an attackable target.
pfUI.hunterbar:RegisterEvent("PLAYER_TARGET_CHANGED")
pfUI.hunterbar:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.hunterbar:SetScript("OnEvent", function()
if UnitExists("target") and UnitCanAttack("player", "target") then
this.elapsed = THROTTLE -- run the first check on the next frame
this:Show()
else
this:Hide()
end
end)
end) end)
+49 -35
View File
@@ -1,51 +1,65 @@
pfUI:RegisterModule("infight", function () pfUI:RegisterModule("infight", function ()
local function OnUpdate() pfUI.infight = CreateFrame("Frame", "pfUICombatScreen", WorldFrame)
if not this.infight and not this.aggro and not this.health then return end pfUI.infight:SetAllPoints(WorldFrame)
if ( this.tick or 1) > GetTime() then return else this.tick = GetTime() + .1 end pfUI.infight:EnableMouse(false)
pfUI.infight:Hide()
if not this.fadeValue then this.fadeValue = 1 end -- Shift the glow between red and a paler orange for good. The group only
if this.fadeValue >= 0.3 then -- advances while the glow is shown, so a hidden glow costs nothing.
this.fadeModifier = -0.1 local pulse = pfUI.infight:CreateAnimationGroup()
end pulse:SetLooping("BOUNCE")
if this.fadeValue <= 0 then local shift = pulse:CreateAnimation()
this.fadeModifier = 0.1 shift:SetDuration(.3)
end shift:SetSmoothing("IN_OUT")
this.fadeValue = this.fadeValue + this.fadeModifier shift:SetScript("OnUpdate", function(self)
local fade = self:GetSmoothProgress() * .3
pfUI.infight:SetBackdropBorderColor(1, .2 + fade, fade, 1 - fade)
end)
pulse:Play()
local visible = nil -- Combat, health, death and aggro all come from events.
if this.infight and UnitAffectingCombat("player") then visible = true end local combat, health, dead, aggro
if this.aggro and UnitHasAggro("player") > 0 then visible = true end
if this.health and UnitHealth("player")/UnitHealthMax("player")*100 <= 25 then visible = true end
if UnitIsDeadOrGhost("player") then visible = nil end
if visible then local function Refresh()
this.screen:Show() pfUI.infight:SetShown((combat or health or aggro) and not dead)
this.screen:SetBackdropBorderColor(1,0.2+this.fadeValue, this.fadeValue, 1-this.fadeValue)
else
this.screen:Hide()
end
end end
pfUI.infight = CreateFrame("Frame", "pfUICombat", UIParent) local function UpdateAggro()
pfUI.infight:SetScript("OnUpdate", OnUpdate) aggro = C.appearance.infight.aggro == "1" and UnitHasAggro("player") > 0
Refresh()
end
pfUI.infight.screen = CreateFrame("Frame", "pfUICombatScreen", WorldFrame) -- a combat drop is also when an attacker that left view is let go
pfUI.infight.screen:SetAllPoints(WorldFrame) local function UpdatePlayer()
pfUI.infight.screen:EnableMouse(false) combat = C.appearance.infight.screen == "1" and UnitAffectingCombat("player")
pfUI.infight.screen:Hide() health = C.appearance.infight.health == "1" and UnitHealth("player") / UnitHealthMax("player") <= .25
dead = UnitIsDeadOrGhost("player")
UpdateAggro()
end
pfUI.infight:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.infight:RegisterEvent("PLAYER_REGEN_DISABLED")
pfUI.infight:RegisterEvent("PLAYER_REGEN_ENABLED")
pfUI.infight:RegisterEvent("PLAYER_DEAD")
pfUI.infight:RegisterEvent("PLAYER_ALIVE")
pfUI.infight:RegisterEvent("PLAYER_UNGHOST")
pfUI.infight:RegisterUnitEvent("UNIT_HEALTH", "player")
pfUI.infight:RegisterUnitEvent("UNIT_MAXHEALTH", "player")
pfUI.infight:SetScript("OnEvent", UpdatePlayer)
pfUI.events:RegisterCallback("aggro:changed", function(_, old, new)
local player = UnitGUID("player")
if old == player or new == player then UpdateAggro() end
end, "infight")
pfUI.infight.UpdateConfig = function(self) pfUI.infight.UpdateConfig = function(self)
pfUI.infight.infight = C.appearance.infight.screen == "1" and true or nil pfUI.infight:SetBackdrop({
pfUI.infight.aggro = C.appearance.infight.aggro == "1" and true or nil
pfUI.infight.health = C.appearance.infight.health == "1" and true or nil
pfUI.infight.screen:SetBackdrop({
edgeFile = pfUI.media["img:glow"], edgeSize = tonumber(C.appearance.infight.intensity), edgeFile = pfUI.media["img:glow"], edgeSize = tonumber(C.appearance.infight.intensity),
insets = {left = 0, right = 0, top = 0, bottom = 0}, insets = {left = 0, right = 0, top = 0, bottom = 0},
}) })
pfUI.infight.screen:Hide() UpdatePlayer()
end end
pfUI.infight.UpdateConfig() pfUI.infight:UpdateConfig()
end) end)
+35 -61
View File
@@ -1,26 +1,13 @@
-- Innervate Callout Module -- Innervate Callout Module
-- Announces Innervate casts via raid/party/battleground chat -- Announces Innervate casts via raid/party/battleground chat
-- Registers AURA_CAST events directly - zero polling, pure event-driven -- Listens to COMBAT_LOG_EVENT_UNFILTERED - zero polling, pure event-driven
pfUI:RegisterModule("innervatecall", function () pfUI:RegisterModule("innervatecall", function ()
-- Requires Nampower for AURA_CAST events
if not GetNampowerVersion then return end
-- Only load for druids -- Only load for druids
local _, playerClass = UnitClass("player") if UnitClassBase("player") ~= "DRUID" then return end
if playerClass ~= "DRUID" then return end
local INNERVATE_SPELLID = 29166 local INNERVATE_SPELLID = 29166
local GCD_DURATION = 1.5
-- GUID → name resolution for the target. UnitTokenFromGUID walks the
-- engine's known unit tokens (player, party, raid, target, ...) and
-- returns the first one currently bound to the GUID, so we don't have
-- to manually iterate party/raid here.
local function ResolveTargetName(targetGuid)
if not targetGuid then return nil end
local token = UnitTokenFromGUID(targetGuid)
return token and UnitName(token) or nil
end
-- Determine chat channel based on group context -- Determine chat channel based on group context
local function GetAnnounceChannel() local function GetAnnounceChannel()
@@ -40,57 +27,44 @@ pfUI:RegisterModule("innervatecall", function ()
return nil return nil
end end
-- Event frame - registers AURA_CAST directly (bypasses libdebuff hooks -- Set on our cast, cleared once the "ready" timer is scheduled
-- which are gated behind ownDebuffs/pendingCasts checks meant for debuffs) local pending = false
local frame = CreateFrame("Frame")
-- AURA_CAST_ON_SELF fires when a buff lands ON the player
-- AURA_CAST_ON_OTHER fires when a buff lands on someone else
-- Both needed: self-innervate = ON_SELF, innervate on others = ON_OTHER
-- casterGuid check prevents announcing other druids' innervates
frame:RegisterEvent("AURA_CAST_ON_SELF")
frame:RegisterEvent("AURA_CAST_ON_OTHER")
frame:RegisterEvent("PLAYER_LOGOUT")
frame:SetScript("OnEvent", function()
if event == "PLAYER_LOGOUT" then
this:UnregisterAllEvents()
this:SetScript("OnEvent", nil)
return
end
-- AURA_CAST args: arg1=spellId, arg2=casterGuid, arg3=targetGuid -- Schedule the "ready" announcement once Innervate's own cooldown is in
local spellId = arg1 -- the spell history. Until then GetSpellCooldown reports only the GCD,
local casterGuid = arg2 -- which has no isOnGCD flag here, so tell them apart by duration.
local targetGuid = arg3 local function ScheduleReady()
local cd = C_Spell.GetSpellCooldown(INNERVATE_SPELLID)
if not cd or cd.duration <= GCD_DURATION then return end
if spellId ~= INNERVATE_SPELLID then return end pending = false
C_Timer.After(cd.startTime + cd.duration - GetTime(), function()
-- Only announce our own casts
if not IsPlayerGuid(casterGuid) then return end
-- Resolve target name from GUID
local targetName = ResolveTargetName(targetGuid) or "Unknown"
-- Determine channel
local channel = GetAnnounceChannel()
if not channel then return end -- solo, no announcement
SendChatMessage(">> Innervate casted on " .. targetName .. " <<", channel)
-- Schedule "ready" announcement when cooldown expires
-- Use GetSpellIdCooldown for precise remaining time, fallback to 360s
local cdRemaining = 360
if GetSpellIdCooldown then
local cd = GetSpellIdCooldown(INNERVATE_SPELLID)
if cd and cd.cooldownRemainingMs and cd.cooldownRemainingMs > 0 then
cdRemaining = cd.cooldownRemainingMs / 1000
end
end
C_Timer.After(cdRemaining, function()
local ch = GetAnnounceChannel() local ch = GetAnnounceChannel()
if ch then if ch then
SendChatMessage(">> Innervate is ready <<", ch) SendChatMessage(">> Innervate is ready <<", ch)
end end
end) end)
end
pfUI.events:RegisterFrameEventAndCallback("SPELL_UPDATE_COOLDOWN", function()
if pending then ScheduleReady() end
end)
pfUI.events:RegisterFrameEventAndCallback("COMBAT_LOG_EVENT_UNFILTERED", function()
-- Innervate is instant, so it logs SPELL_CAST_SUCCESS with its target
local _, subevent, _, sourceGUID, _, _, _, _, destName, _, _, spellId = CombatLogGetCurrentEventInfo()
if subevent ~= "SPELL_CAST_SUCCESS" or spellId ~= INNERVATE_SPELLID then return end
-- Only announce our own casts
if not IsPlayerGuid(sourceGUID) then return end
-- Determine channel
local channel = GetAnnounceChannel()
if not channel then return end -- solo, no announcement
SendChatMessage(">> Innervate cast on " .. (destName or "Unknown") .. " <<", channel)
pending = true
ScheduleReady()
end) end)
end) end)
+8 -4
View File
@@ -26,10 +26,14 @@ pfUI:RegisterModule("itemcount", function ()
if bank < 0 then bank = 0 end if bank < 0 then bank = 0 end
frame:AddLine(" ") frame:AddLine(" ")
if bags > 0 then frame:AddDoubleLine("Bags:", bags, 1, 1, 1, 1, 1, 1) end if bags > 0 then frame:AddDoubleLine(T["Bags"] .. ":", bags, 1, 1, 1, 1, 1, 1) end
if bank > 0 then frame:AddDoubleLine("Bank:", bank, 1, 1, 1, 1, 1, 1) end if bank > 0 then frame:AddDoubleLine(T["Bank"] .. ":", bank, 1, 1, 1, 1, 1, 1) end
if equipped > 0 then frame:AddDoubleLine("Equipped:", equipped, 1, 1, 1, 1, 1, 1) end if equipped > 0 then frame:AddDoubleLine(T["Equipped"] .. ":", equipped, 1, 1, 1, 1, 1, 1) end
frame:AddDoubleLine("Total:", total, 1, 1, 1, 1, 1, 1)
local sources = (bags > 0 and 1 or 0) + (bank > 0 and 1 or 0) + (equipped > 0 and 1 or 0)
if sources > 1 then
frame:AddDoubleLine(T["Total"] .. ":", total, 1, 1, 1, 1, 1, 1)
end
frame:Show() frame:Show()
end end
+98 -213
View File
@@ -31,8 +31,9 @@ pfUI:RegisterModule("loot", function ()
pfUI.loot.randoms = {} pfUI.loot.randoms = {}
pfUI.loot.rollers = {} pfUI.loot.rollers = {}
pfUI.loot.rollers_sorted = {} pfUI.loot.rollers_sorted = {}
pfUI.loot.info = {}
local info = pfUI.loot.info -- the master loot menu while it is shown
local masterLootMenu, OpenMasterLootMenu, RefreshMasterLootMenu
function pfUI.loot.RaidRoll(candidates) function pfUI.loot.RaidRoll(candidates)
if type(candidates) ~= "table" then return end if type(candidates) ~= "table" then return end
@@ -48,7 +49,7 @@ pfUI:RegisterModule("loot", function ()
names = (k==1) and (i..":"..pfUI.loot.index_to_name[candidates[i]]) or (names..", "..i..":"..pfUI.loot.index_to_name[candidates[i]]) names = (k==1) and (i..":"..pfUI.loot.index_to_name[candidates[i]]) or (names..", "..i..":"..pfUI.loot.index_to_name[candidates[i]])
-- fit the maximum names in a single 255 char message (15) -- fit the maximum names in a single 255 char message (15)
if i == to or k == 15 then if i == to or k == 15 then
QueueFunction(SendChatMessageWide,names) SendChatMessageWide(names)
names = "" names = ""
end end
k = k<15 and k+1 or 1 k = k<15 and k+1 or 1
@@ -57,10 +58,11 @@ pfUI:RegisterModule("loot", function ()
end end
pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM") pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM")
pfUI.loot.randomRolling = true pfUI.loot.randomRolling = true
QueueFunction(RandomRoll,"1",tostring(to)) RandomRoll("1",tostring(to))
end end
end end
-- the roll actions keep the menu open, so it can show the rolls coming in
function pfUI.loot.RequestRolls() function pfUI.loot.RequestRolls()
local slot = pfUI.loot.selectedSlot or 0 local slot = pfUI.loot.selectedSlot or 0
local rollers = wipe(pfUI.loot.rollers) local rollers = wipe(pfUI.loot.rollers)
@@ -68,60 +70,16 @@ pfUI:RegisterModule("loot", function ()
SendChatMessageWide(T["Roll for"].. " " .. GetLootSlotLink(slot)) SendChatMessageWide(T["Roll for"].. " " .. GetLootSlotLink(slot))
pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM") pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM")
pfUI.loot.monitorRolling = true pfUI.loot.monitorRolling = true
UIDropDownMenu_Refresh(GroupLootDropDown) RefreshMasterLootMenu()
end return MenuResponse.Open
function pfUI.loot:BuildSpecialRecipientsMenu(level)
local slot = pfUI.loot.selectedSlot or 0
if level == 1 then
if pfUI.loot.my_index or pfUI.loot.disenchanter_index or pfUI.loot.banker_index then
info = wipe(info)
info.text = T["Special Recipient"]
info.textR = NORMAL_FONT_COLOR.r
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.textHeight = 12
info.hasArrow = 1
info.notCheckable = 1
info.value = "PFRECIPIENTS"
info.func = nil
UIDropDownMenu_AddButton(info)
end
elseif level == 2 then
if UIDROPDOWNMENU_MENU_VALUE == "PFRECIPIENTS" then
if (pfUI.loot.my_index) then
info = wipe(info)
info.text = T["Self"]
info.textHeight = 12
info.value = pfUI.loot.my_index
info.func = GroupLootDropDown_GiveLoot
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
end
if (pfUI.loot.disenchanter_index) then
info = wipe(info)
info.text = T["Disenchanter"]
info.textHeight = 12
info.value = pfUI.loot.disenchanter_index
info.func = GroupLootDropDown_GiveLoot
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
end
if (pfUI.loot.banker_index) then
info = wipe(info)
info.text = T["Banker"]
info.textHeight = 12
info.value = pfUI.loot.banker_index
info.func = GroupLootDropDown_GiveLoot
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
end
end
end
end end
function pfUI.loot.ClearRolls() function pfUI.loot.ClearRolls()
wipe(pfUI.loot.rollers) wipe(pfUI.loot.rollers)
wipe(pfUI.loot.rollers_sorted) wipe(pfUI.loot.rollers_sorted)
pfUI.loot.monitorRolling = nil pfUI.loot.monitorRolling = nil
UIDropDownMenu_Refresh(GroupLootDropDown) RefreshMasterLootMenu()
return MenuResponse.Open
end end
function pfUI.loot.CallTieRoll(rollers) function pfUI.loot.CallTieRoll(rollers)
@@ -150,77 +108,12 @@ pfUI:RegisterModule("loot", function ()
pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM") pfUI.loot:RegisterEvent("CHAT_MSG_SYSTEM")
pfUI.loot.monitorRolling = true pfUI.loot.monitorRolling = true
end end
UIDropDownMenu_Refresh(GroupLootDropDown) RefreshMasterLootMenu()
return MenuResponse.Open
end end
function pfUI.loot:BuildSpecialRollsMenu(level) -- fills the candidate tables from the master loot candidates of the raid
local slot = pfUI.loot.selectedSlot or 0 local function UpdateRaidCandidates()
if level == 1 then
info = wipe(info)
info.text = T["Random"]
info.textR = NORMAL_FONT_COLOR.r
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFRANDOM"
info.textHeight = 12
info.notCheckable = 1
info.arg1 = pfUI.loot.randoms
info.func = pfUI.loot.RaidRoll
UIDropDownMenu_AddButton(info)
info = wipe(info)
info.text = T["Request Rolls"]
info.textR = NORMAL_FONT_COLOR.r
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFROLLS"
info.textHeight = 12
info.hasArrow = 1
info.notCheckable = 1
info.func = pfUI.loot.RequestRolls
UIDropDownMenu_AddButton(info)
elseif level == 2 then
if UIDROPDOWNMENU_MENU_VALUE == "PFROLLS" then
info = wipe(info)
info.text = T["Clear Rolls"]
info.textR = NORMAL_FONT_COLOR.r
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFCLEARROLLS"
info.notCheckable = 1
info.func = pfUI.loot.ClearRolls
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
info = wipe(info)
info.text = T["Reroll Ties"]
info.textR = NORMAL_FONT_COLOR.r
info.textG = NORMAL_FONT_COLOR.g
info.textB = NORMAL_FONT_COLOR.b
info.value = "PFTIEROLL"
info.notCheckable = 1
info.arg1 = pfUI.loot.rollers_sorted
info.func = pfUI.loot.CallTieRoll
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
for _,roller in ipairs(pfUI.loot.rollers_sorted) do
info = wipe(info)
info.text = string.format("%02d - %s",roller.roll,roller.who)
info.textHeight = 12
if roller.value == "disabled" then
info.disabled = 1
info.value = "disabled"
else
info.value = roller.value
info.func = GroupLootDropDown_GiveLoot
end
info.notCheckable = 1
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
end
end
end
end
function pfUI.loot:BuildRaidMenu(level)
local slot = pfUI.loot.selectedSlot or 0
local index_to_name = wipe(pfUI.loot.index_to_name) local index_to_name = wipe(pfUI.loot.index_to_name)
local name_to_index = wipe(pfUI.loot.name_to_index) local name_to_index = wipe(pfUI.loot.name_to_index)
local classes_in_raid = wipe(pfUI.loot.classes_in_raid) -- [global class]=localized class for display local classes_in_raid = wipe(pfUI.loot.classes_in_raid) -- [global class]=localized class for display
@@ -252,89 +145,97 @@ pfUI:RegisterModule("loot", function ()
table.insert(players_in_class[unit.class],candidate) table.insert(players_in_class[unit.class],candidate)
end end
end end
if level == 1 then -- classes end
info = wipe(info)
info.text = GIVE_LOOT -- gives the selected slot to a candidate, asking first for epic items
info.textHeight = 12 local function GiveLoot(index)
info.notCheckable = 1 if ( pfUI.loot.selectedQuality >= MASTER_LOOT_THREHOLD ) then
info.isTitle = 1 local dialog = StaticPopup_Show("CONFIRM_LOOT_DISTRIBUTION", ITEM_QUALITY_COLORS[pfUI.loot.selectedQuality].hex..pfUI.loot.selectedItemName..FONT_COLOR_CODE_CLOSE, GetMasterLootCandidate(index))
UIDropDownMenu_AddButton(info) if ( dialog ) then
pfUI.loot:BuildSpecialRollsMenu(UIDROPDOWNMENU_MENU_LEVEL) dialog.data = index
pfUI.loot:BuildSpecialRecipientsMenu(UIDROPDOWNMENU_MENU_LEVEL)
for order, class in ipairs(CLASS_SORT_ORDER) do
local lclass = classes_in_raid[class]
if (lclass) then
info = wipe(info)
info.text = lclass
info.textR, info.textG, info.textB = .7,.7,.7
if class and PFUI_CLASS_COLORS[class] then
info.textR, info.textG, info.textB = PFUI_CLASS_COLORS[class]:GetRGB()
end
info.textHeight = 12
info.hasArrow = 1
info.notCheckable = 1
info.value = class
info.func = nil
UIDropDownMenu_AddButton(info)
end
end
elseif level == 2 then -- players
pfUI.loot:BuildSpecialRollsMenu(UIDROPDOWNMENU_MENU_LEVEL)
pfUI.loot:BuildSpecialRecipientsMenu(UIDROPDOWNMENU_MENU_LEVEL)
local players = players_in_class[UIDROPDOWNMENU_MENU_VALUE]
if (players) and next(players) then
table.sort(players)
for _, candidate in ipairs(players) do
info = wipe(info)
info.text = candidate
info.textR, info.textG, info.textB = .7,.7,.7
if UIDROPDOWNMENU_MENU_VALUE and PFUI_CLASS_COLORS[UIDROPDOWNMENU_MENU_VALUE] then
info.textR, info.textG, info.textB = PFUI_CLASS_COLORS[UIDROPDOWNMENU_MENU_VALUE]:GetRGB()
end
info.textHeight = 12
info.value = name_to_index[candidate]
info.func = GroupLootDropDown_GiveLoot
UIDropDownMenu_AddButton(info,UIDROPDOWNMENU_MENU_LEVEL)
end
end end
else
GiveMasterLoot(pfUI.loot.selectedSlot, index)
end end
end end
function pfUI.loot:BuildPartyMenu(level) -- A party gets its candidates. A raid gets the advanced loot tools, then
local slot = pfUI.loot.selectedSlot or 0 -- a submenu of candidates per class.
if level == 1 then local function GenerateMasterLootMenu(owner, rootDescription)
for i=1, MAX_PARTY_MEMBERS+1, 1 do if not IsInRaid() then
for i=1, MAX_PARTY_MEMBERS+1 do
local candidate = GetMasterLootCandidate(i) local candidate = GetMasterLootCandidate(i)
if (candidate) then if (candidate) then
info = wipe(info)
local unit = GroupInfoByName(candidate,"party") local unit = GroupInfoByName(candidate,"party")
info.text = candidate rootDescription:CreateButton(PFUI_CLASS_COLORS[unit.class]:WrapTextInColorCode(candidate), GiveLoot, i)
info.textR, info.textG, info.textB = .7,.7,.7 end
if unit.class and PFUI_CLASS_COLORS[unit.class] then end
info.textR, info.textG, info.textB = PFUI_CLASS_COLORS[unit.class]:GetRGB() return
end end
info.textHeight = 12
info.value = i UpdateRaidCandidates()
info.func = GroupLootDropDown_GiveLoot rootDescription:CreateTitle(GIVE_LOOT)
UIDropDownMenu_AddButton(info)
if C.loot.advancedloot == "1" then
rootDescription:CreateButton(NORMAL_FONT_COLOR:WrapTextInColorCode(T["Random"]), pfUI.loot.RaidRoll, pfUI.loot.randoms)
rootDescription:CreateButton(NORMAL_FONT_COLOR:WrapTextInColorCode(T["Request Rolls"]), pfUI.loot.RequestRolls)
-- the rolls so far, highest first; a roller who can't get the item is greyed out
if pfUI.loot.monitorRolling then
rootDescription:CreateButton(NORMAL_FONT_COLOR:WrapTextInColorCode(T["Reroll Ties"]), pfUI.loot.CallTieRoll, pfUI.loot.rollers_sorted)
rootDescription:CreateButton(NORMAL_FONT_COLOR:WrapTextInColorCode(T["Clear Rolls"]), pfUI.loot.ClearRolls)
for _, roller in ipairs(pfUI.loot.rollers_sorted) do
local button = rootDescription:CreateButton(string.format("%02d - %s", roller.roll, roller.who), GiveLoot, roller.value)
button:SetEnabled(roller.value ~= "disabled")
end
end
if pfUI.loot.my_index or pfUI.loot.disenchanter_index or pfUI.loot.banker_index then
local recipients = rootDescription:CreateButton(NORMAL_FONT_COLOR:WrapTextInColorCode(T["Special Recipient"]))
if pfUI.loot.my_index then
recipients:CreateButton(T["Self"], GiveLoot, pfUI.loot.my_index)
end
if pfUI.loot.disenchanter_index then
recipients:CreateButton(T["Disenchanter"], GiveLoot, pfUI.loot.disenchanter_index)
end
if pfUI.loot.banker_index then
recipients:CreateButton(T["Banker"], GiveLoot, pfUI.loot.banker_index)
end
end
end
for _, class in ipairs(CLASS_SORT_ORDER) do
local players = pfUI.loot.players_in_class[class]
if (players) then
local color = PFUI_CLASS_COLORS[class]
local classButton = rootDescription:CreateButton(color:WrapTextInColorCode(pfUI.loot.classes_in_raid[class]))
table.sort(players)
for _, candidate in ipairs(players) do
classButton:CreateButton(color:WrapTextInColorCode(candidate), GiveLoot, pfUI.loot.name_to_index[candidate])
end end
end end
end end
end end
function pfUI.loot:InitGroupDropDown() -- Opens the menu under the clicked loot button, which owns it. The slots
local inRaid = IsInRaid() -- table is by row, not by loot slot, so after a looted item it no longer
if UIDROPDOWNMENU_MENU_LEVEL == 1 then -- lines up with selectedSlot. Opening it again closes the one shown before.
if ( inRaid ) then OpenMasterLootMenu = function()
pfUI.loot:BuildRaidMenu(UIDROPDOWNMENU_MENU_LEVEL) local slot = pfUI.loot.selectedLootButton
else local description = MenuUtil.CreateRootMenuDescription(pfUIMenuStyleMixin)
pfUI.loot:BuildPartyMenu(UIDROPDOWNMENU_MENU_LEVEL) Menu.PopulateDescription(GenerateMasterLootMenu, slot, description)
end
elseif UIDROPDOWNMENU_MENU_LEVEL == 2 and (inRaid) then masterLootMenu = Menu.GetManager():OpenMenu(slot, description, AnchorUtil.CreateAnchor("TOPLEFT", slot, "BOTTOMLEFT", 0, 0))
pfUI.loot:BuildRaidMenu(UIDROPDOWNMENU_MENU_LEVEL) if masterLootMenu then
masterLootMenu:SetClosedCallback(function() masterLootMenu = nil end)
end end
end end
-- a change to the candidates or the rolls rebuilds the menu while it is shown
RefreshMasterLootMenu = function()
if masterLootMenu then OpenMasterLootMenu() end
end
function pfUI.loot:AddMasterLootMenus() function pfUI.loot:AddMasterLootMenus()
for index,value in ipairs(UnitPopupMenus["SELF"]) do for index,value in ipairs(UnitPopupMenus["SELF"]) do
if value == "LOOT_PROMOTE" then if value == "LOOT_PROMOTE" then
@@ -386,7 +287,6 @@ pfUI:RegisterModule("loot", function ()
end end
if C.loot.advancedloot == "1" then if C.loot.advancedloot == "1" then
UIDropDownMenu_Initialize(GroupLootDropDown, pfUI.loot.InitGroupDropDown, "MENU")
for button, data in pairs(pfUI.loot.unitbuttons) do for button, data in pairs(pfUI.loot.unitbuttons) do
UnitPopupButtons[button] = { text = data[1], dist = 0} UnitPopupButtons[button] = { text = data[1], dist = 0}
end end
@@ -423,7 +323,6 @@ pfUI:RegisterModule("loot", function ()
end) end)
else else
pfUI.loot:RemoveMasterlootMenus() pfUI.loot:RemoveMasterlootMenus()
UIDropDownMenu_Initialize(GroupLootDropDown, GroupLootDropDown_Initialize, "MENU")
end end
pfUI.loot.slots = {} pfUI.loot.slots = {}
@@ -516,12 +415,11 @@ pfUI:RegisterModule("loot", function ()
local function CloseOnClick() local function CloseOnClick()
local lootbind = StaticPopup_FindVisible("LOOT_BIND") local lootbind = StaticPopup_FindVisible("LOOT_BIND")
local masterloot = UIDROPDOWNMENU_INIT_MENU and (UIDROPDOWNMENU_INIT_MENU == "GroupLootDropDown") if lootbind or masterLootMenu then else CloseLoot() end
if lootbind or masterloot then else CloseLoot() end
end end
function pfUI.loot:CreateSlot(id) function pfUI.loot:CreateSlot(id)
local frame = CreateFrame(LOOT_BUTTON_FRAME_TYPE, 'pfLootButton'..id, pfUI.loot) local frame = CreateFrame("LootButton", 'pfLootButton'..id, pfUI.loot)
frame:RegisterForClicks('LeftButtonUp', 'RightButtonUp') frame:RegisterForClicks('LeftButtonUp', 'RightButtonUp')
frame:SetPoint("LEFT", border*2, 0) frame:SetPoint("LEFT", border*2, 0)
frame:SetPoint("RIGHT", -border*2, 0) frame:SetPoint("RIGHT", -border*2, 0)
@@ -541,7 +439,7 @@ pfUI:RegisterModule("loot", function ()
StaticPopup_Hide("CONFIRM_LOOT_DISTRIBUTION") StaticPopup_Hide("CONFIRM_LOOT_DISTRIBUTION")
local numItems = GetNumLootItems() local numItems = GetNumLootItems()
pfUI.loot.selectedLootButton = this:GetName() pfUI.loot.selectedLootButton = this
pfUI.loot.selectedSlot = this:GetID() pfUI.loot.selectedSlot = this:GetID()
pfUI.loot.selectedQuality = this.quality pfUI.loot.selectedQuality = this.quality
pfUI.loot.selectedItemName = this.name:GetText() pfUI.loot.selectedItemName = this.name:GetText()
@@ -552,7 +450,7 @@ pfUI:RegisterModule("loot", function ()
LootSlot(this:GetID()) LootSlot(this:GetID())
-- workaround for bugged disenchant / container loot on some servers -- workaround for bugged disenchant / container loot on some servers
if numItems == 1 then if numItems == 1 then
QueueFunction(CloseOnClick) RunNextFrame(CloseOnClick)
end end
end) end)
@@ -632,11 +530,11 @@ pfUI:RegisterModule("loot", function ()
pfUI.loot:SetScript("OnEvent", function() pfUI.loot:SetScript("OnEvent", function()
if event == "OPEN_MASTER_LOOT_LIST" then if event == "OPEN_MASTER_LOOT_LIST" then
ToggleDropDownMenu(1, nil, GroupLootDropDown, pfUI.loot.slots[pfUI.loot.selectedSlot], 0, 0) OpenMasterLootMenu()
end end
if event == "UPDATE_MASTER_LOOT_LIST" then if event == "UPDATE_MASTER_LOOT_LIST" then
UIDropDownMenu_Refresh(GroupLootDropDown) RefreshMasterLootMenu()
end end
if event == "LOOT_OPENED" then if event == "LOOT_OPENED" then
@@ -667,7 +565,6 @@ pfUI:RegisterModule("loot", function ()
if event == "LOOT_CLOSED" then if event == "LOOT_CLOSED" then
StaticPopup_Hide("LOOT_BIND") StaticPopup_Hide("LOOT_BIND")
HideUIPanel(this) HideUIPanel(this)
if DropDownList1:IsShown() then CloseDropDownMenus() end
for _, v in pairs(this.slots) do for _, v in pairs(this.slots) do
v:Hide() v:Hide()
end end
@@ -699,7 +596,7 @@ pfUI:RegisterModule("loot", function ()
table.sort(pfUI.loot.rollers_sorted,function(a,b) table.sort(pfUI.loot.rollers_sorted,function(a,b)
return a.roll > b.roll return a.roll > b.roll
end) end)
QueueFunction(UIDropDownMenu_Refresh,GroupLootDropDown) RefreshMasterLootMenu()
end end
end end
@@ -707,7 +604,7 @@ pfUI:RegisterModule("loot", function ()
if C.loot.autopickup == "1" and GetNumPartyMembers() == 0 and GetNumRaidMembers() == 0 then if C.loot.autopickup == "1" and GetNumPartyMembers() == 0 and GetNumRaidMembers() == 0 then
if event == "LOOT_BIND_CONFIRM" then if event == "LOOT_BIND_CONFIRM" then
local slot = arg1 local slot = arg1
QueueFunction(function() RunNextFrame(function()
LootSlot(slot) LootSlot(slot)
StaticPopup_Hide("LOOT_BIND") StaticPopup_Hide("LOOT_BIND")
end) end)
@@ -722,18 +619,6 @@ pfUI:RegisterModule("loot", function ()
LootFrame:UnregisterAllEvents() LootFrame:UnregisterAllEvents()
table.insert(UISpecialFrames, "pfLootFrame") table.insert(UISpecialFrames, "pfLootFrame")
function _G.GroupLootDropDown_GiveLoot()
if ( pfUI.loot.selectedQuality >= MASTER_LOOT_THREHOLD ) then
local dialog = StaticPopup_Show("CONFIRM_LOOT_DISTRIBUTION", ITEM_QUALITY_COLORS[pfUI.loot.selectedQuality].hex..pfUI.loot.selectedItemName..FONT_COLOR_CODE_CLOSE, this:GetText())
if ( dialog ) then
dialog.data = this.value
end
else
GiveMasterLoot(pfUI.loot.selectedSlot, this.value)
end
CloseDropDownMenus()
end
StaticPopupDialogs["CONFIRM_LOOT_DISTRIBUTION"].OnAccept = function(data) StaticPopupDialogs["CONFIRM_LOOT_DISTRIBUTION"].OnAccept = function(data)
GiveMasterLoot(pfUI.loot.selectedSlot, data) GiveMasterLoot(pfUI.loot.selectedSlot, data)
end end
+82 -134
View File
@@ -1,9 +1,9 @@
pfUI:RegisterModule("loothistory", function () pfUI:RegisterModule("loothistory", function ()
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
-- Layout -- Layout (rows are 2px apart)
local ITEM_H, PLAYER_H = 24, 18 local ITEM_H, PLAYER_H = 24, 16
local ITEM_W, PLAYER_W = 350, 330 local PLAYER_INDENT = 18
-- rollType constants returned by C_LootHistory.GetPlayerInfo (0/1/2; vanilla -- rollType constants returned by C_LootHistory.GetPlayerInfo (0/1/2; vanilla
-- has no disenchant roll). -- has no disenchant roll).
@@ -16,12 +16,6 @@ pfUI:RegisterModule("loothistory", function ()
local WINMARK = "Interface\\Buttons\\UI-CheckBox-Check" local WINMARK = "Interface\\Buttons\\UI-CheckBox-Check"
local QUESTIONMARK = "Interface\\Icons\\INV_Misc_QuestionMark" local QUESTIONMARK = "Interface\\Icons\\INV_Misc_QuestionMark"
local function ClassColor(class)
local c = class and RAID_CLASS_COLORS[class]
if c then return c.r, c.g, c.b end
return 1, 1, 1
end
-- Paint an item row's icon/name/quality from a loaded Item mixin. -- Paint an item row's icon/name/quality from a loaded Item mixin.
local function RenderItemVisual(f, item) local function RenderItemVisual(f, item)
local r, g, b = 1, 1, 1 local r, g, b = 1, 1, 1
@@ -92,31 +86,24 @@ pfUI:RegisterModule("loothistory", function ()
pfUI.loothistory.clear:SetText(T["Clear"]) pfUI.loothistory.clear:SetText(T["Clear"])
pfUI.loothistory.clear:SetScript("OnClick", function() C_LootHistory.Clear() end) pfUI.loothistory.clear:SetScript("OnClick", function() C_LootHistory.Clear() end)
-- scroll frame -- ==========================================================================
pfUI.loothistory.scroll = CreateScrollFrame("pfLootHistoryScroll", pfUI.loothistory) -- List: a row per item and, under an expanded item, a row per player
pfUI.loothistory.scroll:SetSize(360, 440) -- ==========================================================================
pfUI.loothistory.scroll:SetPoint("BOTTOM", 0, 10) local list = CreateFrame("Frame", "pfLootHistoryList", pfUI.loothistory, "pfUIScrollBoxListTemplate")
list:SetSize(370, 450)
pfUI.loothistory.scroll.backdrop = CreateFrame("Frame", nil, pfUI.loothistory.scroll) list:SetPoint("BOTTOM", 0, 5)
pfUI.loothistory.scroll.backdrop:SetFrameLevel(1) CreateBackdrop(list, nil, true)
pfUI.loothistory.scroll.backdrop:SetPoint("TOPLEFT", pfUI.loothistory.scroll, "TOPLEFT", -5, 5)
pfUI.loothistory.scroll.backdrop:SetPoint("BOTTOMRIGHT", pfUI.loothistory.scroll, "BOTTOMRIGHT", 5, -5)
CreateBackdrop(pfUI.loothistory.scroll.backdrop, nil, true)
local list = CreateScrollChild("pfLootHistoryList", pfUI.loothistory.scroll)
pfUI.loothistory.list = list pfUI.loothistory.list = list
-- ==========================================================================
-- Frame pools
-- ==========================================================================
local itemFrames = {}
local usedPlayers, freePlayers = {}, {}
local FullUpdate -- forward declaration (toggle handlers call it) local FullUpdate -- forward declaration (toggle handlers call it)
local function CreateItemFrame() local function ToggleExpanded(f)
local f = CreateFrame("Button", nil, list) local id = f.rollID
f:SetSize(ITEM_W, ITEM_H) if id then expanded[id] = not expanded[id]; FullUpdate() end
end
-- one-time setup of a pooled item row
local function SetupItemRow(f)
f:SetBackdrop(pfUI.backdrop_hover) f:SetBackdrop(pfUI.backdrop_hover)
f:SetBackdropBorderColor(1, 1, 1, .04) f:SetBackdropBorderColor(1, 1, 1, .04)
f:EnableMouse(1) f:EnableMouse(1)
@@ -125,10 +112,7 @@ pfUI:RegisterModule("loothistory", function ()
f.toggle = CreateFrame("Button", nil, f) f.toggle = CreateFrame("Button", nil, f)
f.toggle:SetSize(14, 14) f.toggle:SetSize(14, 14)
f.toggle:SetPoint("LEFT", 4, 0) f.toggle:SetPoint("LEFT", 4, 0)
f.toggle:SetScript("OnClick", function() f.toggle:SetScript("OnClick", function() ToggleExpanded(f) end)
local id = f.rollID
if id then expanded[id] = not expanded[id]; FullUpdate() end
end)
-- icon + quality-colored border -- icon + quality-colored border
f.iconbg = CreateFrame("Frame", nil, f) f.iconbg = CreateFrame("Frame", nil, f)
@@ -145,18 +129,18 @@ pfUI:RegisterModule("loothistory", function ()
f.winicon:SetSize(14, 14) f.winicon:SetSize(14, 14)
f.winicon:SetPoint("RIGHT", f, "RIGHT", -6, 0) f.winicon:SetPoint("RIGHT", f, "RIGHT", -6, 0)
f.winroll = f:CreateFontString("Status", "OVERLAY", "GameFontNormal") f.winroll = f:CreateFontString(nil, "OVERLAY", "GameFontNormal")
f.winroll:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") f.winroll:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.winroll:SetPoint("RIGHT", f.winicon, "LEFT", -2, 0) f.winroll:SetPoint("RIGHT", f.winicon, "LEFT", -2, 0)
f.winroll:SetTextColor(1, 1, 1, 1) f.winroll:SetTextColor(1, 1, 1, 1)
f.winname = f:CreateFontString("Status", "OVERLAY", "GameFontNormal") f.winname = f:CreateFontString(nil, "OVERLAY", "GameFontNormal")
f.winname:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") f.winname:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.winname:SetPoint("RIGHT", f.winroll, "LEFT", -4, 0) f.winname:SetPoint("RIGHT", f.winroll, "LEFT", -4, 0)
f.winname:SetJustifyH("RIGHT") f.winname:SetJustifyH("RIGHT")
-- item name (leaves room on the right for the winner block) -- item name (leaves room on the right for the winner block)
f.name = f:CreateFontString("Status", "OVERLAY", "GameFontNormal") f.name = f:CreateFontString(nil, "OVERLAY", "GameFontNormal")
f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.name:SetPoint("LEFT", f.iconbg, "RIGHT", 5, 0) f.name:SetPoint("LEFT", f.iconbg, "RIGHT", 5, 0)
f.name:SetPoint("RIGHT", f, "RIGHT", -100, 0) f.name:SetPoint("RIGHT", f, "RIGHT", -100, 0)
@@ -174,20 +158,13 @@ pfUI:RegisterModule("loothistory", function ()
this:SetBackdropBorderColor(1, 1, 1, .04) this:SetBackdropBorderColor(1, 1, 1, .04)
GameTooltip:Hide() GameTooltip:Hide()
end) end)
f:SetScript("OnClick", function() f:SetScript("OnClick", function() ToggleExpanded(f) end)
local id = this.rollID
if id then expanded[id] = not expanded[id]; FullUpdate() end
end)
return f
end end
local function CreatePlayerFrame() -- one-time setup of a pooled player row
local f = CreateFrame("Frame", nil, list) local function SetupPlayerRow(f)
f:SetSize(PLAYER_W, PLAYER_H)
-- name is indented to leave room for the winner checkmark on its left -- name is indented to leave room for the winner checkmark on its left
f.name = f:CreateFontString("Status", "OVERLAY", "GameFontNormal") f.name = f:CreateFontString(nil, "OVERLAY", "GameFontNormal")
f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") f.name:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.name:SetPoint("LEFT", 20, 0) f.name:SetPoint("LEFT", 20, 0)
f.name:SetJustifyH("LEFT") f.name:SetJustifyH("LEFT")
@@ -196,7 +173,7 @@ pfUI:RegisterModule("loothistory", function ()
f.rollicon:SetSize(16, 16) f.rollicon:SetSize(16, 16)
f.rollicon:SetPoint("RIGHT", -4, 0) f.rollicon:SetPoint("RIGHT", -4, 0)
f.rolltext = f:CreateFontString("Status", "OVERLAY", "GameFontNormal") f.rolltext = f:CreateFontString(nil, "OVERLAY", "GameFontNormal")
f.rolltext:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") f.rolltext:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
f.rolltext:SetPoint("RIGHT", f.rollicon, "LEFT", -3, 0) f.rolltext:SetPoint("RIGHT", f.rollicon, "LEFT", -3, 0)
f.rolltext:SetTextColor(1, 1, 1, 1) f.rolltext:SetTextColor(1, 1, 1, 1)
@@ -206,23 +183,6 @@ pfUI:RegisterModule("loothistory", function ()
f.winmark:SetSize(16, 16) f.winmark:SetSize(16, 16)
f.winmark:SetTexture(WINMARK) f.winmark:SetTexture(WINMARK)
f.winmark:SetPoint("RIGHT", f.name, "LEFT", -1, 0) f.winmark:SetPoint("RIGHT", f.name, "LEFT", -1, 0)
return f
end
local function RecycleAllPlayers()
for i = 1, table.getn(usedPlayers) do
local pf = usedPlayers[i]
pf:Hide()
table.insert(freePlayers, pf)
end
usedPlayers = {}
end
local function GetPlayerFrame()
local pf = table.remove(freePlayers) or CreatePlayerFrame()
table.insert(usedPlayers, pf)
return pf
end end
local function SetToggleTexture(toggle, isExpanded) local function SetToggleTexture(toggle, isExpanded)
@@ -238,34 +198,28 @@ pfUI:RegisterModule("loothistory", function ()
-- ========================================================================== -- ==========================================================================
-- Rendering -- Rendering
-- ========================================================================== -- ==========================================================================
local function UpdateItemFrame(f, i) local function InitItemRow(f, row)
local rollID, itemLink, numPlayers, isDone, winnerIdx = C_LootHistory.GetItem(i) if not f.toggle then SetupItemRow(f) end
local i = row.item
local rollID, itemLink, _, isDone, winnerIdx = C_LootHistory.GetItem(i)
f.rollID = rollID f.rollID = rollID
f.itemIdx = i
f.itemLink = itemLink f.itemLink = itemLink
f.numPlayers = numPlayers or 0
f.isDone = isDone
local isExpanded = rollID and expanded[rollID] local isExpanded = rollID and expanded[rollID]
SetToggleTexture(f.toggle, isExpanded) SetToggleTexture(f.toggle, isExpanded)
-- Item icon/name/quality via the ClassicAPI Item mixin. When the item -- Item icon/name/quality via the ClassicAPI Item mixin. The row shows a
-- isn't cached yet, show a placeholder and re-paint this row from the -- placeholder until ContinueOnItemLoad paints it, which happens at once
-- ContinueOnItemLoad callback (guarded on rollID: rows are pooled, so the -- when the item is cached (guarded on rollID: rows are pooled, so the
-- callback must no-op if the row has since been reused for another roll). -- callback must no-op if the row has since been reused for another roll).
local item = itemLink and Item:CreateFromItemLink(itemLink) ShowRetrieving(f)
if item and not item:IsItemEmpty() then if itemLink then
if item:IsItemDataCached() then local item = Item:CreateFromItemLink(itemLink)
RenderItemVisual(f, item) local pending = rollID
else item:ContinueOnItemLoad(function()
ShowRetrieving(f) if f.rollID == pending then RenderItemVisual(f, item) end
local pending = rollID end)
item:ContinueOnItemLoad(function()
if f.rollID == pending then RenderItemVisual(f, item) end
end)
end
else
ShowRetrieving(f)
end end
-- winner summary only on a decided, collapsed row -- winner summary only on a decided, collapsed row
@@ -277,7 +231,7 @@ pfUI:RegisterModule("loothistory", function ()
if wroll and wroll > 0 then f.winroll:SetText(wroll) else f.winroll:SetText("") end if wroll and wroll > 0 then f.winroll:SetText(wroll) else f.winroll:SetText("") end
f.winroll:Show() f.winroll:Show()
f.winname:SetText(wname or UNKNOWN) f.winname:SetText(wname or UNKNOWN)
f.winname:SetTextColor(ClassColor(wclass)) f.winname:SetTextColor(PFUI_CLASS_COLORS[wclass]:GetRGB())
f.winname:Show() f.winname:Show()
else else
-- nobody won: everyone passed -- nobody won: everyone passed
@@ -296,16 +250,35 @@ pfUI:RegisterModule("loothistory", function ()
end end
end end
local function RenderPlayerFrame(pf, name, class, rollType, roll, isWinner) local function InitPlayerRow(pf, row)
if not pf.name then SetupPlayerRow(pf) end
local name, class, rollType, roll, isWinner = C_LootHistory.GetPlayerInfo(row.item, row.player)
pf.name:SetText(name or UNKNOWN) pf.name:SetText(name or UNKNOWN)
pf.name:SetTextColor(ClassColor(class)) pf.name:SetTextColor(PFUI_CLASS_COLORS[class]:GetRGB())
pf.rollicon:SetTexture(ROLL_TEX[rollType] or ROLL_TEX[ROLL_PASS]) pf.rollicon:SetTexture(ROLL_TEX[rollType] or ROLL_TEX[ROLL_PASS])
if roll and roll > 0 then pf.rolltext:SetText(roll) else pf.rolltext:SetText("") end if roll and roll > 0 then pf.rolltext:SetText(roll) else pf.rolltext:SetText("") end
if isWinner then pf.winmark:Show() else pf.winmark:Hide() end pf.winmark:SetShown(isWinner)
end end
local view = CreateScrollBoxListLinearView(2, 2, 4, 4, 2)
view:SetElementFactory(function(factory, row)
if row.player then
factory("Frame", InitPlayerRow)
else
factory("Button", InitItemRow)
end
end)
view:SetElementExtentCalculator(function(_, row)
return row.player and PLAYER_H or ITEM_H
end)
view:SetElementIndentCalculator(function(row)
return row.player and PLAYER_INDENT or 0
end)
ScrollUtil.InitScrollBoxListWithScrollBar(list.ScrollBox, list.ScrollBar, view)
-- A player row is worth showing while the roll is undecided (see everyone), -- A player row is worth showing while the roll is undecided (see everyone),
-- or afterwards only if they actually rolled or it's you (hide the passers' -- or afterwards only if they actually rolled or it's you (hide the passers'
-- noise on a decided roll) — mirrors Blizzard's ShouldDisplayPlayer. -- noise on a decided roll) — mirrors Blizzard's ShouldDisplayPlayer.
@@ -315,46 +288,23 @@ pfUI:RegisterModule("loothistory", function ()
function FullUpdate() function FullUpdate()
if not pfUI.loothistory:IsShown() then return end if not pfUI.loothistory:IsShown() then return end
RecycleAllPlayers()
local num = C_LootHistory.GetNumItems() local rows = {}
local y = -2 for i = 1, C_LootHistory.GetNumItems() do
local rollID, _, numPlayers, isDone = C_LootHistory.GetItem(i)
table.insert(rows, { item = i })
for i = 1, num do if rollID and expanded[rollID] then
local f = itemFrames[i] or CreateItemFrame() for p = 1, numPlayers or 0 do
itemFrames[i] = f local _, _, _, roll, _, isMe = C_LootHistory.GetPlayerInfo(i, p)
UpdateItemFrame(f, i) if ShouldDisplayPlayer(isDone, roll, isMe) then
f:ClearAllPoints() table.insert(rows, { item = i, player = p })
f:SetPoint("TOPLEFT", list, "TOPLEFT", 4, y)
f:Show()
y = y - ITEM_H - 2
if f.rollID and expanded[f.rollID] then
for p = 1, f.numPlayers do
local name, class, rollType, roll, isWinner, isMe = C_LootHistory.GetPlayerInfo(i, p)
if ShouldDisplayPlayer(f.isDone, roll, isMe) then
local pf = GetPlayerFrame()
RenderPlayerFrame(pf, name, class, rollType, roll, isWinner)
pf:ClearAllPoints()
pf:SetPoint("TOPLEFT", list, "TOPLEFT", 22, y)
pf:Show()
y = y - PLAYER_H
end end
end end
y = y - 2
end end
end end
for i = num + 1, table.getn(itemFrames) do list.ScrollBox:SetDataProvider(CreateDataProvider(rows), ScrollBoxConstants.RetainScrollPosition)
itemFrames[i]:Hide()
end
-- Resize the scroll child and re-attach it: SetHeight alone on a
-- SetAllPoints'd child doesn't make the ScrollFrame recompute its scroll
-- range, so a dynamically-grown list wouldn't scroll until a /reload.
list:SetHeight(math.max(1, -y + 2))
pfUI.loothistory.scroll:SetScrollChild(list)
pfUI.loothistory.scroll:UpdateScrollState()
end end
pfUI.loothistory:SetScript("OnShow", function() FullUpdate() end) pfUI.loothistory:SetScript("OnShow", function() FullUpdate() end)
@@ -362,20 +312,18 @@ pfUI:RegisterModule("loothistory", function ()
-- ========================================================================== -- ==========================================================================
-- Events -- Events
-- ========================================================================== -- ==========================================================================
local events = CreateFrame("Frame") -- auto-show on a new roll opening / completing, if enabled
events:RegisterEvent("LOOT_HISTORY_FULL_UPDATE") local function AutoShow()
events:RegisterEvent("LOOT_HISTORY_ROLL_CHANGED") if C.loothistory.autoshow == "1" and not pfUI.loothistory:IsShown() then
events:RegisterEvent("LOOT_HISTORY_ROLL_COMPLETE")
events:SetScript("OnEvent", function()
-- auto-show on a new roll opening / completing, if enabled
if C.loothistory.autoshow == "1"
and (event == "LOOT_HISTORY_FULL_UPDATE" or event == "LOOT_HISTORY_ROLL_COMPLETE")
and not pfUI.loothistory:IsShown() then
pfUI.loothistory:Show() -- OnShow runs FullUpdate pfUI.loothistory:Show() -- OnShow runs FullUpdate
return return
end end
FullUpdate() -- no-op while hidden FullUpdate() -- no-op while hidden
end) end
pfUI.events:RegisterFrameEventAndCallback("LOOT_HISTORY_FULL_UPDATE", AutoShow)
pfUI.events:RegisterFrameEventAndCallback("LOOT_HISTORY_ROLL_COMPLETE", AutoShow)
pfUI.events:RegisterFrameEventAndCallback("LOOT_HISTORY_ROLL_CHANGED", FullUpdate)
-- ========================================================================== -- ==========================================================================
-- Slash command -- Slash command
+88
View File
@@ -0,0 +1,88 @@
pfUI:RegisterModule("lossofcontrol", function ()
-- 5.x's loss of control alert. ClassicAPI's C_LossOfControl builds the
-- effects from the player's debuffs and from the school lockout of an
-- interrupt.
local strings = L["lossofcontrol"]
-- how much each effect takes away; the alert shows the strongest one
local PRIORITY = {
STUN = 3, FEAR = 3, CONFUSE = 3, CHARM = 3, POSSESS = 3, PACIFYSILENCE = 3,
SILENCE = 2, SCHOOL_INTERRUPT = 2, PACIFY = 2,
DISARM = 1, ROOT = 1,
}
-- the lockout packet does not name the interrupting spell
local INTERRUPT_ICON = "Interface\\Icons\\Ability_Kick"
local function IsStronger(data, best)
local priority, bestPriority = PRIORITY[data.locType], PRIORITY[best.locType]
if priority ~= bestPriority then return priority > bestPriority end
return (data.timeRemaining or math.huge) > (best.timeRemaining or math.huge)
end
local frame = CreateFrame("Frame", "pfLossOfControl", UIParent)
frame:SetSize(220, 48)
frame:SetPoint("CENTER", 0, 120)
frame:SetFrameStrata("HIGH")
frame:Hide()
frame.icon = CreateFrame("Frame", nil, frame)
frame.icon:SetSize(48, 48)
frame.icon:SetPoint("LEFT", 0, 0)
CreateBackdrop(frame.icon, nil, true)
frame.icon.tex = frame.icon:CreateTexture(nil, "ARTWORK")
HandleIcon(frame.icon, frame.icon.tex)
frame.cd = CreateCooldown(frame.icon, "lossofcontrol")
frame.cd:SetAllPoints(frame.icon.tex)
frame.label = frame:CreateFontString(nil, "OVERLAY")
frame.label:SetFont(pfUI.font_default, 20, "OUTLINE")
frame.label:SetTextColor(NORMAL_FONT_COLOR:GetRGB())
frame.label:SetPoint("LEFT", frame.icon, "RIGHT", 8, 0)
frame.Refresh = function(self)
local best
for i = 1, C_LossOfControl.GetActiveLossOfControlDataCount() do
local data = C_LossOfControl.GetActiveLossOfControlData(i)
if not best or IsStronger(data, best) then best = data end
end
if not best then
if pfUI.unlock and pfUI.unlock:IsShown() then return end
self:Hide()
return
end
if best.locType == "SCHOOL_INTERRUPT" then
self.label:SetText(format(strings.LOSS_OF_CONTROL_DISPLAY_INTERRUPT_SCHOOL, C_Spell.GetSchoolString(best.lockoutSchool)))
self.icon.tex:SetTexture(INTERRUPT_ICON)
else
self.label:SetText(strings["LOSS_OF_CONTROL_DISPLAY_" .. best.locType])
self.icon.tex:SetTexture(best.iconTexture)
end
CooldownFrame_SetTimer(self.cd, best.startTime or 0, best.duration or 0, best.startTime and 1 or 0)
self:Show()
end
-- a refreshed debuff (UNIT_AURA_DELTA) or a second kick on the same school
-- (SPELL_UPDATE_COOLDOWN) changes the timer without a loss of control event
frame:SetScript("OnShow", function()
this:RegisterUnitEvent("UNIT_AURA_DELTA", "player")
this:RegisterEvent("SPELL_UPDATE_COOLDOWN")
end)
frame:SetScript("OnHide", function()
this:UnregisterAllEvents()
end)
frame:SetScript("OnEvent", function()
this:Refresh()
end)
pfUI.events:RegisterFrameEventAndCallback("LOSS_OF_CONTROL_ADDED", function() frame:Refresh() end)
pfUI.events:RegisterFrameEventAndCallback("LOSS_OF_CONTROL_UPDATE", function() frame:Refresh() end)
UpdateMovable(frame)
pfUI.lossofcontrol = frame
end)
+128
View File
@@ -0,0 +1,128 @@
-- Macro icon picker
-- Replaces Blizzard's MacroPopupFrame (the "name + icon" dialog opened by the
-- New / Change-Icon buttons) with a pfUI-native picker driven by
-- IconDataProviderMixin, so the full spell + item + loose icon set is
-- available instead of the stock spell-only list. Saving goes through
-- C_Macro.CreateMacro / C_Macro.EditMacro, which take the icon as a texture
-- string -- so arbitrary icons (including index-less INV_* item icons) persist
-- on both the modern (Turtle/Octo) and stock-vanilla macro UIs. The surrounding
-- MacroFrame (list + body editor) is Blizzard's, already skinned elsewhere.
pfUI:RegisterModule("macroicons", function ()
HookAddon("Blizzard_MacroUI", function()
-- ============================================================
-- Popup frame
-- ============================================================
local picker = CreateFrame("Frame", "pfMacroIconPicker", UIParent)
picker:SetFrameStrata("DIALOG")
picker:SetSize(472, 484)
-- Starts anchored to the right of the macro panel (re-anchored at open
-- once the skin's backdrop exists); dragging pins it in place after.
picker:SetPoint("BOTTOMLEFT", MacroFrame, "BOTTOMRIGHT", 8, 0)
picker:Hide()
CreateBackdrop(picker, nil, nil, .9)
CreateBackdropShadow(picker)
picker:EnableMouse(true)
picker:SetMovable(true)
picker:RegisterForDrag("LeftButton")
picker:SetScript("OnDragStart", function() this:StartMoving() end)
picker:SetScript("OnDragStop", function()
this:StopMovingOrSizing()
this.userMoved = true
end)
-- Spellbook seed leads the grid with class-relevant spell/talent icons.
local iconPicker = CreateIconPicker("pfMacroIcon", picker,
IconDataProviderExtraType.Spellbook, MACRO_POPUP_TEXT)
-- ============================================================
-- Open / save
-- ============================================================
-- Blizzard's popup disables these while it is open; mirror that so the
-- underlying frame can't be double-driven, then let MacroFrame_Update
-- restore the correct states on close.
local function SetMacroButtons(enabled)
local m = enabled and "Enable" or "Disable"
MacroNewButton[m](MacroNewButton)
MacroEditButton[m](MacroEditButton)
MacroDeleteButton[m](MacroDeleteButton)
end
local function OpenMacroPopup(mode)
if mode == "edit" and MacroFrame.selectedMacro then
picker.mode = "edit"
local name, texture = GetMacroInfo(MacroFrame.selectedMacro)
picker.editbox:SetText(name or "")
iconPicker.SetIcon(texture)
else
picker.mode = "new"
picker.editbox:SetText("")
iconPicker.SetIcon(nil)
end
picker.search:SetText("")
if not picker.userMoved then
picker:ClearAllPoints()
picker:SetPoint("BOTTOMLEFT", MacroFrame.backdrop or MacroFrame, "BOTTOMRIGHT", 8, 0)
end
SetMacroButtons(false)
picker:Show()
picker.editbox:SetFocus()
iconPicker.Refresh()
end
local function SaveMacroPopup()
local text = picker.editbox:GetText()
if text == "" then return end
local icon = iconPicker.GetIcon()
if picker.mode == "edit" and MacroFrame.selectedMacro then
C_Macro.EditMacro(MacroFrame.selectedMacro, text, icon, nil)
MacroFrame_SelectMacro(MacroFrame.selectedMacro)
else
local idx = C_Macro.CreateMacro(text, icon, nil, (MacroFrame.macroBase or 0) > 0)
if idx then MacroFrame_SelectMacro(idx) end
end
picker:Hide()
end
picker:SetScript("OnHide", function() MacroFrame_Update() end)
picker.editbox:SetScript("OnEnterPressed", SaveMacroPopup)
picker.editbox:SetScript("OnEscapePressed", function() picker:Hide() end)
-- OK / Cancel
local okay = CreateFrame("Button", "pfMacroIconPickerOkay", picker, "UIPanelButtonTemplate")
okay:SetSize(80, 22)
okay:SetText(OKAY)
okay:SetScript("OnClick", SaveMacroPopup)
SkinButton(okay)
local cancel = CreateFrame("Button", "pfMacroIconPickerCancel", picker, "UIPanelButtonTemplate")
cancel:SetSize(80, 22)
cancel:SetText(CANCEL)
cancel:SetPoint("BOTTOMRIGHT", picker, "BOTTOMRIGHT", -14, 12)
cancel:SetScript("OnClick", function() picker:Hide() end)
SkinButton(cancel)
-- Okay | Cancel, both anchored to the bottom-right corner.
okay:SetPoint("BOTTOMRIGHT", cancel, "BOTTOMLEFT", -6, 0)
-- ============================================================
-- Take over the New / Change-Icon buttons; retire Blizzard's popup
-- ============================================================
MacroNewButton:SetScript("OnClick", function()
MacroFrame_SaveMacro()
OpenMacroPopup("new")
end)
MacroEditButton:SetScript("OnClick", function()
MacroFrame_SaveMacro()
OpenMacroPopup("edit")
end)
-- Closing the macro window takes the picker with it.
MacroFrame:HookScript("OnHide", function() picker:Hide() end)
end)
end)
-66
View File
@@ -1,66 +0,0 @@
pfUI:RegisterModule("macrotweak", function ()
local conflictAddons = { "Supermacro", "SuperCleveRoidMacros", "UltimaMacros" }
local disabled = false
for _, addon in pairs(conflictAddons) do
local name = addon
EventUtil.ContinueOnAddOnLoaded(name, function()
if not disabled then
DEFAULT_CHAT_FRAME:AddMessage("|cff33ffccpfUI|r: " .. name .. " found, macrotweak disabled.")
end
disabled = true
end)
end
-- do not write macro calls into chat input history
if ChatFrameEditBox._AddHistoryLine then
local userinput
ChatFrameEditBox._AddHistoryLine = ChatFrameEditBox.AddHistoryLine
ChatFrameEditBox.AddHistoryLine = function(self, text)
if disabled then return ChatFrameEditBox._AddHistoryLine(self, text) end
if not userinput and text and string.find(text, "^/run(.+)") then return end
if not userinput and string.find(text, "^/script(.+)") then return end
if not userinput and string.find(text, "^/cast(.+)") then return end
ChatFrameEditBox._AddHistoryLine(self, text)
end
local OnEnter = ChatFrameEditBox:GetScript("OnEnterPressed")
ChatFrameEditBox:SetScript("OnEnterPressed", function(a1,a2,a3,a4)
userinput = true
OnEnter(a1,a2,a3,a4)
userinput = nil
end)
end
-- make sure #showtooltip inside macros won't be sent
local hookSendChatMessage = SendChatMessage
function _G.SendChatMessage(msg, ...)
if disabled then return hookSendChatMessage(msg, unpack(arg)) end
if msg and string.find(msg, "^#showtooltip ") then return end
hookSendChatMessage(msg, unpack(arg))
end
-- add /use and /equip to the macro api:
-- https://wowwiki.fandom.com/wiki/Making_a_macro
-- supported arguments:
-- /use <itemname>
-- /use <inventory slot>
-- /use <bag> <slot>
pfUI.api.RegisterSlashCommand("PFUSE", { "/equip" , "/use", "/pfequip", "/pfuse" }, function (msg)
if not msg or msg == "" then return end
local bag, slot, _
if string.find(msg, "%d+%s+%d+") then
_, _, bag, slot = string.find(msg, "(%d+)%s+(%d+)")
elseif string.find(msg, "%d+") then
_, _, slot = string.find(msg, "(%d+)")
else
bag, slot = FindItem(msg)
end
if bag and slot then
UseContainerItem(bag, slot)
elseif not bag and slot then
UseInventoryItem(slot)
end
end)
end)
+22 -19
View File
@@ -25,11 +25,7 @@ pfUI:RegisterModule("map", function ()
pfUI.map = { UpdateConfig = UpdateTooltipScale } pfUI.map = { UpdateConfig = UpdateTooltipScale }
function _G.ToggleWorldMap() function _G.ToggleWorldMap()
if WorldMapFrame:IsShown() then WorldMapFrame:SetShown(not WorldMapFrame:IsShown())
WorldMapFrame:Hide()
else
WorldMapFrame:Show()
end
end end
C.position["WorldMapFrame"] = C.position["WorldMapFrame"] or { alpha = 1.0, scale = 0.7 } C.position["WorldMapFrame"] = C.position["WorldMapFrame"] or { alpha = 1.0, scale = 0.7 }
@@ -37,6 +33,10 @@ pfUI:RegisterModule("map", function ()
local alpha = C.position["WorldMapFrame"].alpha local alpha = C.position["WorldMapFrame"].alpha
local scale = C.position["WorldMapFrame"].scale local scale = C.position["WorldMapFrame"].scale
-- the hooks go on once, however often the loader runs: turtle-wow.lua also
-- calls it, outside of an event
local hooked
local pfMapLoader = CreateFrame("Frame") local pfMapLoader = CreateFrame("Frame")
pfMapLoader:RegisterEvent("PLAYER_ENTERING_WORLD") pfMapLoader:RegisterEvent("PLAYER_ENTERING_WORLD")
pfMapLoader:SetScript("OnEvent", function() pfMapLoader:SetScript("OnEvent", function()
@@ -50,9 +50,8 @@ pfUI:RegisterModule("map", function ()
WorldMapFrame:EnableMouse(true) WorldMapFrame:EnableMouse(true)
WorldMapFrame:RegisterForDrag("LeftButton") WorldMapFrame:RegisterForDrag("LeftButton")
-- make sure the hooks get only applied once if not hooked then
if not this.hooked then hooked = true
this.hooked = true
WorldMapFrame:HookScript("OnShow", function() WorldMapFrame:HookScript("OnShow", function()
-- customize -- customize
@@ -68,20 +67,26 @@ pfUI:RegisterModule("map", function ()
WorldMapFrame:HookScript("OnMouseWheel", function() WorldMapFrame:HookScript("OnMouseWheel", function()
if IsShiftKeyDown() then if IsShiftKeyDown() then
alpha = clamp(WorldMapFrame:GetAlpha() + arg1/10, 0.1, 1.0) alpha = Clamp(WorldMapFrame:GetAlpha() + arg1/10, 0.1, 1.0)
WorldMapFrame:SetAlpha(alpha) WorldMapFrame:SetAlpha(alpha)
end end
if IsControlKeyDown() then if IsControlKeyDown() then
local oldscale = WorldMapFrame:GetScale() local oldscale = WorldMapFrame:GetScale()
local point, rel, relpoint, offx, offy = WorldMapFrame:GetPoint() local point, rel, relpoint, offx, offy = WorldMapFrame:GetPoint()
scale = clamp(oldscale + arg1/10, 0.1, 2.0) scale = Clamp(oldscale + arg1/10, 0.1, 2.0)
-- recalculate world frame position based on old and new scale -- recalculate world frame position based on old and new scale
if point == "TOPLEFT" and relpoint == "TOPLEFT" then if point == "TOPLEFT" and relpoint == "TOPLEFT" then
offx = offx*oldscale/scale offx = offx*oldscale/scale
offy = offy*oldscale/scale offy = offy*oldscale/scale
WorldMapFrame:SetPoint(point, rel, relpoint, offx, offy) -- Anchor to the parent (3-arg SetPoint) rather than re-using the frame
-- GetPoint handed back. Re-anchoring to `rel` throws
-- "<unnamed> is dependent on this" as soon as anything else has anchored
-- itself to WorldMapFrame, which aborts the whole zoom handler. The
-- parent-relative form is also what LoadMovable/SaveMovable already
-- assume: SaveMovable stores only xpos/ypos, with no relative frame.
WorldMapFrame:SetPoint(point, offx, offy)
end end
WorldMapFrame:SetScale(scale) WorldMapFrame:SetScale(scale)
@@ -107,8 +112,8 @@ pfUI:RegisterModule("map", function ()
WorldMapFrame:ClearAllPoints() WorldMapFrame:ClearAllPoints()
WorldMapFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 0) WorldMapFrame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
WorldMapFrame:SetWidth(WorldMapButton:GetWidth() + 15) local wmWidth, wmHeight = WorldMapButton:GetSize()
WorldMapFrame:SetHeight(WorldMapButton:GetHeight() + 55) WorldMapFrame:SetSize(wmWidth + 15, wmHeight + 55)
LoadMovable(WorldMapFrame) LoadMovable(WorldMapFrame)
-- skin -- skin
@@ -130,8 +135,7 @@ pfUI:RegisterModule("map", function ()
btn:SetHighlightTexture("") btn:SetHighlightTexture("")
btn.text = _G["pfUI_map_autozoneswitchText"] btn.text = _G["pfUI_map_autozoneswitchText"]
CreateBackdrop(btn, nil, true) CreateBackdrop(btn, nil, true)
btn:SetWidth(14) btn:SetSize(14, 14)
btn:SetHeight(14)
btn:SetPoint("RIGHT", WorldMapContinentDropDown, "LEFT", -8, 2) btn:SetPoint("RIGHT", WorldMapContinentDropDown, "LEFT", -8, 2)
btn.text:ClearAllPoints() btn.text:ClearAllPoints()
btn.text:SetPoint("RIGHT", btn, "LEFT", -4, 1) btn.text:SetPoint("RIGHT", btn, "LEFT", -4, 1)
@@ -169,8 +173,7 @@ pfUI:RegisterModule("map", function ()
WorldMapButton.coords.text:SetJustifyH("RIGHT") WorldMapButton.coords.text:SetJustifyH("RIGHT")
WorldMapButton.coords:SetScript("OnUpdate", function() WorldMapButton.coords:SetScript("OnUpdate", function()
local width = WorldMapButton:GetWidth() local width, height = WorldMapButton:GetSize()
local height = WorldMapButton:GetHeight()
local mx, my = WorldMapButton:GetCenter() local mx, my = WorldMapButton:GetCenter()
local scale = WorldMapButton:GetEffectiveScale() local scale = WorldMapButton:GetEffectiveScale()
local x, y = GetCursorPosition() local x, y = GetCursorPosition()
@@ -180,8 +183,8 @@ pfUI:RegisterModule("map", function ()
my = (( my + height / 2 ) - ( y / scale )) / height * 100 my = (( my + height / 2 ) - ( y / scale )) / height * 100
end end
if mx and my and MouseIsOver(WorldMapButton) then if mx and my and WorldMapButton:IsMouseOver() then
WorldMapButton.coords.text:SetText(string.format('%.1f / %.1f', mx, my)) WorldMapButton.coords.text:SetFormattedText('%.1f / %.1f', mx, my)
else else
WorldMapButton.coords.text:SetText("") WorldMapButton.coords.text:SetText("")
end end
+5 -5
View File
@@ -85,7 +85,7 @@ pfUI:RegisterModule("mapcolors", function ()
end end
local function ColorizeName(frame) local function ColorizeName(frame)
local _, class = UnitClass(frame.unit) local class = UnitClassBase(frame.unit)
local color = PFUI_CLASS_COLORS[class] local color = PFUI_CLASS_COLORS[class]
frame.name = frame.name or UnitName(frame.unit) frame.name = frame.name or UnitName(frame.unit)
frame.name = '|c'..color.colorStr..frame.name..'|r' frame.name = '|c'..color.colorStr..frame.name..'|r'
@@ -95,7 +95,7 @@ pfUI:RegisterModule("mapcolors", function ()
local tooltipText = "" local tooltipText = ""
if unit_button_name == 'WorldMap' then if unit_button_name == 'WorldMap' then
-- check player -- check player
if MouseIsOver(WorldMapPlayer) then if WorldMapPlayer:IsMouseOver() then
ColorizeName(WorldMapPlayer) ColorizeName(WorldMapPlayer)
tooltipText = WorldMapPlayer.name tooltipText = WorldMapPlayer.name
end end
@@ -104,7 +104,7 @@ pfUI:RegisterModule("mapcolors", function ()
-- check party -- check party
for i=1, MAX_PARTY_MEMBERS do for i=1, MAX_PARTY_MEMBERS do
local frame = _G[unit_button_name.."Party"..i] local frame = _G[unit_button_name.."Party"..i]
if frame:IsVisible() and MouseIsOver(frame) then if frame:IsVisible() and frame:IsMouseOver() then
ColorizeName(frame) ColorizeName(frame)
tooltipText = tooltipText.."\n"..frame.name tooltipText = tooltipText.."\n"..frame.name
end end
@@ -113,7 +113,7 @@ pfUI:RegisterModule("mapcolors", function ()
--check Raid --check Raid
for i=1, MAX_RAID_MEMBERS do for i=1, MAX_RAID_MEMBERS do
local frame = _G[unit_button_name.."Raid"..i] local frame = _G[unit_button_name.."Raid"..i]
if frame:IsVisible() and MouseIsOver(frame) then if frame:IsVisible() and frame:IsMouseOver() then
ColorizeName(frame) ColorizeName(frame)
tooltipText = tooltipText.."\n"..frame.name tooltipText = tooltipText.."\n"..frame.name
end end
@@ -138,7 +138,7 @@ pfUI:RegisterModule("mapcolors", function ()
end end
-- BattlefieldMinimap -- BattlefieldMinimap
HookAddonOrVariable("Blizzard_BattlefieldMinimap", function() HookAddon("Blizzard_BattlefieldMinimap", function()
Initialize('BattlefieldMinimap') Initialize('BattlefieldMinimap')
hooksecurefunc('BattlefieldMinimap_OnUpdate', function() hooksecurefunc('BattlefieldMinimap_OnUpdate', function()
+77 -66
View File
@@ -30,20 +30,13 @@ pfUI:RegisterModule("mapreveal", function ()
pfUI.mapreveal:UpdateConfig() pfUI.mapreveal:UpdateConfig()
end) end)
local explores = {}
local explorecaches = {} local explorecaches = {}
local alreadyknown = {} -- per-zone accumulator: { [zone] = { [texName] = true } }
-- Own texture pool - separate from Blizzard's WorldMapOverlay textures -- Own texture pool - separate from Blizzard's WorldMapOverlay textures
local pfOverlays = {} local overlayPool = CreateTexturePool(WorldMapDetailFrame, "BORDER", nil, nil, function(_, tex)
local pfOverlayMax = 0 tex:Hide()
tex:ClearAllPoints()
local function pfGetOverlay(idx) end)
if not pfOverlays[idx] then
pfOverlays[idx] = WorldMapDetailFrame:CreateTexture("pfReveal"..idx, "BORDER")
end
return pfOverlays[idx]
end
local exploreEnter = function() local exploreEnter = function()
WorldMapTooltip:ClearLines() WorldMapTooltip:ClearLines()
@@ -52,86 +45,97 @@ pfUI:RegisterModule("mapreveal", function ()
WorldMapTooltip:AddLine(this.name, 1, 1, 1) WorldMapTooltip:AddLine(this.name, 1, 1, 1)
WorldMapTooltip:Show() WorldMapTooltip:Show()
if not explorecaches[this.name] then return end if not explorecaches[this.area] then return end
if C.appearance.worldmap.mapreveal == "0" then return end if C.appearance.worldmap.mapreveal == "0" then return end
for texture in pairs(explorecaches[this.name]) do for texture in pairs(explorecaches[this.area]) do
texture:SetVertexColor(1,1,1,1) texture:SetVertexColor(1,1,1,1)
end end
end end
local exploreLeave = function() local exploreLeave = function()
WorldMapTooltip:Hide() WorldMapTooltip:Hide()
if not explorecaches[this.name] then return end if not explorecaches[this.area] then return end
if C.appearance.worldmap.mapreveal == "0" then return end if C.appearance.worldmap.mapreveal == "0" then return end
local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color) local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color)
for texture in pairs(explorecaches[this.name]) do for texture in pairs(explorecaches[this.area]) do
texture:SetVertexColor(r,g,b,a) texture:SetVertexColor(r,g,b,a)
end end
end end
-- Magnifying-glass icons for unexplored overlays. Everything constant lives
-- in the creator; the update only anchors and labels what it acquires -- and
-- it only acquires the ones it is going to show, where the old table grew an
-- icon for every overlay in the zone and hid most of them again.
local function CreateExplore()
local explore = CreateFrame("Frame", nil, WorldMapDetailFrame)
explore:SetSize(16, 16)
explore:SetScript("OnEnter", exploreEnter)
explore:SetScript("OnLeave", exploreLeave)
explore:EnableMouse(true)
explore:SetFrameLevel(255)
explore.tex = explore:CreateTexture(nil, "OVERLAY")
explore.tex:SetTexture("Interface\\WorldMap\\WorldMap-MagnifyingGlass")
explore.tex:SetBlendMode("ADD")
explore.tex:SetTexCoord(.08, .92, .08, .92)
explore.tex:SetAllPoints()
return explore
end
local explorePool = CreateObjectPool(CreateExplore, function(_, explore)
explore:Hide()
explore:ClearAllPoints()
end)
local function pfWorldMapFrame_Update() local function pfWorldMapFrame_Update()
-- clear stale caches -- clear stale caches
for k in pairs(explorecaches) do explorecaches[k] = nil end for k in pairs(explorecaches) do explorecaches[k] = nil end
-- hide all our textures from last frame -- hide all our textures and icons from last frame
for i = 1, pfOverlayMax do overlayPool:ReleaseAll()
pfOverlays[i]:Hide() explorePool:ReleaseAll()
end
local showExplore = C.appearance.worldmap.mapexploration == "1"
local showReveal = C.appearance.worldmap.mapreveal == "1"
if not showExplore and not showReveal then return end
local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color) local r,g,b,a = GetStringColor(C.appearance.worldmap.mapreveal_color)
local mapFileName = GetMapInfo() local mapFileName = GetMapInfo()
if not mapFileName then mapFileName = "World" end if not mapFileName then mapFileName = "World" end
local numOverlays = GetNumMapOverlays()
-- accumulate explored overlays per zone (never clear, only add)
if not alreadyknown[mapFileName] then alreadyknown[mapFileName] = {} end
for i = 1, numOverlays do
local texName = GetMapOverlayInfo(i)
if texName then alreadyknown[mapFileName][string.upper(texName)] = true end
end
local zoneKnown = alreadyknown[mapFileName]
-- hide explore icons
for _, frame in pairs(explores) do frame:Hide() end
-- ClassicAPI: full overlay list for the viewed zone (explored + unexplored), -- ClassicAPI: full overlay list for the viewed zone (explored + unexplored),
-- read straight from WorldMapOverlay.dbc. Replaces the hand-measured pfMapOverlayData. -- read straight from WorldMapOverlay.dbc. Replaces the hand-measured pfMapOverlayData.
local zoneData = C_Map.GetMapOverlays() or {} local zoneData = C_Map.GetMapOverlays() or {}
local textureCount = 0
for i, overlay in ipairs(zoneData) do -- ClassicAPI: the unexplored subset of the viewed zone, using the engine's
-- own explored-bit test. Replaces the alreadyknown accumulator, which
-- replayed the explored-only GetMapOverlayInfo view. Keyed by the bare
-- texture name, the same key the icon cache below uses.
local unknown = {}
if showExplore then
for _, overlay in ipairs(C_MapExplorationInfo.GetUnexploredMapTextures() or {}) do
if overlay.textureName and overlay.textureName ~= "" then
unknown[string.upper(overlay.textureName)] = true
end
end
end
for _, overlay in ipairs(zoneData) do
local name = overlay.textureName -- bare, e.g. "DRYGULCHRAVINE" local name = overlay.textureName -- bare, e.g. "DRYGULCHRAVINE"
local textureName = overlay.texturePath -- full engine path (for SetTexture)
local textureWidth = overlay.textureWidth local textureWidth = overlay.textureWidth
local textureHeight = overlay.textureHeight local textureHeight = overlay.textureHeight
local offsetX = overlay.offsetX local offsetX = overlay.offsetX
local offsetY = overlay.offsetY local offsetY = overlay.offsetY
-- explore magnifying glass icon -- explore magnifying glass icon for overlays the engine still
explores[i] = explores[i] or CreateFrame("Frame", nil, WorldMapDetailFrame) -- counts as unexplored.
local explore = explores[i] if showExplore and unknown[string.upper(name)] then
explore:SetWidth(16) local explore = explorePool:Acquire()
explore:SetHeight(16) explore:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", offsetX + textureWidth/2, -offsetY - textureHeight/2)
explore:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", offsetX + textureWidth/2, -offsetY - textureHeight/2) explore.name = mapFileName .. " (" .. name .. ")"
explore:SetScript("OnEnter", exploreEnter) explore.area = name -- cache key: explorecaches is keyed by the plain area name
explore:SetScript("OnLeave", exploreLeave)
explore:EnableMouse(true)
explore:SetFrameLevel(255)
explore.name = mapFileName .. " (" .. name .. ")"
explore.tex = explore.tex or explore:CreateTexture("", "OVERLAY")
explore.tex:SetBlendMode("ADD")
explore.tex:SetTexCoord(.08, .92, .08, .92)
explore.tex:SetAllPoints()
-- `alreadyknown` stores the FULL paths GetMapOverlayInfo returns,
-- so compare with the full path, not the bare name.
if C.appearance.worldmap.mapexploration == "1" and not zoneKnown[string.upper(textureName)] then
explore.tex:SetTexture("Interface\\WorldMap\\WorldMap-MagnifyingGlass")
explore:Show() explore:Show()
else
explore:Hide()
end end
-- render overlay texture tiles on BORDER draw layer -- render overlay texture tiles on BORDER draw layer
@@ -144,13 +148,11 @@ pfUI:RegisterModule("mapreveal", function ()
-- disambiguated from the actual BLP dimensions. No 256px grid -- disambiguated from the actual BLP dimensions. No 256px grid
-- math here — deriving the grid from textureWidth/Height is -- math here — deriving the grid from textureWidth/Height is
-- exactly what shears quirky overlays (e.g. Icepoint's Kaneq'nuun). -- exactly what shears quirky overlays (e.g. Icepoint's Kaneq'nuun).
if C.appearance.worldmap.mapreveal == "1" then if showReveal then
for _, tile in ipairs(overlay.tiles) do for _, tile in ipairs(overlay.tiles) do
textureCount = textureCount + 1 local tex = overlayPool:Acquire()
local tex = pfGetOverlay(textureCount)
tex:SetWidth(tile.width) tex:SetSize(tile.width, tile.height)
tex:SetHeight(tile.height)
tex:SetTexCoord(0, tile.texCoordX, 0, tile.texCoordY) tex:SetTexCoord(0, tile.texCoordX, 0, tile.texCoordY)
tex:ClearAllPoints() tex:ClearAllPoints()
tex:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", tile.offsetX, -tile.offsetY) tex:SetPoint("TOPLEFT", "WorldMapDetailFrame", "TOPLEFT", tile.offsetX, -tile.offsetY)
@@ -164,8 +166,6 @@ pfUI:RegisterModule("mapreveal", function ()
end end
end end
end end
pfOverlayMax = math.max(pfOverlayMax, textureCount)
end end
-- hook WorldMapFrame_Update -- hook WorldMapFrame_Update
@@ -175,4 +175,15 @@ pfUI:RegisterModule("mapreveal", function ()
pfWorldMapFrame_Update() pfWorldMapFrame_Update()
end end
end) -- live refresh while the map is open: exploration changes arrive on this
-- event. Zone switches, zoom and (re)opens still come through the hook
-- above, so nothing is redrawn while the map is closed — the next open
-- rebuilds from the current state.
pfUI.events:RegisterFrameEventAndCallback("MAP_EXPLORATION_UPDATED", function()
if WorldMapFrame and WorldMapFrame:IsShown() then
pfWorldMapFrame_Update()
end
end)
end)
+87 -76
View File
@@ -1,57 +1,30 @@
pfUI:RegisterModule("marktracking", function () pfUI:RegisterModule("marktracking", function ()
-- Requires mark1-mark8 unit tokens (Turtle WoW / Nampower)
if not UnitExists("mark1") and not UnitExists("mark8") then
if not pcall(function() UnitExists("mark1") end) then return end
end
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
-- Parse color strings "r,g,b,a" into components
local function ParseColor(str, dr, dg, db, da)
if not str or str == "" then return dr, dg, db, da end
local _, _, r, g, b, a = string.find(str, "([%d%.]+),([%d%.]+),([%d%.]+),([%d%.]+)")
if r then
return tonumber(r) or dr, tonumber(g) or dg, tonumber(b) or db, tonumber(a) or da
end
return dr, dg, db, da
end
local markerOrder = { 8, 7, 6, 5, 4, 3, 2, 1 } -- skull, cross, square, moon, triangle, diamond, circle, star local markerOrder = { 8, 7, 6, 5, 4, 3, 2, 1 } -- skull, cross, square, moon, triangle, diamond, circle, star
local markerTokens = {} local markerTokens = {} -- [i] = "markN"
for i = 1, 8 do markerTokens[i] = "mark" .. i end local markerIndex = {} -- ["markN"] = i, for the event handler's arg1
-- Default colors per marker
local defaultColors = {
[1] = { 1.0, 0.9, 0.0, 1 }, -- star: yellow
[2] = { 1.0, 0.5, 0.0, 1 }, -- circle: orange
[3] = { 0.8, 0.0, 0.8, 1 }, -- diamond: purple
[4] = { 0.0, 0.8, 0.0, 1 }, -- triangle: green
[5] = { 0.7, 0.7, 0.7, 1 }, -- moon: silver
[6] = { 0.0, 0.4, 0.9, 1 }, -- square: blue
[7] = { 0.9, 0.0, 0.0, 1 }, -- cross: red
[8] = { 1.0, 1.0, 1.0, 1 }, -- skull: white
}
local markerConfigKeys = { local markerConfigKeys = {
[1] = "raidmarkercolor_star", "raidmarkercolor_star",
[2] = "raidmarkercolor_circle", "raidmarkercolor_circle",
[3] = "raidmarkercolor_diamond", "raidmarkercolor_diamond",
[4] = "raidmarkercolor_triangle", "raidmarkercolor_triangle",
[5] = "raidmarkercolor_moon", "raidmarkercolor_moon",
[6] = "raidmarkercolor_square", "raidmarkercolor_square",
[7] = "raidmarkercolor_cross", "raidmarkercolor_cross",
[8] = "raidmarkercolor_skull", "raidmarkercolor_skull",
} }
local markerColors = {} local markerColors = {}
for i = 1, 8 do for i, markKey in ipairs(markerConfigKeys) do
local d = defaultColors[i] markerTokens[i] = "mark" .. i
local r, g, b, a = ParseColor(C.unitframes[markerConfigKeys[i]], d[1], d[2], d[3], d[4]) markerIndex[markerTokens[i]] = i
markerColors[i] = { r, g, b, a } local r, g, b, a = GetStringColor(C.unitframes[markKey])
markerColors[i] = { tonumber(r), tonumber(g), tonumber(b), tonumber(a) }
end end
local FALLBACK_INTERVAL = 1.0 -- safety net for units that come into range after marker was set local FALLBACK_INTERVAL = 1.0 -- safety net for units that come into range after marker was set
local elapsed = 0
local isUnlocked = false local isUnlocked = false
local ROW_HEIGHT = tonumber(C.unitframes.raidmarkerheight) or 14 local ROW_HEIGHT = tonumber(C.unitframes.raidmarkerheight) or 14
local BAR_WIDTH = tonumber(C.unitframes.raidmarkerwidth) or 80 local BAR_WIDTH = tonumber(C.unitframes.raidmarkerwidth) or 80
@@ -98,8 +71,7 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
else else
pfUI.marktracking:SetPoint("TOP", UIParent, "CENTER", 0, 0) pfUI.marktracking:SetPoint("TOP", UIParent, "CENTER", 0, 0)
end end
pfUI.marktracking:SetWidth(TOTAL_ROW_WIDTH) pfUI.marktracking:SetSize(TOTAL_ROW_WIDTH, 8 * (ROW_HEIGHT + 1) + border * 2 - 1)
pfUI.marktracking:SetHeight(8 * (ROW_HEIGHT + 1) + border * 2 - 1)
pfUI.marktracking:Hide() pfUI.marktracking:Hide()
CreateBackdrop(pfUI.marktracking) CreateBackdrop(pfUI.marktracking)
@@ -125,19 +97,16 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
local i = markerOrder[idx] local i = markerOrder[idx]
local row = CreateFrame("Button", nil, pfUI.marktracking) local row = CreateFrame("Button", nil, pfUI.marktracking)
row:SetWidth(TOTAL_ROW_WIDTH) row:SetSize(TOTAL_ROW_WIDTH, ROW_HEIGHT)
row:SetHeight(ROW_HEIGHT)
row:Hide() row:Hide()
row:RegisterForClicks("LeftButtonUp") row:RegisterForClicks("LeftButtonUp", "RightButtonUp")
row:SetScript("OnClick", function() row:SetAttribute("type1", "target")
TargetUnit(markerTokens[this.markerIndex]) row:SetAttribute("type2", "menu")
end)
-- raid icon -- raid icon
row.icon = row:CreateTexture(nil, "ARTWORK") row.icon = row:CreateTexture(nil, "ARTWORK")
row.icon:SetWidth(ROW_HEIGHT) row.icon:SetSize(ROW_HEIGHT, ROW_HEIGHT)
row.icon:SetHeight(ROW_HEIGHT)
row.icon:SetPoint("LEFT", row, "LEFT", 1, 0) row.icon:SetPoint("LEFT", row, "LEFT", 1, 0)
local markTex = C.unitframes.blizzard_raidicons == "1" and "Interface\\TargetingFrame\\UI-RaidTargetingIcons" or pfUI.media["img:raidicons"] local markTex = C.unitframes.blizzard_raidicons == "1" and "Interface\\TargetingFrame\\UI-RaidTargetingIcons" or pfUI.media["img:raidicons"]
row.icon:SetTexture(markTex) row.icon:SetTexture(markTex)
@@ -145,8 +114,7 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
-- portrait (right side) -- portrait (right side)
row.portrait = row:CreateTexture(nil, "ARTWORK") row.portrait = row:CreateTexture(nil, "ARTWORK")
row.portrait:SetWidth(PORTRAIT_SIZE) row.portrait:SetSize(PORTRAIT_SIZE, PORTRAIT_SIZE)
row.portrait:SetHeight(PORTRAIT_SIZE)
row.portrait:SetPoint("RIGHT", row, "RIGHT", -1, 0) row.portrait:SetPoint("RIGHT", row, "RIGHT", -1, 0)
row.portrait:SetTexCoord(.1, .9, .1, .9) row.portrait:SetTexCoord(.1, .9, .1, .9)
if not rm_showportrait then row.portrait:Hide() end if not rm_showportrait then row.portrait:Hide() end
@@ -204,8 +172,8 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
local token = markerTokens[i] local token = markerTokens[i]
if UnitExists(token) and not UnitIsDead(token) then if UnitExists(token) and not UnitIsDead(token) then
local hp = UnitHealth(token) local hp, maxhp = UnitHealth(token), UnitHealthMax(token)
local maxhp = UnitHealthMax(token) row:SetAttribute('unit', token)
if hp and maxhp and maxhp > 0 and hp > 0 then if hp and maxhp and maxhp > 0 and hp > 0 then
local pct = hp / maxhp local pct = hp / maxhp
@@ -267,11 +235,30 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
end end
end end
-- Fast per-row refresh for a single mark's UNIT_HEALTH/UNIT_MAXHEALTH: moves
-- just the bar + hp text. If the mark's visibility flips (comes into range,
-- dies, hp crosses 0) the visible rows re-pack, so hand off to UpdateDisplay.
local function UpdateRow(i)
if isUnlocked then return end
local row = pfUI.marktracking.rows[i]
if not row then return end
local token = markerTokens[i]
local hp, maxhp = UnitHealth(token), UnitHealthMax(token)
local shouldShow = UnitExists(token) and not UnitIsDead(token)
and hp and maxhp and maxhp > 0 and hp > 0 and true or false
if shouldShow ~= (row:IsShown() and true or false) then
UpdateDisplay()
return
end
if not shouldShow then return end
local pct = hp / maxhp
row.health:SetValue(pct)
if rm_showpct then row.hptext:SetText(math.ceil(pct * 100) .. "%") end
end
-- Unlock mode: show fixed 1-row placeholder so positioning works correctly -- Unlock mode: show fixed 1-row placeholder so positioning works correctly
if pfUI.unlock then if pfUI.unlock then
local origShow = pfUI.unlock:GetScript("OnShow") pfUI.unlock:HookScript("OnShow", function()
pfUI.unlock:SetScript("OnShow", function()
if origShow then origShow() end
isUnlocked = true isUnlocked = true
-- hide all rows, show container at 1-row height as drag handle -- hide all rows, show container at 1-row height as drag handle
for i = 1, 8 do for i = 1, 8 do
@@ -281,9 +268,7 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
pfUI.marktracking:Show() pfUI.marktracking:Show()
end) end)
local origHide = pfUI.unlock:GetScript("OnHide") pfUI.unlock:HookScript("OnHide", function()
pfUI.unlock:SetScript("OnHide", function()
if origHide then origHide() end
isUnlocked = false isUnlocked = false
UpdateDisplay() UpdateDisplay()
end) end)
@@ -292,24 +277,50 @@ pfUI.marktracking = CreateFrame("Frame", "pfMarkTracking", UIParent)
-- Event-driven scanner frame -- Event-driven scanner frame
local scanner = CreateFrame("Frame") local scanner = CreateFrame("Frame")
-- RAID_TARGET_UPDATE: fires when a raid marker is set/cleared -- Fallback poll: catches units that come into range AFTER a marker was set
-- PLAYER_ENTERING_WORLD: fires on login, reload, and zone transitions -- (no event fires for that case, so we need this safety net). UpdateDisplay
-- UNIT_HEALTH/UNIT_MAXHEALTH: fires on HP changes for real-time bar updates -- is a full eight-row rebuild, so it exists only while grouped -- raid markers
-- are a group feature and there is nothing to discover alone. The group events
-- below start and cancel it, so outside a group there is no timer queued at
-- all rather than one waking every second to return early.
--
-- Deliberately NOT keyed on a mark being visible: a marker set on a unit that
-- is out of range shows no row, and that is exactly what this poll catches.
local poll
local function UpdatePoll()
local grouped = IsInGroup()
if grouped and not poll then
poll = C_Timer.NewTicker(FALLBACK_INTERVAL, UpdateDisplay)
elseif not grouped and poll then
poll:Cancel()
poll = nil
end
end
-- RAID_TARGET_UPDATE: a raid marker was set/cleared -> full refresh
-- PLAYER_ENTERING_WORLD: login/reload/zone -> full refresh
-- PARTY_MEMBERS_CHANGED/RAID_ROSTER_UPDATE: joined or left a group -> the rows
-- can change, and the fallback poll starts or stops with it
-- UNIT_HEALTH/UNIT_MAXHEALTH: filtered to the eight mark tokens, so arg1 is
-- always "markN" and we refresh just that row (UpdateRow) instead of
-- rescanning all eight.
scanner:RegisterEvent("RAID_TARGET_UPDATE") scanner:RegisterEvent("RAID_TARGET_UPDATE")
scanner:RegisterEvent("PLAYER_ENTERING_WORLD") scanner:RegisterEvent("PLAYER_ENTERING_WORLD")
scanner:RegisterEvent("UNIT_HEALTH") scanner:RegisterEvent("PARTY_MEMBERS_CHANGED")
scanner:RegisterEvent("UNIT_MAXHEALTH") scanner:RegisterEvent("RAID_ROSTER_UPDATE")
scanner:RegisterUnitEvent("UNIT_HEALTH", "mark1", "mark2", "mark3", "mark4", "mark5", "mark6", "mark7", "mark8")
scanner:RegisterUnitEvent("UNIT_MAXHEALTH", "mark1", "mark2", "mark3", "mark4", "mark5", "mark6", "mark7", "mark8")
scanner:SetScript("OnEvent", function() scanner:SetScript("OnEvent", function()
UpdateDisplay() if event == "UNIT_HEALTH" or event == "UNIT_MAXHEALTH" then
end) -- arg1 is one of the eight tokens we registered for, so this is a lookup
-- rather than a parse -- string.match would allocate a capture and
-- Fallback poll at 1s: catches units that come into range AFTER a marker was set -- tonumber would parse it, on every health tick of every marked unit.
-- (no event fires for that case, so we need this safety net) local i = arg1 and markerIndex[arg1]
scanner:SetScript("OnUpdate", function() if i then UpdateRow(i) end
elapsed = elapsed + arg1 return
if elapsed < FALLBACK_INTERVAL then return end end
elapsed = 0 if event ~= "RAID_TARGET_UPDATE" then UpdatePoll() end
UpdateDisplay() UpdateDisplay()
end) end)
end) end)
+36 -53
View File
@@ -18,7 +18,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap:SetPoint("TOPRIGHT", UIParent, -border*2, -border*2) pfUI.minimap:SetPoint("TOPRIGHT", UIParent, -border*2, -border*2)
UpdateMovable(pfUI.minimap) UpdateMovable(pfUI.minimap)
pfUI.minimap:SetScript("OnShow", function() pfUI.minimap:SetScript("OnShow", function()
QueueFunction(ShowUIPanel, Minimap) RunNextFrame(function() ShowUIPanel(Minimap) end)
end) end)
Minimap:SetParent(pfUI.minimap) Minimap:SetParent(pfUI.minimap)
@@ -33,11 +33,9 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.UpdateConfig = function(self) pfUI.minimap.UpdateConfig = function(self)
size = tonumber(C.appearance.minimap.size) or 140 size = tonumber(C.appearance.minimap.size) or 140
pfUI.minimap:SetWidth(size) pfUI.minimap:SetSize(size, size)
pfUI.minimap:SetHeight(size)
Minimap:SetWidth(size) Minimap:SetSize(size, size)
Minimap:SetHeight(size)
-- vanilla+tbc: do the best to detect the minimap arrow -- vanilla+tbc: do the best to detect the minimap arrow
local arrowscale = tonumber(C.appearance.minimap.arrowscale) local arrowscale = tonumber(C.appearance.minimap.arrowscale)
@@ -105,46 +103,46 @@ pfUI:RegisterModule("minimap", function ()
this.highlight:SetAllPoints(this) this.highlight:SetAllPoints(this)
this.highlight:SetFrameLevel(this:GetFrameLevel() + 1) this.highlight:SetFrameLevel(this:GetFrameLevel() + 1)
this.highlight.tex = this.highlight:CreateTexture("OVERLAY") this.highlight.tex = this.highlight:CreateTexture(nil, "OVERLAY")
this.highlight.tex:SetTexture(pfUI.media["img:mail"]) this.highlight.tex:SetTexture(pfUI.media["img:mail"])
this.highlight.tex:SetPoint("TOPLEFT", MiniMapMailIcon, "TOPLEFT", -2, 2) this.highlight.tex:SetPoint("TOPLEFT", MiniMapMailIcon, "TOPLEFT", -2, 2)
this.highlight.tex:SetPoint("BOTTOMRIGHT", MiniMapMailIcon, "BOTTOMRIGHT", 2, -2) this.highlight.tex:SetPoint("BOTTOMRIGHT", MiniMapMailIcon, "BOTTOMRIGHT", 2, -2)
this.highlight.tex:SetVertexColor(1,.5,.5) this.highlight.tex:SetVertexColor(1,.5,.5)
this.highlight:SetScript("OnUpdate", function() -- Blink ten times between .9 and .1, then hide
if not this.count then this.count = 0 end local highlight = this.highlight
if not this.modifier then this.modifier = 1 end highlight:SetAlpha(.9)
if this.count >= 10 then this:Hide() end highlight.blink = highlight:CreateAnimationGroup()
for i = 1, 10 do
this:SetAlpha(this:GetAlpha() + this.modifier) local down = highlight.blink:CreateAnimation("Alpha")
down:SetChange(-.8)
if this:GetAlpha() <= 0.1 then down:SetDuration(.3)
this.modifier = 0.05 down:SetOrder(i * 2 - 1)
this.count = this.count + 1 local up = highlight.blink:CreateAnimation("Alpha")
elseif this:GetAlpha() >= 0.9 then up:SetChange(.8)
this.modifier = -0.05 up:SetDuration(.3)
end up:SetOrder(i * 2)
end) end
highlight.blink:SetScript("OnFinished", function() highlight:Hide() end)
end end
this.highlight.count = 0
this.highlight:Show() this.highlight:Show()
this.highlight.blink:Stop()
this.highlight.blink:Play()
end) end)
-- Create coordinates text frame with location configurable -- Create coordinates text frame with location configurable
pfUI.minimapCoordinates = CreateFrame("Frame", "pfMinimapCoord", pfUI.minimap) pfUI.minimapCoordinates = CreateFrame("Frame", "pfMinimapCoord", pfUI.minimap)
pfUI.minimapCoordinates:SetScript("OnUpdate", function() -- Update coords every 0.1 seconds
-- Throttle to update coords every 0.1 seconds C_Timer.NewTicker(0.1, function()
if ( this.tick or 0) > GetTime() then return end
this.tick = GetTime() + .1
if C.appearance.minimap.coordstext == "off" then return end if C.appearance.minimap.coordstext == "off" then return end
this.posX, this.posY = GetPlayerMapPosition("player") local coord = pfUI.minimapCoordinates
if this.posX ~= 0 and this.posY ~= 0 then coord.posX, coord.posY = GetPlayerMapPosition("player")
this.text:SetText(string.format("%.1f, %.1f", round(this.posX * 100, 1), round(this.posY * 100, 1))) if coord.posX ~= 0 and coord.posY ~= 0 then
coord.text:SetFormattedText("%.1f, %.1f", round(coord.posX * 100, 1), round(coord.posY * 100, 1))
else else
this.text:SetText("|cffffaaaaN/A") coord.text:SetText("|cffffaaaaN/A")
end end
end) end)
@@ -158,8 +156,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimapCoordinates:SetPoint("BOTTOMLEFT", 3, 3) pfUI.minimapCoordinates:SetPoint("BOTTOMLEFT", 3, 3)
end end
pfUI.minimapCoordinates:SetHeight(C.global.font_size) pfUI.minimapCoordinates:SetSize(Minimap:GetWidth(), C.global.font_size)
pfUI.minimapCoordinates:SetWidth(Minimap:GetWidth())
pfUI.minimapCoordinates.text = pfUI.minimapCoordinates:CreateFontString("MinimapCoordinatesText", "LOW", "GameFontNormal") pfUI.minimapCoordinates.text = pfUI.minimapCoordinates:CreateFontString("MinimapCoordinatesText", "LOW", "GameFontNormal")
pfUI.minimapCoordinates.text:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE") pfUI.minimapCoordinates.text:SetFont(pfUI.font_default, C.global.font_size, "OUTLINE")
pfUI.minimapCoordinates.text:SetTextColor(1,1,1,1) pfUI.minimapCoordinates.text:SetTextColor(1,1,1,1)
@@ -171,19 +168,14 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimapCoordinates.text:SetJustifyH("LEFT") pfUI.minimapCoordinates.text:SetJustifyH("LEFT")
end end
if C.appearance.minimap.coordstext ~= "on" then pfUI.minimapCoordinates:SetShown(C.appearance.minimap.coordstext == "on")
pfUI.minimapCoordinates:Hide()
else
pfUI.minimapCoordinates:Show()
end
-- Create zone text frame in top center of minimap -- Create zone text frame in top center of minimap
pfUI.minimapZone = CreateFrame("Frame", "pfMinimapZone", pfUI.minimap) pfUI.minimapZone = CreateFrame("Frame", "pfMinimapZone", pfUI.minimap)
pfUI.minimapZone:RegisterEvent("MINIMAP_ZONE_CHANGED") pfUI.minimapZone:RegisterEvent("MINIMAP_ZONE_CHANGED")
pfUI.minimapZone:RegisterEvent("PLAYER_ENTERING_WORLD") pfUI.minimapZone:RegisterEvent("PLAYER_ENTERING_WORLD")
pfUI.minimapZone:SetPoint("TOP", 0, -3) pfUI.minimapZone:SetPoint("TOP", 0, -3)
pfUI.minimapZone:SetHeight(C.global.font_size + 2) pfUI.minimapZone:SetSize(Minimap:GetWidth(), C.global.font_size + 2)
pfUI.minimapZone:SetWidth(Minimap:GetWidth())
pfUI.minimapZone.text = pfUI.minimapZone:CreateFontString("minimapZoneText", "LOW", "GameFontNormal") pfUI.minimapZone.text = pfUI.minimapZone:CreateFontString("minimapZoneText", "LOW", "GameFontNormal")
pfUI.minimapZone.text:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE") pfUI.minimapZone.text:SetFont(pfUI.font_default, C.global.font_size + 2, "OUTLINE")
pfUI.minimapZone.text:SetAllPoints(pfUI.minimapZone) pfUI.minimapZone.text:SetAllPoints(pfUI.minimapZone)
@@ -205,17 +197,13 @@ pfUI:RegisterModule("minimap", function ()
elseif pvp == "contested" then elseif pvp == "contested" then
pfUI.minimapZone.text:SetTextColor(1.0, 0.7, 0) pfUI.minimapZone.text:SetTextColor(1.0, 0.7, 0)
else else
pfUI.minimapZone.text:SetTextColor(1, 1, 1, 1) pfUI.minimapZone.text:SetTextColor(WHITE_FONT_COLOR:GetRGBA())
end end
pfUI.minimapZone.text:SetText(GetMinimapZoneText()) pfUI.minimapZone.text:SetText(GetMinimapZoneText())
end end
end) end)
if C.appearance.minimap.zonetext ~= "on" then pfUI.minimapZone:SetShown(C.appearance.minimap.zonetext == "on")
pfUI.minimapZone:Hide()
else
pfUI.minimapZone:Show()
end
-- Minimap hover event -- Minimap hover event
-- Update and toggle showing of coordinates and zone text on mouse enter/leave -- Update and toggle showing of coordinates and zone text on mouse enter/leave
@@ -239,10 +227,9 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.pvpicon = CreateFrame("Frame", nil, pfUI.minimap) pfUI.minimap.pvpicon = CreateFrame("Frame", nil, pfUI.minimap)
pfUI.minimap.pvpicon:Hide() pfUI.minimap.pvpicon:Hide()
pfUI.minimap.pvpicon:RegisterEvent("UPDATE_FACTION") pfUI.minimap.pvpicon:RegisterEvent("UPDATE_FACTION")
pfUI.minimap.pvpicon:RegisterEvent("UNIT_FACTION") pfUI.minimap.pvpicon:RegisterUnitEvent("UNIT_FACTION", "player")
pfUI.minimap.pvpicon:SetFrameStrata("HIGH") pfUI.minimap.pvpicon:SetFrameStrata("HIGH")
pfUI.minimap.pvpicon:SetWidth(16) pfUI.minimap.pvpicon:SetSize(16, 16)
pfUI.minimap.pvpicon:SetHeight(16)
pfUI.minimap.pvpicon:SetAlpha(.5) pfUI.minimap.pvpicon:SetAlpha(.5)
pfUI.minimap.pvpicon:SetParent(pfUI.minimap) pfUI.minimap.pvpicon:SetParent(pfUI.minimap)
pfUI.minimap.pvpicon:SetPoint("BOTTOMRIGHT", pfUI.minimap, "BOTTOMRIGHT", -5, 5) pfUI.minimap.pvpicon:SetPoint("BOTTOMRIGHT", pfUI.minimap, "BOTTOMRIGHT", -5, 5)
@@ -251,11 +238,7 @@ pfUI:RegisterModule("minimap", function ()
pfUI.minimap.pvpicon.texture:SetAllPoints(pfUI.minimap.pvpicon) pfUI.minimap.pvpicon.texture:SetAllPoints(pfUI.minimap.pvpicon)
pfUI.minimap.pvpicon:SetScript("OnEvent", function() pfUI.minimap.pvpicon:SetScript("OnEvent", function()
if C.unitframes.player.showPVPMinimap == "1" and UnitIsPVP("player") then pfUI.minimap.pvpicon:SetShown(C.unitframes.player.showPVPMinimap == "1" and UnitIsPVP("player"))
pfUI.minimap.pvpicon:Show()
else
pfUI.minimap.pvpicon:Hide()
end
end) end)
end) end)

Some files were not shown because too many files have changed in this diff Show More