80 Commits
Author SHA1 Message Date
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
81 changed files with 12007 additions and 4212 deletions
+1 -1
View File
@@ -13,7 +13,7 @@ do
-- on. There pfUI does load, and will throw wherever it reaches for something -- 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 -- the installed DLL doesn't have yet -- the popup names the cause so those
-- errors aren't a mystery. -- errors aren't a mystery.
local PFUI_CLASSIC_API_MIN = 11500 -- (X*10000 + Y*100 + Z) local PFUI_CLASSIC_API_MIN = 11805 -- (X*10000 + Y*100 + Z)
local PFUI_CLASSIC_API_LATEST = PFUI_CLASSIC_API_MIN local PFUI_CLASSIC_API_LATEST = PFUI_CLASSIC_API_MIN
local PFUI_CLASSIC_API_WEBSITE = "https://github.com/brues-code/ClassicAPI" local PFUI_CLASSIC_API_WEBSITE = "https://github.com/brues-code/ClassicAPI"
local PFUI_CLASSIC_API_LATEST_URL = PFUI_CLASSIC_API_WEBSITE .. "/releases/latest" local PFUI_CLASSIC_API_LATEST_URL = PFUI_CLASSIC_API_WEBSITE .. "/releases/latest"
+74 -74
View File
@@ -293,14 +293,6 @@ function pfUI.api.GetFactionIcon(raceKey)
return FACTION_ICON[info.faction] or "" return FACTION_ICON[info.faction] or ""
end end
-- [ GetPlayerRaceIcons ]
-- Returns the faction and race emblems of the player character.
-- return: [string] both inline textures, or an empty string
function pfUI.api.GetPlayerRaceIcons()
local _, raceKey = UnitRace("player")
return pfUI.api.GetFactionIcon(raceKey) .. pfUI.api.GetRaceIcon(raceKey, UnitSex("player"))
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.
@@ -730,20 +722,7 @@ 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
if _G.GetCoinTextureString then return "|cffffffff" .. _G.GetCoinTextureString(money) .. "|r"
return "|cffffffff" .. _G.GetCoinTextureString(money) .. "|r"
end
local gold = floor(money/ 100 / 100)
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 ]
@@ -1333,17 +1312,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",
@@ -1363,49 +1371,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 ] --
@@ -1416,7 +1398,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}
@@ -1434,9 +1415,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
@@ -1517,6 +1495,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)
@@ -1529,11 +1519,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
@@ -1549,13 +1548,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
@@ -1572,6 +1571,7 @@ 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
+25 -4
View File
@@ -71,6 +71,8 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("buffs", nil, "debuffrowsize", "16") pfUI:UpdateConfig("buffs", nil, "debuffrowsize", "16")
pfUI:UpdateConfig("buffs", nil, "textinside", "0") pfUI:UpdateConfig("buffs", nil, "textinside", "0")
pfUI:UpdateConfig("buffs", nil, "fontsize", "-1") pfUI:UpdateConfig("buffs", nil, "fontsize", "-1")
pfUI:UpdateConfig("buffs", nil, "cooldown_anim", "1")
pfUI:UpdateConfig("buffs", nil, "cooldown_reverse", "1")
pfUI:UpdateConfig("buffbar", "pbuff", "enable", "0") pfUI:UpdateConfig("buffbar", "pbuff", "enable", "0")
pfUI:UpdateConfig("buffbar", "pbuff", "use_unitfonts", "0") pfUI:UpdateConfig("buffbar", "pbuff", "use_unitfonts", "0")
@@ -156,6 +158,8 @@ function pfUI:LoadConfig()
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", "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")
@@ -167,11 +171,11 @@ 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")
pfUI:UpdateConfig("appearance", "bags", "icon_size", "-1") pfUI:UpdateConfig("appearance", "bags", "icon_size", "-1")
pfUI:UpdateConfig("appearance", "bags", "cooldown_reverse", "0")
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")
@@ -226,7 +230,6 @@ function pfUI:LoadConfig()
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")
@@ -324,6 +327,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")
@@ -512,14 +518,21 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("unitframes", unit, "pspace", "-3") pfUI:UpdateConfig("unitframes", unit, "pspace", "-3")
pfUI:UpdateConfig("unitframes", unit, "cooldown_text", "1") pfUI:UpdateConfig("unitframes", unit, "cooldown_text", "1")
pfUI:UpdateConfig("unitframes", unit, "cooldown_anim", "0") pfUI:UpdateConfig("unitframes", unit, "cooldown_anim", "0")
pfUI:UpdateConfig("unitframes", unit, "cooldown_reverse", "1")
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")
@@ -672,6 +685,7 @@ function pfUI:LoadConfig()
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", nil, "cd_size", "12")
pfUI:UpdateConfig("bars", nil, "cooldown_reverse", "0")
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")
@@ -685,6 +699,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("totems", nil, "iconsize", "26") pfUI:UpdateConfig("totems", nil, "iconsize", "26")
pfUI:UpdateConfig("totems", nil, "spacing", "3") pfUI:UpdateConfig("totems", nil, "spacing", "3")
pfUI:UpdateConfig("totems", nil, "showbg", "0") pfUI:UpdateConfig("totems", nil, "showbg", "0")
pfUI:UpdateConfig("totems", nil, "cooldown_reverse", "1")
pfUI:UpdateConfig("panel", nil, "use_unitfonts", "0") pfUI:UpdateConfig("panel", nil, "use_unitfonts", "0")
pfUI:UpdateConfig("panel", nil, "hide_leftchat", "0") pfUI:UpdateConfig("panel", nil, "hide_leftchat", "0")
@@ -810,14 +825,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", "playericons", "0") pfUI:UpdateConfig("chat", "text", "factionicons", "0")
pfUI:UpdateConfig("chat", "text", "whosearchunknown", "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")
@@ -932,6 +948,7 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("nameplates", nil, "debufftimers", "1") pfUI:UpdateConfig("nameplates", nil, "debufftimers", "1")
pfUI:UpdateConfig("nameplates", nil, "debufftext", "1") pfUI:UpdateConfig("nameplates", nil, "debufftext", "1")
pfUI:UpdateConfig("nameplates", nil, "debuffanim", "0") pfUI:UpdateConfig("nameplates", nil, "debuffanim", "0")
pfUI:UpdateConfig("nameplates", nil, "debreverse", "1")
pfUI:UpdateConfig("abuttons", nil, "enable", "1") pfUI:UpdateConfig("abuttons", nil, "enable", "1")
pfUI:UpdateConfig("abuttons", nil, "position", "bottom") pfUI:UpdateConfig("abuttons", nil, "position", "bottom")
@@ -959,6 +976,10 @@ function pfUI:LoadConfig()
pfUI:UpdateConfig("character", "inventory", "durability", "1") pfUI:UpdateConfig("character", "inventory", "durability", "1")
pfUI:UpdateConfig("character", "inventory", "equipflyout", "0") 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("thirdparty", nil, "chatbg", "1") pfUI:UpdateConfig("thirdparty", nil, "chatbg", "1")
pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0") pfUI:UpdateConfig("thirdparty", nil, "showmeter", "0")
+133 -329
View File
@@ -3,15 +3,19 @@ setfenv(1, pfUI:GetEnvironment())
do -- statusbars do -- statusbars
local animations = {} local animations = {}
local stepsize, val local stepsize
local width, height, point
-- native StatusBar methods the bar overrides
local statusbar = CreateFrame("StatusBar")
local SetValue, SetMinMaxValues = statusbar.SetValue, statusbar.SetMinMaxValues
local SetOrientation, SetFrameLevel = statusbar.SetOrientation, statusbar.SetFrameLevel
local animate = CreateFrame("Frame", "pfStatusBarAnimation", UIParent) local animate = CreateFrame("Frame", "pfStatusBarAnimation", UIParent)
animate:SetScript("OnUpdate", function() animate:SetScript("OnUpdate", function()
stepsize = tonumber(pfUI_config.unitframes.animation_speed) stepsize = tonumber(pfUI_config.unitframes.animation_speed)
for bar in pairs(animations) do for bar in pairs(animations) do
if not bar.val_ or abs(bar.val_ - bar.val) < stepsize or bar.instant then if not bar.val_ or abs(bar.val_ - bar.val) < stepsize then
bar:DisplayValue(bar.val) bar:DisplayValue(bar.val)
elseif bar.val ~= bar.val_ then elseif bar.val ~= bar.val_ then
bar:DisplayValue(bar.val_ + min((bar.val-bar.val_) / stepsize, max(bar.val-bar.val_, 30 / GetFramerate()))) bar:DisplayValue(bar.val_ + min((bar.val-bar.val_) / stepsize, max(bar.val-bar.val_, 30 / GetFramerate())))
@@ -21,7 +25,8 @@ do -- statusbars
local handlers = { local handlers = {
["DisplayValue"] = function(self, val) ["DisplayValue"] = function(self, val)
val = Clamp(val, self.min, self.max) local smin, smax = self:GetMinMaxValues()
val = Clamp(val, smin, smax)
-- remove animation queue -- remove animation queue
if val == self.val_ then if val == self.val_ then
@@ -30,53 +35,20 @@ do -- statusbars
-- set current visible value -- set current visible value
self.val_ = val self.val_ = val
SetValue(self, val)
if self.mode == "vertical" then -- the background fills the missing part, all of an empty range
height = self:GetHeight() self.bg:SetValue(smax > smin and (smax - val) / (smax - smin) or 1)
height = height / self:GetEffectiveScale()
point = height / (self.max - self.min) * (val - self.min)
-- keep values in limits
point = Clamp(point, 0, height)
-- set point to zero if value and max is zero
if val == 0 then point = 0 end
-- set status bar position/size
self.bar:SetPoint("TOPLEFT", self, "TOPLEFT", 0, - height + point)
self.bar:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", 0, 0)
-- set background bar position/size
self.bg:SetPoint("TOPLEFT", self, "TOPLEFT", 0, 0)
self.bg:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", 0, point)
else
width = self:GetWidth()
width = width / self:GetEffectiveScale()
point = width / (self.max - self.min) * (val - self.min)
-- keep values in limits
point = Clamp(point, 0, width)
-- set point to zero if value and max is zero
if val == 0 then point = 0 end
-- set status bar position/size
self.bar:SetPoint("TOPLEFT", self, "TOPLEFT", 0, 0)
self.bar:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", - width + point, 0)
-- set background bar position/size
self.bg:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", 0, 0)
self.bg:SetPoint("TOPLEFT", self, "TOPLEFT", point, 0)
end
end, end,
["SetMinMaxValues"] = function(self, smin, smax, smooth) ["SetMinMaxValues"] = function(self, smin, smax, smooth)
-- smoothen the transition by keeping the value at the same percentage as before -- smoothen the transition by keeping the value at the same percentage as before
if smooth and self.max and self.max > 0 and smax > 0 and self.max ~= smax then local _, oldmax = self:GetMinMaxValues()
self.val_ = (self.val_ or self.val) / self.max * smax if smooth and oldmax > 0 and smax > 0 and oldmax ~= smax then
self.val_ = (self.val_ or self.val) / oldmax * smax
end end
self.min, self.max = smin, smax SetMinMaxValues(self, smin, smax)
self:DisplayValue(self.val_ or self.val) self:DisplayValue(self.val_ or self.val)
end, end,
@@ -89,41 +61,35 @@ do -- statusbars
end end
end, end,
["SetStatusBarTexture"] = function(self, r, g, b, a)
self.bar:SetTexture(r, g, b, a)
end,
["SetStatusBarColor"] = function(self, r, g, b, a)
self.bar:SetVertexColor(r, g, b, a)
end,
["SetStatusBarBackgroundTexture"] = function(self, r, g, b, a)
self.bg:SetTexture(r, g, b, a)
end,
["SetStatusBarBackgroundColor"] = function(self, r, g, b, a) ["SetStatusBarBackgroundColor"] = function(self, r, g, b, a)
self.bg:SetVertexColor(r, g, b, a) self.bg:SetColorFill(r, g, b, a)
end, end,
["SetOrientation"] = function(self, mode) ["SetOrientation"] = function(self, orientation)
self.mode = strlower(mode) SetOrientation(self, orientation)
self.bg:SetOrientation(orientation)
end,
-- the background stays one level below the fill, under anything else
-- drawn on the fill's frame
["SetFrameLevel"] = function(self, level)
SetFrameLevel(self, level)
self.bg:SetFrameLevel(level - 1)
end, end,
} }
function pfUI.api.CreateStatusBar(name, parent) function pfUI.api.CreateStatusBar(name, parent)
local f = CreateFrame("Button", name, parent) local f = CreateFrame("StatusBar", name, parent)
f:EnableMouse(false) SetMinMaxValues(f, 0, 100)
SetValue(f, 0)
f.val = 0
f.bar = f:CreateTexture(nil, "NORMAL") f.bg = CreateFrame("StatusBar", nil, f)
f.bar:SetPoint("TOPLEFT", f, "TOPLEFT", 0, 0) f.bg:SetFrameLevel(f:GetFrameLevel() - 1)
f.bar:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 0, 0) f.bg:SetAllPoints(f)
f.bg:SetReverseFill(true)
f.bg = f:CreateTexture(nil, "BACKGROUND") f.bg:SetMinMaxValues(0, 1)
f.bg:SetPoint("TOPLEFT", f, "TOPLEFT", 0, 0) f.bg:SetValue(1)
f.bg:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 0, 0)
-- set some default values
f.min, f.max, f.val = 0, 100, 0
-- add all handler functions to the object -- add all handler functions to the object
for name, func in pairs(handlers) do for name, func in pairs(handlers) do
@@ -170,7 +136,7 @@ do -- dropdown
end end
local function MenuOnUpdate() local function MenuOnUpdate()
if not MouseIsOver(this, 100, -100, -100, 100) then if not this:IsMouseOver(100, -100, -100, 100) then
this.button:HideMenu() this.button:HideMenu()
end end
end end
@@ -350,186 +316,28 @@ do -- dropdown
end end
end end
function pfUI.api.CreateTabChild(self, title, bwidth, bheight, bottom, static) -- [ pfUIScrollingEditBoxTemplate ]
-- create tab button -- Mixin of the template in ui-widgets.xml: ClassicAPI's scrolling edit box
local b = CreateFrame("Button", "pfConfig" .. title .. "Button", self, "UIPanelButtonTemplate") -- with pfUI's scroll bar beside it.
b:SetText(title) _G.pfUIScrollingEditBoxMixin = {}
-- setup env function pfUIScrollingEditBoxMixin:InitScrollBar()
local childcount = table.getn(self.childs) + 1 local scrollBox = self:GetScrollBox()
local button_width = bwidth scrollBox:ClearAllPoints()
local button_height = bheight or 20 scrollBox:SetPoint("TOPLEFT")
local border = 4 scrollBox:SetPoint("BOTTOMRIGHT", self.ScrollBar, "BOTTOMLEFT")
ScrollUtil.RegisterScrollBoxWithScrollBar(scrollBox, self.ScrollBar)
if not button_width then
button_width = 150
elseif button_width == true then
button_width = _G["pfConfig" .. title .. "ButtonText"]:GetStringWidth() + 4 * border
end
-- set dimensions
b:SetSize(button_width, button_height)
b:SetID(childcount)
if not self.align or self.align == "LEFT" then
local outside = self.outside and -2 * border - button_width or 0
if bottom then
b:SetPoint("BOTTOMLEFT", self, "BOTTOMLEFT", border + outside, (self.bottomcount-1) * (button_height) + (self.bottomcount * border) )
else
b:SetPoint("TOPLEFT", self, "TOPLEFT", border + outside, -(childcount-1) * (button_height) - (childcount * border) )
end
elseif self.align == "TOP" then
local outside = self.outside and 2 * border + button_height or 0
local prev_button = self.buttons[getn(self.buttons)]
if prev_button then
b:SetPoint("TOPLEFT", prev_button, "TOPRIGHT", border, 0)
else
b:SetPoint("TOPLEFT", self, "TOPLEFT", border + (self.outside and -border), -border + outside )
end
end
SkinButton(b,.2,1,.8)
if childcount ~= 1 then
b:SetTextColor(.5,.5,.5)
else
b:SetTextColor(.2,1,.8)
end
b:SetScript("OnClick", function()
for k,v in pairs(self.childs) do
v:Hide()
end
self.childs[this:GetID()]:Show()
for k,v in pairs(self.buttons) do
v.active = false
v:SetTextColor(.5,.5,.5)
end
self.buttons[this:GetID()]:SetTextColor(.2,1,.8)
end)
self.buttons[childcount] = b
self.bottomcount = bottom and self.bottomcount + 1 or self.bottomcount
-- create child frame
local child, scrollchild = nil, nil
if not static then
child = CreateScrollFrame("pfConfig" .. title .. "Frame", self)
scrollchild = CreateScrollChild("pfConfig" .. title .. "ScrollChild", child)
else
child = CreateFrame("Frame", "pfConfig" .. title .. "Frame", self)
end
if childcount ~= 1 then child:Hide() end
if not self.align or self.align == "LEFT" then
child:SetPoint("TOPLEFT", self, "TOPLEFT", button_width + 2*border + 5, -border -5)
child:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -border -5 , border + 5)
elseif self.align == "TOP" then
if self.outside then
child:SetPoint("TOPLEFT", self, "TOPLEFT", 5, -5)
child:SetPoint("BOTTOMRIGHT", self, "BOTTOMRIGHT", -5, 5)
end
end
CreateBackdrop(child)
SetAllPointsOffset(child.backdrop, child, -5,5)
local ret = scrollchild or child
ret.button = b
table.insert(self.childs, child)
return ret
end end
function pfUI.api.CreateTabFrame(parent, align, outside) -- The edit box takes its font from a font object and sets that object again
local f = CreateFrame("Frame", nil, parent) -- on every SetText, so a font path goes through a font object of the frame's own.
function pfUIScrollingEditBoxMixin:SetFont(font, size, flags)
f:SetPoint("TOPLEFT", parent, "TOPLEFT", -5, 5) if not self.font then
f:SetPoint("BOTTOMRIGHT", parent, "BOTTOMRIGHT", 5, -5) self.font = CreateFont(self:GetName() .. "Font")
self:GetEditBox().fontName = self.font
-- setup env
f.childs = { }
f.buttons = { }
f.align = align
f.outside = outside
f.bottomcount = 1
-- Create Child Frame
f.CreateTabChild = pfUI.api.CreateTabChild
return f
end
function pfUI.api.CreateScrollFrame(name, parent)
local f = CreateFrame("ScrollFrame", name, parent)
-- create slider
f.slider = CreateFrame("Slider", nil, f)
f.slider:SetOrientation('VERTICAL')
f.slider:SetPoint("TOPLEFT", f, "TOPRIGHT", -7, 0)
f.slider:SetPoint("BOTTOMRIGHT", 0, 0)
f.slider:SetThumbTexture(pfUI.media["img:col"])
f.slider.thumb = f.slider:GetThumbTexture()
f.slider.thumb:SetHeight(50)
f.slider.thumb:SetTexture(.3,1,.8,.5)
f.slider:SetScript("OnValueChanged", function()
f:SetVerticalScroll(this:GetValue())
f.UpdateScrollState()
end)
f.UpdateScrollState = function()
f.slider:SetMinMaxValues(0, f:GetVerticalScrollRange())
f.slider:SetValue(f:GetVerticalScroll())
local m = f:GetHeight()+f:GetVerticalScrollRange()
local v = f:GetHeight()
local ratio = v / m
if ratio < 1 then
local size = math.floor(v * ratio)
f.slider.thumb:SetHeight(size)
f.slider:Show()
else
f.slider:Hide()
end
end end
self.font:SetFont(font, size, flags)
f.Scroll = function(self, step) self:SetFontObject(self.font)
local step = step or 0
local current = f:GetVerticalScroll()
local max = f:GetVerticalScrollRange()
local new = current - step
f:SetVerticalScroll(Clamp(new, 0, max))
f:UpdateScrollState()
end
f:EnableMouseWheel(1)
f:SetScript("OnMouseWheel", function()
this:Scroll(arg1*10)
end)
return f
end
function pfUI.api.CreateScrollChild(name, parent)
local f = CreateFrame("Frame", name, parent)
-- dummy values required
f:SetSize(1, 1)
f:SetAllPoints(parent)
parent:SetScrollChild(f)
f:SetScript("OnUpdate", function()
this:GetParent():UpdateScrollState()
end)
return f
end end
-- [ CreateTextBox ] -- [ CreateTextBox ]
@@ -661,7 +469,7 @@ function pfUI.api.SkinButton(button, cr, cg, cb, icon, disableHighlight)
end end
b.UnlockHighlight = function() b.UnlockHighlight = function()
if not MouseIsOver(b) then if not MouseIsOverHitRect(b) then
b:SetBackdropBorderColor(GetStringColor(pfUI_config.appearance.border.color)) b:SetBackdropBorderColor(GetStringColor(pfUI_config.appearance.border.color))
end end
b.locked = false b.locked = false
@@ -683,6 +491,7 @@ function pfUI.api.SkinCollapseButton(button, all)
b.icon:SetSize(size, size) b.icon:SetSize(size, size)
b.icon:SetPoint("LEFT", 2, 2) b.icon:SetPoint("LEFT", 2, 2)
CreateBackdrop(b.icon) CreateBackdrop(b.icon)
b.icon:EnableMouse(false)
b.icon.text = b.icon:CreateFontString(nil, "OVERLAY") b.icon.text = b.icon:CreateFontString(nil, "OVERLAY")
b.icon.text:SetFontObject(GameFontWhite) b.icon.text:SetFontObject(GameFontWhite)
b.icon.text:SetPoint("CENTER", -1, 0) b.icon.text:SetPoint("CENTER", -1, 0)
@@ -1160,18 +969,22 @@ function pfUI.api.CreateInfoBox(text, time, parent, height)
infobox = CreateFrame("Button", "pfInfoBox", UIParent) infobox = CreateFrame("Button", "pfInfoBox", UIParent)
infobox:Hide() infobox:Hide()
infobox.fade = infobox:CreateAnimationGroup()
local fade = infobox.fade:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(.3)
infobox.fade:SetScript("OnFinished", function()
infobox:Hide()
infobox:SetAlpha(1)
end)
infobox:SetScript("OnUpdate", function() infobox:SetScript("OnUpdate", function()
local time = infobox.lastshow + infobox.duration - GetTime() local time = infobox.lastshow + infobox.duration - GetTime()
infobox.timeout:SetValue(time) infobox.timeout:SetValue(time)
if GetTime() > infobox.lastshow + infobox.duration then if GetTime() > infobox.lastshow + infobox.duration then
infobox:SetAlpha(infobox:GetAlpha()-0.05) if not infobox.fade:IsPlaying() then infobox.fade:Play() end
elseif MouseIsOverHitRect(this) then
if infobox:GetAlpha() <= 0.1 then
infobox:Hide()
infobox:SetAlpha(1)
end
elseif MouseIsOver(this) then
this:SetAlpha(max(0.4, this:GetAlpha() - .1)) this:SetAlpha(max(0.4, this:GetAlpha() - .1))
else else
this:SetAlpha(min(1, this:GetAlpha() + .1)) this:SetAlpha(min(1, this:GetAlpha() + .1))
@@ -1214,6 +1027,7 @@ function pfUI.api.CreateInfoBox(text, time, parent, height)
infobox:SetParent(parent) infobox:SetParent(parent)
infobox:SetFrameStrata("FULLSCREEN_DIALOG") infobox:SetFrameStrata("FULLSCREEN_DIALOG")
infobox.fade:Stop()
infobox:Show() infobox:Show()
end end
@@ -1256,7 +1070,7 @@ end
-- survives filter changes -- a spell icon you picked still saves after you -- survives filter changes -- a spell icon you picked still saves after you
-- switch the filter to "Items" and it drops out of the visible grid. -- switch the filter to "Items" and it drops out of the visible grid.
-- --
-- name global-name prefix for the scroll frame and editboxes -- name global-name prefix for the icon grid and editboxes
-- parent the popup frame to attach the widgets to -- parent the popup frame to attach the widgets to
-- extraType IconDataProviderExtraType.* seed (Spellbook / Equipment) -- extraType IconDataProviderExtraType.* seed (Spellbook / Equipment)
-- nameLabelText header shown above the name field -- nameLabelText header shown above the name field
@@ -1326,17 +1140,13 @@ function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
parent.iconLabel:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -86) parent.iconLabel:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -86)
parent.iconLabel:SetText(MACRO_POPUP_CHOOSE_ICON) parent.iconLabel:SetText(MACRO_POPUP_CHOOSE_ICON)
-- Icon grid + scroll -- Icon grid: the template keeps 5px around the grid and its 7px scroll bar,
local iconScroll = CreateFrame("ScrollFrame", name.."Scroll", parent, "FauxScrollFrameTemplate") -- and the grid leaves 4px before the bar
iconScroll:SetPoint("TOPLEFT", parent, "TOPLEFT", 14, -116) local gridWidth = ICON_GRID_COLS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD
iconScroll:SetWidth(ICON_GRID_COLS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD) local gridHeight = ICON_GRID_ROWS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD
iconScroll:SetHeight(ICON_GRID_ROWS * (ICON_BTN_SIZE + ICON_BTN_PAD) - ICON_BTN_PAD) local grid = CreateFrame("Frame", name.."Icons", parent, "pfUIScrollBoxListTemplate")
grid:SetPoint("TOPLEFT", parent, "TOPLEFT", 9, -111)
local scrollbar = _G[name.."ScrollScrollBar"] grid:SetSize(gridWidth + 4 + 7 + 10, gridHeight + 10)
scrollbar:ClearAllPoints()
scrollbar:SetPoint("TOPLEFT", iconScroll, "TOPRIGHT", 8, -16)
scrollbar:SetPoint("BOTTOMLEFT", iconScroll, "BOTTOMRIGHT", 8, 16)
SkinScrollbar(scrollbar)
-- Filter dropdown: All / Spells / Items -- Filter dropdown: All / Spells / Items
local filterDropdown = CreateFrame("Frame", name.."Filter", parent, "UIDropDownMenuTemplate") local filterDropdown = CreateFrame("Frame", name.."Filter", parent, "UIDropDownMenuTemplate")
@@ -1371,38 +1181,54 @@ function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
UIDropDownMenu_SetSelectedValue(filterDropdown, "all") UIDropDownMenu_SetSelectedValue(filterDropdown, "all")
SkinDropDown(filterDropdown) SkinDropDown(filterDropdown)
local iconButtons = {} -- the selected icon gets a gold border in the grid and shows in the preview
for r = 1, ICON_GRID_ROWS do local function UpdateSelection()
for c = 1, ICON_GRID_COLS do grid.ScrollBox:ReinitializeFrames()
local i = (r - 1) * ICON_GRID_COLS + c parent.selectedPreview.tex:SetTexture(selectedIconPath)
local btn = CreateFrame("Button", nil, parent) end
btn:SetSize(ICON_BTN_SIZE, ICON_BTN_SIZE)
btn:SetPoint("TOPLEFT", iconScroll, "TOPLEFT", (c-1) * (ICON_BTN_SIZE + ICON_BTN_PAD), -(r-1) * (ICON_BTN_SIZE + ICON_BTN_PAD)) local function IconOnClick()
local path = provider:GetIconByIndex(this.iconIndex)
if path then selectedIconPath = path end
UpdateSelection()
end
local function IconOnEnter()
local path = provider:GetIconByIndex(this.iconIndex)
if type(path) == "string" then
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(IconKey(path), 1, 1, 1)
GameTooltip:Show()
end
end
local function InitIconButton(btn, icon)
-- one-time setup of a pooled button
if not btn.texture then
CreateBackdrop(btn) CreateBackdrop(btn)
btn.texture = btn:CreateTexture(nil, "ARTWORK") btn.texture = btn:CreateTexture(nil, "ARTWORK")
btn.texture:SetAllPoints(btn) btn.texture:SetAllPoints(btn)
btn.texture:SetTexCoord(.08, .92, .08, .92) btn.texture:SetTexCoord(.08, .92, .08, .92)
btn:SetScript("OnClick", function() btn:SetScript("OnClick", IconOnClick)
if this.iconIndex and provider then btn:SetScript("OnEnter", IconOnEnter)
local path = provider:GetIconByIndex(this.iconIndex)
if path then selectedIconPath = path end
RefreshIconGrid()
end
end)
btn:SetScript("OnEnter", function()
if not this.iconIndex or not provider then return end
local path = provider:GetIconByIndex(this.iconIndex)
if type(path) == "string" then
GameTooltip:SetOwner(this, "ANCHOR_RIGHT")
GameTooltip:SetText(IconKey(path), 1, 1, 1)
GameTooltip:Show()
end
end)
btn:SetScript("OnLeave", GameTooltip_Hide) btn:SetScript("OnLeave", GameTooltip_Hide)
iconButtons[i] = btn end
btn.iconIndex = icon.index
local path = provider:GetIconByIndex(icon.index)
btn.texture:SetTexture(path)
if IconKey(path) == IconKey(selectedIconPath) then
btn.backdrop:SetBackdropBorderColor(1, 0.82, 0, 1)
else
btn.backdrop:SetBackdropBorderColor(pfUI.cache.er, pfUI.cache.eg, pfUI.cache.eb, pfUI.cache.ea)
end end
end end
local view = CreateScrollBoxListGridView(ICON_GRID_COLS, 0, 0, 0, 4, ICON_BTN_PAD, ICON_BTN_PAD)
view:SetElementSize(ICON_BTN_SIZE, ICON_BTN_SIZE)
view:SetElementInitializer("Button", InitIconButton)
ScrollUtil.InitScrollBoxListWithScrollBar(grid.ScrollBox, grid.ScrollBar, view)
-- Rebuild the search-filtered index list (provider indices whose icon -- Rebuild the search-filtered index list (provider indices whose icon
-- basename contains the search text); nil when the search box is empty. -- basename contains the search text); nil when the search box is empty.
function RebuildFilter() function RebuildFilter()
@@ -1420,38 +1246,17 @@ function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
end end
end end
-- one grid entry per provider index the filter lets through, scrolled to the top
function RefreshIconGrid() function RefreshIconGrid()
EnsureProvider() EnsureProvider()
local numIcons = filtered and table.getn(filtered) or provider:GetNumIcons() if filtered then
local numRows = math.ceil(numIcons / ICON_GRID_COLS) grid.ScrollBox:SetDataProvider(CreateDataProviderWithAssignedKey(filtered, "index"))
FauxScrollFrame_Update(iconScroll, numRows, ICON_GRID_ROWS, ICON_BTN_SIZE + ICON_BTN_PAD) else
local offset = FauxScrollFrame_GetOffset(iconScroll) grid.ScrollBox:SetDataProvider(CreateDataProviderByIndexCount(provider:GetNumIcons()))
for i = 1, ICON_GRID_ROWS * ICON_GRID_COLS do
local listIdx = i + offset * ICON_GRID_COLS
local btn = iconButtons[i]
if listIdx <= numIcons then
btn:Show()
local providerIdx = filtered and filtered[listIdx] or listIdx
btn.iconIndex = providerIdx
local path = provider:GetIconByIndex(providerIdx)
btn.texture:SetTexture(path)
if IconKey(path) == IconKey(selectedIconPath) then
btn.backdrop:SetBackdropBorderColor(1, 0.82, 0, 1)
else
btn.backdrop:SetBackdropBorderColor(pfUI.cache.er, pfUI.cache.eg, pfUI.cache.eb, pfUI.cache.ea)
end
else
btn:Hide()
btn.iconIndex = nil
end
end end
parent.selectedPreview.tex:SetTexture(selectedIconPath) parent.selectedPreview.tex:SetTexture(selectedIconPath)
end end
iconScroll:SetScript("OnVerticalScroll", function()
FauxScrollFrame_OnVerticalScroll(ICON_BTN_SIZE + ICON_BTN_PAD, function() RefreshIconGrid() end)
end)
-- Search box (bottom-left) filters the grid by icon name. -- Search box (bottom-left) filters the grid by icon name.
parent.searchLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal") parent.searchLabel = parent:CreateFontString(nil, "OVERLAY", "GameFontNormal")
parent.searchLabel:SetPoint("BOTTOMLEFT", parent, "BOTTOMLEFT", 16, 18) parent.searchLabel:SetPoint("BOTTOMLEFT", parent, "BOTTOMLEFT", 16, 18)
@@ -1466,13 +1271,14 @@ function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
parent.search:SetScript("OnTextChanged", function() parent.search:SetScript("OnTextChanged", function()
searchText = strupper(strtrim(this:GetText())) searchText = strupper(strtrim(this:GetText()))
RebuildFilter() RebuildFilter()
scrollbar:SetValue(0)
RefreshIconGrid() RefreshIconGrid()
end) end)
-- Release the provider when the popup closes so its icon cache GCs. -- Release the provider when the popup closes so its icon cache GCs, and
-- the grid's entries that index into it.
parent:HookScript("OnHide", function() parent:HookScript("OnHide", function()
if provider then provider:Release(); provider = nil end if provider then provider:Release(); provider = nil end
grid.ScrollBox:RemoveDataProvider()
end) end)
local handle = { editbox = parent.editbox, search = parent.search } local handle = { editbox = parent.editbox, search = parent.search }
@@ -1480,15 +1286,13 @@ function pfUI.api.CreateIconPicker(name, parent, extraType, nameLabelText)
function handle.SetIcon(path) selectedIconPath = path or QUESTION_MARK end function handle.SetIcon(path) selectedIconPath = path or QUESTION_MARK end
function handle.Refresh() RefreshIconGrid() end function handle.Refresh() RefreshIconGrid() end
function handle.SetIconAreaShown(shown) function handle.SetIconAreaShown(shown)
local method = shown and "Show" or "Hide" grid:SetShown(shown)
iconScroll[method](iconScroll) parent.iconLabel:SetShown(shown)
for _, b in ipairs(iconButtons) do b[method](b) end parent.selectedLabel:SetShown(shown)
parent.iconLabel[method](parent.iconLabel) parent.selectedPreview:SetShown(shown)
parent.selectedLabel[method](parent.selectedLabel) filterDropdown:SetShown(shown)
parent.selectedPreview[method](parent.selectedPreview) parent.searchLabel:SetShown(shown)
filterDropdown[method](filterDropdown) parent.search:SetShown(shown)
parent.searchLabel[method](parent.searchLabel)
parent.search[method](parent.search)
end end
return handle return handle
end end
+105
View File
@@ -0,0 +1,105 @@
<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>
</Ui>
+237 -309
View File
@@ -10,10 +10,93 @@ pfUI.uf.frames = {}
-- Scans run back to back and consume the buffer before the next refill. -- Scans run back to back and consume the buffer before the next refill.
local auraSlots = {} local auraSlots = {}
-- Separate buffer for the tooltip handlers. They run from OnEnter, which can -- Aura block corner -> { icon anchor point, x direction, y direction, below frame }
-- fire while RefreshUnit is showing/hiding icons under the cursor, so they must local auraCorners = {
-- not share the refresh buffer. TOPLEFT = { "BOTTOMLEFT", 1, 1 },
local tooltipSlots = {} BOTTOMLEFT = { "TOPLEFT", 1, -1, true },
TOPRIGHT = { "BOTTOMRIGHT", -1, 1 },
BOTTOMRIGHT = { "TOPRIGHT", -1, -1, true },
}
-- Flows the shown icons of an aura block outward from the frame edge, starting
-- `offset` away from it (its own row gap when nil): `perrow` icons per row,
-- each row as tall as its largest icon. The first `icons.own` icons are the
-- player's (C_UnitAuras lists them first) and use `icons.ownsize`. Returns the
-- offset just past the block's last row, where a block sharing the same corner
-- continues.
local function LayoutAuraBlock(unit, icons, offset)
local corner = auraCorners[icons.pos]
local anchor = unit.config.portraitheight ~= "-1" and unit.hp or unit
if anchor == unit.hp and corner[4] then anchor = unit.power end
offset = offset or icons.gapy
local x, rowsize, col = 0, 0, 0
local i = 1
while icons[i] and icons[i]:IsShown() do
if col == icons.perrow then
offset = offset + rowsize + icons.gapy
x, rowsize, col = 0, 0, 0
end
local size = i <= icons.own and icons.ownsize or icons.size
icons[i]:SetSize(size, size)
icons[i]:ClearAllPoints()
icons[i]:SetPoint(corner[1], anchor, icons.pos, corner[2] * x, corner[3] * offset)
x = x + size + icons.gapx
if size > rowsize then rowsize = size end
col = col + 1
i = i + 1
end
if col > 0 then offset = offset + rowsize + icons.gapy end
return offset
end
-- Buffs and debuffs sharing a corner stack in one column: buffs first on
-- friendly units, debuffs first on neutral and hostile ones.
local function LayoutAuras(unit, unitstr)
local first, second = unit.buffs, unit.debuffs
if not UnitIsFriend("player", unitstr) then first, second = second, first end
if not first then first, second = second, nil end
if not first then return end
local offset = LayoutAuraBlock(unit, first)
if second then
LayoutAuraBlock(unit, second, second.pos == first.pos and offset or nil)
end
end
-- Returns the cooldown start and duration of an aura, 0, 0 when it has none.
-- Start is capped to now: talent-extended auras run past their Spell.dbc base
-- duration, and a start in the future trips the cooldown text's 2^32
-- wraparound branch.
local function AuraTimer(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
-- Starts the timers RefreshUnit stored on the shown icons of an aura block.
local function StartAuraTimers(icons)
if not icons then return end
local i = 1
while icons[i] and icons[i]:IsShown() do
local dur = icons[i].auraDuration
CooldownFrame_SetTimer(icons[i].cd, icons[i].auraStart, dur, dur > 0 and 1 or 0)
i = i + 1
end
end
-- ============================================================================ -- ============================================================================
-- GUID-based Roster Tracking for Smart Updates -- GUID-based Roster Tracking for Smart Updates
@@ -78,10 +161,6 @@ local glow2 = {
insets = {left = 0, right = 0, top = 0, bottom = 0}, insets = {left = 0, right = 0, top = 0, bottom = 0},
} }
local function DoNothing()
return
end
local function BuffOnEnter() local function BuffOnEnter()
local parent = this:GetParent() local parent = this:GetParent()
if not parent.label then return end if not parent.label then return end
@@ -119,32 +198,8 @@ local function DebuffOnEnter()
local unitstr = this:GetParent().label .. this:GetParent().id local unitstr = this:GetParent().label .. this:GetParent().id
GameTooltip:SetOwner(this, "ANCHOR_BOTTOMRIGHT") GameTooltip:SetOwner(this, "ANCHOR_BOTTOMRIGHT")
if this:GetParent().label ~= "player" then -- C_UnitAuras lists the player's own auras first, so the selfdebuff
local parent = this:GetParent() -- (HARMFUL|PLAYER) list is a prefix of the HARMFUL list: same index.
-- selfdebuff filters the displayed list to player-cast harmful auras, but
-- SetUnitAura's index has to be into the unfiltered HARMFUL list. Look up
-- the displayed aura via the PLAYER filter, then find its position in the
-- unfiltered list by name + sourceGUID.
--
-- The unfiltered 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
-- reports those as harmful too. So enumerate however many the unit has.
if parent.config and parent.config.selfdebuff == "1" then
local ownAura = C_UnitAuras.GetAuraDataByIndex(unitstr, this.id, "HARMFUL|PLAYER")
if ownAura then
local n = ScanAuraSlots(unitstr, "HARMFUL", tooltipSlots)
for i = 1, n do
local check = C_UnitAuras.GetAuraDataBySlot(unitstr, tooltipSlots[i])
if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
GameTooltip:SetUnitAura(unitstr, i, "HARMFUL")
return
end
end
end
end
end
GameTooltip:SetUnitAura(unitstr, this.id, "HARMFUL") GameTooltip:SetUnitAura(unitstr, this.id, "HARMFUL")
end end
@@ -180,7 +235,50 @@ function pfUI.api.GetUnitStats(unitstr)
end end
local aggrodata = { } local aggrodata = { }
local aggroScan = nil -- static { u, t, tt } triples, built once so the hot scan allocates nothing
-- every unit whose target or target's target UnitHasAggro checks, as static
-- { u, t, tt } triples so the hot scan allocates nothing
local aggroScan = { }
do
local function add(u)
local t = u .. "target"
table.insert(aggroScan, { u = u, t = t, tt = t .. "target" })
end
add("pet")
add("player")
add("target")
add("mouseover")
add("focus")
add("focustarget")
add("focustargettarget")
add("pettarget")
add("playertarget")
add("targettarget")
add("mouseovertarget")
add("targettargettarget")
for i=1,4 do
add("party" .. i)
add("party" .. i .. "target")
add("partypet" .. i)
add("partypet" .. i .. "target")
end
for i=1,40 do
add("raid" .. i)
add("raid" .. i .. "target")
add("raidpet" .. i)
add("raidpet" .. i .. "target")
add("nameplate" .. i)
add("nameplate" .. i .. "target")
end
end
function pfUI.api.UnitHasAggro(unit) function pfUI.api.UnitHasAggro(unit)
local now = GetTime() local now = GetTime()
local data = aggrodata[unit] local data = aggrodata[unit]
@@ -195,16 +293,6 @@ function pfUI.api.UnitHasAggro(unit)
data.state = 0 data.state = 0
if UnitExists(unit) and UnitIsFriend(unit, "player") then if UnitExists(unit) and UnitIsFriend(unit, "player") then
-- pfValidUnits never changes after load, so precompute the "<u>target" /
-- "<u>targettarget" token strings once instead of concatenating per call.
if not aggroScan then
aggroScan = {}
for u in pairs(pfValidUnits) do
local t = u .. "target"
table.insert(aggroScan, { u = u, t = t, tt = t .. "target" })
end
end
for i = 1, table.getn(aggroScan) do for i = 1, table.getn(aggroScan) do
local s = aggroScan[i] local s = aggroScan[i]
if UnitExists(s.t) and UnitIsUnit(s.t, unit) and UnitCanAttack(s.u, unit) then if UnitExists(s.t) and UnitIsUnit(s.t, unit) and UnitCanAttack(s.u, unit) then
@@ -219,27 +307,6 @@ function pfUI.api.UnitHasAggro(unit)
return data.state return data.state
end end
pfUI.uf.glow = CreateFrame("Frame", nil, UIParent)
pfUI.uf.glow:SetScript("OnUpdate", function()
local fpsmod = GetFramerate() / 30
if not this.val or this.val >= .8 then
this.mod = -0.01 / fpsmod
elseif this.val <= .4 then
this.mod = 0.01 / fpsmod
end
this.val = this.val + this.mod
end)
pfUI.uf.glow.mod = 0
pfUI.uf.glow.val = 0.6
function pfUI.uf.glow.UpdateGlowAnimation()
local val = pfUI.uf.glow.val or 0.6
if val < 0.4 then val = 0.4 end
if val > 0.8 then val = 0.8 end
this:SetAlpha(val)
end
function pfUI.uf:UpdateVisibility() function pfUI.uf:UpdateVisibility()
local self = self or this local self = self or this
@@ -313,10 +380,15 @@ function pfUI.uf:UpdateVisibility()
self._label, self._id = nil, nil self._label, self._id = nil, nil
end end
local unitstr = ("%s%s"):format(self.label or "", self.id or "") -- this runs for every frame five times a second, so only touch the
self.unitstr = unitstr ~= "" and unitstr or nil -- attribute when the unit actually changed
self:SetAttribute("unit", self.unitstr) local unitstr = self.label .. self.id
local visibility = ("[target=%s,exists] show; hide"):format(unitstr) if unitstr ~= self.unitstr then
self.unitstr = unitstr
self:SetAttribute("unit", unitstr)
end
-- anything but "show"/"hide" means "show if the unit exists"
local visibility = "exists"
-- Group frames are redundant when the group is already shown as a raid grid: -- Group frames are redundant when the group is already shown as a raid grid:
-- either an actual raid, or a party promoted to the raid grid via -- either an actual raid, or a party promoted to the raid grid via
@@ -355,9 +427,7 @@ function pfUI.uf:UpdateVisibility()
self:RegisterUnitEvents(visibility ~= "hide" and self.unitstr or nil) self:RegisterUnitEvents(visibility ~= "hide" and self.unitstr or nil)
-- vanilla visibility -- vanilla visibility
if self.unitname then if visibility == "hide" then
self:Show()
elseif visibility == "hide" then
self:Hide() self:Hide()
elseif visibility == "show" then elseif visibility == "show" then
self:Show() self:Show()
@@ -425,9 +495,12 @@ function pfUI.uf:UpdateConfig()
local C = pfUI_config local C = pfUI_config
local rawborder, default_border = GetBorderSize("unitframes") local rawborder, default_border = GetBorderSize("unitframes")
local spacing = f.config.pspace * GetPerfectPixel() local spacing = f.config.pspace * GetPerfectPixel()
-- aura icon backdrops sit outside the icon, so gaps clear both borders
local aura_border = (C.appearance.border.force_blizz == "1" and 1 or 2) * default_border
local cooldown_text = tonumber(f.config.cooldown_text) local cooldown_text = tonumber(f.config.cooldown_text)
local cooldown_anim = tonumber(f.config.cooldown_anim) local cooldown_anim = tonumber(f.config.cooldown_anim)
local cooldown_reverse = tonumber(f.config.cooldown_reverse) or 0
local relative_point = "BOTTOM" local relative_point = "BOTTOM"
if f.config.panchor == "TOPLEFT" then if f.config.panchor == "TOPLEFT" then
@@ -451,7 +524,6 @@ function pfUI.uf:UpdateConfig()
f.glow:SetBackdrop(glow2) f.glow:SetBackdrop(glow2)
f.glow:SetPoint("TOPLEFT", f, "TOPLEFT", -6 - default_border,6 + default_border) f.glow:SetPoint("TOPLEFT", f, "TOPLEFT", -6 - default_border,6 + default_border)
f.glow:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 6 + default_border,-6 - default_border) f.glow:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 6 + default_border,-6 - default_border)
f.glow:SetScript("OnUpdate", pfUI.uf.glow.UpdateGlowAnimation)
f.glow:Hide() f.glow:Hide()
f.combat:SetSize(tonumber(f.config.squaresize), tonumber(f.config.squaresize)) f.combat:SetSize(tonumber(f.config.squaresize), tonumber(f.config.squaresize))
@@ -466,6 +538,8 @@ function pfUI.uf:UpdateConfig()
if tonumber(f.config.height) < 0 then f.hp:Hide() end if tonumber(f.config.height) < 0 then f.hp:Hide() end
pfUI.api.CreateBackdrop(f.hp, default_border) pfUI.api.CreateBackdrop(f.hp, default_border)
-- one level above the backdrop for the bar's background, one more for its fill
f.hp.bar:SetFrameLevel(f.hp.backdrop:GetFrameLevel() + 2)
f.hp.bar:SetStatusBarTexture(pfUI.media[f.config.bartexture]) f.hp.bar:SetStatusBarTexture(pfUI.media[f.config.bartexture])
f.hp.bar:SetAllPoints(f.hp) f.hp.bar:SetAllPoints(f.hp)
if f.config.verticalbar == "1" then if f.config.verticalbar == "1" then
@@ -480,7 +554,7 @@ function pfUI.uf:UpdateConfig()
if custombg == "1" then if custombg == "1" then
local cr, cg, cb, ca = GetStringColor(custombgcolor) local cr, cg, cb, ca = GetStringColor(custombgcolor)
cr, cg, cb, ca = tonumber(cr), tonumber(cg), tonumber(cb), tonumber(ca) cr, cg, cb, ca = tonumber(cr), tonumber(cg), tonumber(cb), tonumber(ca)
f.hp.bar:SetStatusBarBackgroundTexture(cr,cg,cb,ca) f.hp.bar:SetStatusBarBackgroundColor(cr,cg,cb,ca)
end end
f.power:ClearAllPoints() f.power:ClearAllPoints()
@@ -489,7 +563,7 @@ function pfUI.uf:UpdateConfig()
if tonumber(f.config.pheight) < 0 then f.power:Hide() end if tonumber(f.config.pheight) < 0 then f.power:Hide() end
pfUI.api.CreateBackdrop(f.power, default_border) pfUI.api.CreateBackdrop(f.power, default_border)
f.power.bar:SetFrameLevel(f.power.backdrop:GetFrameLevel() + 1) f.power.bar:SetFrameLevel(f.power.backdrop:GetFrameLevel() + 2)
f.power.bar:SetStatusBarTexture(pfUI.media[f.config.pbartexture]) f.power.bar:SetStatusBarTexture(pfUI.media[f.config.pbartexture])
f.power.bar:SetAllPoints(f.power) f.power.bar:SetAllPoints(f.power)
@@ -499,7 +573,7 @@ function pfUI.uf:UpdateConfig()
if custompbg == "1" then if custompbg == "1" then
local cr, cg, cb, ca = GetStringColor(custompbgcolor) local cr, cg, cb, ca = GetStringColor(custompbgcolor)
cr, cg, cb, ca = tonumber(cr), tonumber(cg), tonumber(cb), tonumber(ca) cr, cg, cb, ca = tonumber(cr), tonumber(cg), tonumber(cb), tonumber(ca)
f.power.bar:SetStatusBarBackgroundTexture(cr,cg,cb,ca) f.power.bar:SetStatusBarBackgroundColor(cr,cg,cb,ca)
end end
local fontname, fontsize, fontstyle local fontname, fontsize, fontstyle
@@ -757,13 +831,17 @@ function pfUI.uf:UpdateConfig()
f.buffs = nil f.buffs = nil
else else
f.buffs = f.buffs or {} f.buffs = f.buffs or {}
f.buffs.pos = f.config.buffs
f.buffs.size = tonumber(f.config.buffsize)
f.buffs.ownsize = f.config.ownbuffsize == "-1" and f.buffs.size or tonumber(f.config.ownbuffsize)
f.buffs.perrow = tonumber(f.config.buffperrow)
f.buffs.gapx = aura_border + tonumber(f.config.buffspacingx)
f.buffs.gapy = aura_border + tonumber(f.config.buffspacingy)
f.buffs.own = 0
for i=1, 32 do for i=1, 32 do
if i > tonumber(f.config.bufflimit) then break end if i > tonumber(f.config.bufflimit) then break end
local perrow = f.config.buffperrow
local row = floor((i-1) / perrow)
f.buffs[i] = f.buffs[i] or CreateFrame("Button", "pfUI" .. f.fname .. "Buff" .. i, f) f.buffs[i] = f.buffs[i] or CreateFrame("Button", "pfUI" .. f.fname .. "Buff" .. i, f)
f.buffs[i].texture = f.buffs[i].texture or f.buffs[i]:CreateTexture() f.buffs[i].texture = f.buffs[i].texture or f.buffs[i]:CreateTexture()
f.buffs[i].texture:SetTexCoord(.08, .92, .08, .92) f.buffs[i].texture:SetTexCoord(.08, .92, .08, .92)
@@ -778,61 +856,13 @@ function pfUI.uf:UpdateConfig()
f.buffs[i]:SetFrameLevel(12) f.buffs[i]:SetFrameLevel(12)
f.buffs[i]:RegisterForClicks("RightButtonUp") f.buffs[i]:RegisterForClicks("RightButtonUp")
f.buffs[i]:ClearAllPoints()
local invert_h, invert_v, af f.buffs[i].cd = f.buffs[i].cd or CreateFrame("Cooldown", f.buffs[i]:GetName() .. "Cooldown", f.buffs[i], "CooldownFrameTemplate")
if f.config.buffs == "TOPLEFT" then
invert_h = 1
invert_v = 1
af = "BOTTOMLEFT"
elseif f.config.buffs == "BOTTOMLEFT" then
invert_h = -1
invert_v = 1
af = "TOPLEFT"
elseif f.config.buffs == "TOPRIGHT" then
invert_h = 1
invert_v = -1
af = "BOTTOMRIGHT"
elseif f.config.buffs == "BOTTOMRIGHT" then
invert_h = -1
invert_v = -1
af = "TOPRIGHT"
end
local anchor = f.config.portraitheight ~= "-1" and f.hp or f
if anchor == f.hp and (f.config.buffs == "BOTTOMLEFT" or f.config.buffs == "BOTTOMRIGHT") then
anchor = f.power
end
local multiply = C.appearance.border.force_blizz == "1" and 1 or 2
f.buffs[i]:SetPoint(af, anchor, f.config.buffs,
invert_v * (i-1-row*perrow)*(multiply*default_border + f.config.buffsize + 1),
invert_h * (row*(multiply*default_border + f.config.buffsize + 1) + (multiply*default_border + 1)))
f.buffs[i]:SetSize(f.config.buffsize, f.config.buffsize)
-- Create CD frame if it doesn't exist
if not f.buffs[i].cd then
if cooldown_anim == 1 then
-- Animation enabled: Use Model frame with CooldownFrameTemplate
f.buffs[i].cd = CreateFrame("Model", f.buffs[i]:GetName() .. "Cooldown", f.buffs[i], "CooldownFrameTemplate")
else
-- Animation disabled: Use regular Frame with dummy functions
f.buffs[i].cd = CreateFrame("Frame", f.buffs[i]:GetName() .. "Cooldown", f.buffs[i])
f.buffs[i].cd.AdvanceTime = DoNothing
f.buffs[i].cd.SetSequence = DoNothing
f.buffs[i].cd.SetSequenceTime = DoNothing
end
end
-- Always update CD properties (in case size changed)
local cdScale = f.config.buffsize / 32
f.buffs[i].cd:ClearAllPoints()
f.buffs[i].cd:SetScale(cdScale)
f.buffs[i].cd:SetAllPoints(f.buffs[i])
f.buffs[i].cd:SetFrameLevel(14) f.buffs[i].cd:SetFrameLevel(14)
f.buffs[i].cd.pfCooldownType = "ALL" f.buffs[i].cd.pfCooldownType = "ALL"
f.buffs[i].cd.pfCooldownStyleText = cooldown_text f.buffs[i].cd.pfCooldownStyleText = cooldown_text
f.buffs[i].cd.pfCooldownStyleAnimation = cooldown_anim f.buffs[i].cd.pfCooldownStyleAnimation = cooldown_anim
f.buffs[i].cd.pfCooldownReverse = cooldown_reverse
f.buffs[i].cd:SetAlpha(cooldown_anim == 1 and 1 or 0) f.buffs[i].cd:SetAlpha(cooldown_anim == 1 and 1 or 0)
-- immediately show/hide existing cooldown text -- immediately show/hide existing cooldown text
@@ -861,6 +891,13 @@ function pfUI.uf:UpdateConfig()
f.debuffs = nil f.debuffs = nil
else else
f.debuffs = f.debuffs or {} f.debuffs = f.debuffs or {}
f.debuffs.pos = f.config.debuffs
f.debuffs.size = tonumber(f.config.debuffsize)
f.debuffs.ownsize = f.config.owndebuffsize == "-1" and f.debuffs.size or tonumber(f.config.owndebuffsize)
f.debuffs.perrow = tonumber(f.config.debuffperrow)
f.debuffs.gapx = aura_border + tonumber(f.config.debuffspacingx)
f.debuffs.gapy = aura_border + tonumber(f.config.debuffspacingy)
f.debuffs.own = 0
for i=1, 32 do for i=1, 32 do
if i > tonumber(f.config.debufflimit) then break end if i > tonumber(f.config.debufflimit) then break end
@@ -879,33 +916,14 @@ function pfUI.uf:UpdateConfig()
f.debuffs[i]:SetFrameLevel(12) f.debuffs[i]:SetFrameLevel(12)
f.debuffs[i]:RegisterForClicks("RightButtonUp") f.debuffs[i]:RegisterForClicks("RightButtonUp")
f.debuffs[i]:ClearAllPoints()
f.debuffs[i]:SetSize(f.config.debuffsize, f.config.debuffsize)
f.debuffs[i]:SetNormalTexture(nil) f.debuffs[i]:SetNormalTexture(nil)
-- Create CD frame if it doesn't exist f.debuffs[i].cd = f.debuffs[i].cd or CreateFrame("Cooldown", f.debuffs[i]:GetName() .. "Cooldown", f.debuffs[i], "CooldownFrameTemplate")
if not f.debuffs[i].cd then
if cooldown_anim == 1 then
-- Animation enabled: Use Model frame with CooldownFrameTemplate
f.debuffs[i].cd = CreateFrame("Model", f.debuffs[i]:GetName() .. "Cooldown", f.debuffs[i], "CooldownFrameTemplate")
else
-- Animation disabled: Use regular Frame with dummy functions
f.debuffs[i].cd = CreateFrame("Frame", f.debuffs[i]:GetName() .. "Cooldown", f.debuffs[i])
f.debuffs[i].cd.AdvanceTime = DoNothing
f.debuffs[i].cd.SetSequence = DoNothing
f.debuffs[i].cd.SetSequenceTime = DoNothing
end
end
-- Always update CD properties (in case size changed)
local cdScale = f.config.debuffsize / 32
f.debuffs[i].cd:ClearAllPoints()
f.debuffs[i].cd:SetScale(cdScale)
f.debuffs[i].cd:SetAllPoints(f.debuffs[i])
f.debuffs[i].cd:SetFrameLevel(14) f.debuffs[i].cd:SetFrameLevel(14)
f.debuffs[i].cd.pfCooldownType = "ALL" f.debuffs[i].cd.pfCooldownType = "ALL"
f.debuffs[i].cd.pfCooldownStyleText = cooldown_text f.debuffs[i].cd.pfCooldownStyleText = cooldown_text
f.debuffs[i].cd.pfCooldownStyleAnimation = cooldown_anim f.debuffs[i].cd.pfCooldownStyleAnimation = cooldown_anim
f.debuffs[i].cd.pfCooldownReverse = cooldown_reverse
f.debuffs[i].cd:SetAlpha(cooldown_anim == 1 and 1 or 0) f.debuffs[i].cd:SetAlpha(cooldown_anim == 1 and 1 or 0)
-- immediately show/hide existing cooldown text -- immediately show/hide existing cooldown text
@@ -943,32 +961,6 @@ function pfUI.uf.OnShow()
pfUI.uf:RefreshUnit(this, "base") pfUI.uf:RefreshUnit(this, "base")
end end
-- GUID-keyed aura start-time tracker, fed by Nampower's BUFF_ADDED_OTHER /
-- BUFF_REMOVED_OTHER. Non-player units have aura.expirationTime == 0 (server
-- doesn't broadcast time), so we reconstruct the swirl from "when we saw it
-- applied" + aura.duration (Spell.dbc base). Only auras we actually witnessed
-- being cast get tracked — pre-existing auras (already on a unit when you
-- target them) intentionally show no timer rather than a fabricated one.
pfUI.uf.aura_starts = {} -- {[guid] = {[spellId] = startTime}}
local auraTracker = CreateFrame("Frame", "pfUF_AuraTracker", UIParent)
auraTracker:RegisterEvent("BUFF_ADDED_OTHER")
auraTracker:RegisterEvent("BUFF_REMOVED_OTHER")
auraTracker:SetScript("OnEvent", function()
-- Nampower arg layout: arg1=guid, arg3=spellId. State code 0=added, 1=removed,
-- 2=modified; we treat any added/modified as "reset start = now" and let the
-- REMOVED event clear the entry.
if not arg1 or not arg3 or arg3 == 0 then return end
if event == "BUFF_REMOVED_OTHER" then
if pfUI.uf.aura_starts[arg1] then
pfUI.uf.aura_starts[arg1][arg3] = nil
end
else
pfUI.uf.aura_starts[arg1] = pfUI.uf.aura_starts[arg1] or {}
pfUI.uf.aura_starts[arg1][arg3] = GetTime()
end
end)
function pfUI.uf.OnEvent() function pfUI.uf.OnEvent()
-- Handle shutdown to prevent crash 132 -- Handle shutdown to prevent crash 132
if event == "PLAYER_LOGOUT" then if event == "PLAYER_LOGOUT" then
@@ -1059,6 +1051,8 @@ function pfUI.uf.OnEvent()
this.update_pvp = true this.update_pvp = true
elseif event == "UNIT_COMBAT" then elseif event == "UNIT_COMBAT" then
CombatFeedback_OnCombatEvent(arg2, arg3, arg4, arg5) CombatFeedback_OnCombatEvent(arg2, arg3, arg4, arg5)
elseif event == "INCOMING_RESURRECT_CHANGED" then
this.update_indicators = true
else else
this.update_base = true this.update_base = true
end end
@@ -1140,7 +1134,18 @@ function pfUI.uf.OnUpdate()
end end
else else
pfUI.uf:RefreshUnitState(this) pfUI.uf:RefreshUnitState(this)
pfUI.uf:RefreshIndicators(this) -- group frames get their leader/loot/raid mark icons refreshed by
-- events through update_indicators, so polling them is only a safety
-- net; frames whose unit changes without events keep polling per tick
local label = this.label
if label == "raid" or label == "party" or label == "raidpet" or label == "partypet" then
if (this.lastIndicatorPoll or 0) < now then
this.lastIndicatorPoll = now + 3
pfUI.uf:RefreshIndicators(this)
end
else
pfUI.uf:RefreshIndicators(this)
end
end end
if this.config and this.config.glowaggro == "1" and pfUI.api.UnitHasAggro(unitstr) > 0 then if this.config and this.config.glowaggro == "1" and pfUI.api.UnitHasAggro(unitstr) > 0 then
@@ -1153,9 +1158,18 @@ function pfUI.uf.OnUpdate()
this.glow:Hide() this.glow:Hide()
end end
-- update everything on eventless frames (targettarget, etc) -- update eventless frames (targettarget, etc). A full refresh rescans
-- every aura and the portrait, so only do it when the unit behind the
-- frame changes or once a second; other ticks refresh the bars only.
if this.tick then if this.tick then
pfUI.uf:RefreshUnit(this, "all") local guid = UnitGUID(unitstr)
if guid ~= this.tickGuid or (this.tickFull or 0) < now then
this.tickGuid = guid
this.tickFull = now + 1
pfUI.uf:RefreshUnit(this, "all")
else
pfUI.uf:RefreshUnit(this, "base")
end
end end
end end
@@ -1209,10 +1223,6 @@ function pfUI.uf.OnUpdate()
this.incHeal:Hide() this.incHeal:Hide()
end end
end end
-- update ressurections
local ress = libpredict:UnitHasIncomingResurrection(unit)
this.ressIcon:SetShown(ress and UnitIsDeadOrGhost(unit))
end end
end end
end end
@@ -1264,8 +1274,6 @@ function pfUI.uf.OnUpdate()
end end
end end
if not this.label or this.label == "" then return end
-- update portrait on first visible frame -- update portrait on first visible frame
if this.portrait and this.portrait.model and this.portrait.model.update then if this.portrait and this.portrait.model and this.portrait.model.update then
this.portrait.model.lastUnit = UnitName(this.portrait.model.update) this.portrait.model.lastUnit = UnitName(this.portrait.model.update)
@@ -1292,6 +1300,7 @@ local UNIT_EVENTS = {
"UNIT_PORTRAIT_UPDATE", "UNIT_MODEL_CHANGED", "UNIT_PORTRAIT_UPDATE", "UNIT_MODEL_CHANGED",
"UNIT_FACTION", "UNIT_FACTION",
"UNIT_AURA", -- frame=buff, frame=debuff "UNIT_AURA", -- frame=buff, frame=debuff
"INCOMING_RESURRECT_CHANGED", -- frame=ressIcon
} }
-- Point this frame's unit-event subscriptions at `unitstr`, or drop them when -- Point this frame's unit-event subscriptions at `unitstr`, or drop them when
@@ -1352,11 +1361,7 @@ end
-- ============================================================ -- ============================================================
function pfUI.uf.OnClick() function pfUI.uf.OnClick()
if not this.label and this.unitname then pfUI.uf:ClickAction(arg1)
TargetByName(this.unitname, true)
else
pfUI.uf:ClickAction(arg1)
end
end end
function pfUI.uf:ClickAction(button) function pfUI.uf:ClickAction(button)
@@ -1453,13 +1458,6 @@ function pfUI.uf:CreateUnitFrame(unit, id, config, tick)
f.config = config or pfUI_config.unitframes.fallback f.config = config or pfUI_config.unitframes.fallback
f.tick = tick f.tick = tick
-- disable events for unknown unitstrings
if not pfValidUnits[strlower(unit) .. id] then
f.unitname = unit
f.label, f.id = "", ""
f.RegisterEvent = function() return end
end
CreateBackdropShadow(f) CreateBackdropShadow(f)
f.hp = CreateFrame("Frame",nil, f) f.hp = CreateFrame("Frame",nil, f)
@@ -1482,7 +1480,18 @@ function pfUI.uf:CreateUnitFrame(unit, id, config, tick)
end end
f.glow = CreateFrame("Frame", nil, f) f.glow = CreateFrame("Frame", nil, f)
f.combat = CreateFrame("Frame", nil, f.hp.bar) -- Pulse between .8 and .4 for good. The group only advances while the glow
-- is shown, so a hidden glow costs nothing.
f.glow:SetAlpha(.8)
f.glow.pulse = f.glow:CreateAnimationGroup()
f.glow.pulse:SetLooping("BOUNCE")
local fade = f.glow.pulse:CreateAnimation("Alpha")
fade:SetChange(-.4)
fade:SetDuration(1.3)
fade:SetSmoothing("IN_OUT")
f.glow.pulse:Play()
f.combat =CreateFrame("Frame", nil, f.hp.bar)
f.combat.tex = f.combat:CreateTexture(nil, "OVERLAY") f.combat.tex = f.combat:CreateTexture(nil, "OVERLAY")
f.combat.tex:SetAllPoints() f.combat.tex:SetAllPoints()
@@ -1499,7 +1508,7 @@ function pfUI.uf:CreateUnitFrame(unit, id, config, tick)
f.incHeal = CreateFrame("Frame", nil, f.hp) f.incHeal = CreateFrame("Frame", nil, f.hp)
-- Texture lives on hp.bar for correct draw order: -- Texture lives on hp.bar for correct draw order:
-- hp.bar.bg (BACKGROUND) < incHeal (BORDER) < hp.bar.bar (NORMAL) -- hp.bar.bg (a level below) < incHeal (BORDER) < hp.bar's fill (ARTWORK)
f.incHeal.texture = f.hp.bar:CreateTexture(nil, "BORDER") f.incHeal.texture = f.hp.bar:CreateTexture(nil, "BORDER")
f.incHeal.texture:SetAllPoints(f.incHeal) f.incHeal.texture:SetAllPoints(f.incHeal)
-- Override Show/Hide since texture lives on hp.bar, not incHeal -- Override Show/Hide since texture lives on hp.bar, not incHeal
@@ -1565,9 +1574,7 @@ function pfUI.uf:CreateUnitFrame(unit, id, config, tick)
f:Hide() f:Hide()
end end
if f.label ~= "" then f:SetAttribute("unit", f.label .. f.id)
f:SetAttribute("unit", f.label .. f.id)
end
-- register frame for clique -- register frame for clique
_G.ClickCastFrames = ClickCastFrames or {} _G.ClickCastFrames = ClickCastFrames or {}
@@ -1641,6 +1648,10 @@ function pfUI.uf:RefreshIndicators(unit)
unit.pvpIcon:SetShown(unit.config.showPVP == "1" and UnitIsPVP(unitstr)) unit.pvpIcon:SetShown(unit.config.showPVP == "1" and UnitIsPVP(unitstr))
end end
if unit.ressIcon then -- Resurrection Icon
unit.ressIcon:SetShown(libpredict:UnitHasResurrection(unitstr))
end
if unit.restIcon and unit:GetName() == "pfPlayer" then -- Rest Icon if unit.restIcon and unit:GetName() == "pfPlayer" then -- Rest Icon
unit.restIcon:SetShown(C.unitframes.player.showRest == "1" and UnitIsUnit(unitstr, "player") and IsResting()) unit.restIcon:SetShown(C.unitframes.player.showRest == "1" and UnitIsUnit(unitstr, "player") and IsResting())
end end
@@ -1752,78 +1763,23 @@ function pfUI.uf:RefreshUnit(unit, component)
unit.buffs[i].stacks:SetText("") unit.buffs[i].stacks:SetText("")
end end
if expirationTime > 0 then unit.buffs[i].auraStart, unit.buffs[i].auraDuration = AuraTimer(duration, expirationTime)
-- pfUI's cooldown text falls into a 2^32 wraparound branch when start > GetTime(),
-- which happens for talent-extended buffs where the real duration exceeds the
-- Spell.dbc base. Anchor start to now in that case to keep the remaining math sane.
local now = GetTime()
local start = expirationTime - duration
local dur = duration
if start > now or dur <= 0 then
start, dur = now, expirationTime - now
end
if dur > 0 then
CooldownFrame_SetTimer(unit.buffs[i].cd, start, dur, 1)
else
CooldownFrame_SetTimer(unit.buffs[i].cd, 0, 0, 0)
end
elseif duration > 0 then
local guid = UnitGUID(unitstr)
local guidStarts = guid and pfUI.uf.aura_starts[guid]
local start = guidStarts and guidStarts[spellId]
if start then
CooldownFrame_SetTimer(unit.buffs[i].cd, start, duration, 1)
else
CooldownFrame_SetTimer(unit.buffs[i].cd, 0, 0, 0)
end
else
CooldownFrame_SetTimer(unit.buffs[i].cd, 0, 0, 0)
end
else else
unit.buffs[i]:Hide() unit.buffs[i]:Hide()
end end
end end
-- own buffs lead the list; count them only when they're drawn larger
if unit.buffs.ownsize ~= unit.buffs.size then
unit.buffs.own = ScanAuraSlots(unitstr, "HELPFUL|PLAYER", auraSlots, unit.config.bufflimit)
end
end end
-- debuffs -- debuffs
if unit.debuffs and ( component == "all" or component == "aura" ) then if unit.debuffs and ( component == "all" or component == "aura" ) then
local texture, stacks, dtype local texture, stacks, dtype
local perrow = unit.config.debuffperrow
local bperrow = unit.config.buffperrow
local selfdebuff = unit.config.selfdebuff local selfdebuff = unit.config.selfdebuff
local invert_h, invert_v, af
if unit.config.debuffs == "TOPLEFT" then
invert_h = 1
invert_v = 1
af = "BOTTOMLEFT"
elseif unit.config.debuffs == "BOTTOMLEFT" then
invert_h = -1
invert_v = 1
af = "TOPLEFT"
elseif unit.config.debuffs == "TOPRIGHT" then
invert_h = 1
invert_v = -1
af = "BOTTOMRIGHT"
elseif unit.config.debuffs == "BOTTOMRIGHT" then
invert_h = -1
invert_v = -1
af = "TOPRIGHT"
end
local buffrow, reposition = 0, ( component == "all" and true or nil )
if unit.config.buffs == unit.config.debuffs then
if unit.buffs[0*bperrow+1] and unit.buffs[0*bperrow+1]:IsShown() then buffrow = buffrow + 1 end
if unit.buffs[1*bperrow+1] and unit.buffs[1*bperrow+1]:IsShown() then buffrow = buffrow + 1 end
if unit.buffs[2*bperrow+1] and unit.buffs[2*bperrow+1]:IsShown() then buffrow = buffrow + 1 end
if unit.buffs[3*bperrow+1] and unit.buffs[3*bperrow+1]:IsShown() then buffrow = buffrow + 1 end
end
if buffrow ~= unit.lastbuffrow then
unit.lastbuffrow = buffrow
reposition = true
end
-- selfdebuff narrows to player-cast harmful auras via the PLAYER filter. -- selfdebuff narrows to player-cast harmful auras via the PLAYER filter.
-- Player-frame debuffs aren't gated on it (it'd hide most party-applied -- Player-frame debuffs aren't gated on it (it'd hide most party-applied
-- effects on you). One GetAuraSlots enumeration per refresh; the i-th slot -- effects on you). One GetAuraSlots enumeration per refresh; the i-th slot
@@ -1834,19 +1790,6 @@ function pfUI.uf:RefreshUnit(unit, component)
for i=1, unit.config.debufflimit do for i=1, unit.config.debufflimit do
if not unit.debuffs[i] then break end if not unit.debuffs[i] then break end
local row = floor((i-1) / unit.config.debuffperrow)
if reposition then
local anchor = unit.config.portraitheight ~= "-1" and unit.hp or unit
if anchor == unit.hp and (unit.config.debuffs == "BOTTOMLEFT" or unit.config.debuffs == "BOTTOMRIGHT") then
anchor = unit.power
end
local multiply = C.appearance.border.force_blizz == "1" and 1 or 2
unit.debuffs[i]:SetPoint(af, anchor, unit.config.debuffs,
invert_v * (i-1-row*perrow)*(multiply*default_border + unit.config.debuffsize + 1),
invert_h * ((row+buffrow)*(multiply*default_border + unit.config.debuffsize + 1) + (multiply*default_border + 1)))
end
-- positional read by slot id allocates nothing -- positional read by slot id allocates nothing
local name, icon, count, dispelType, duration, expirationTime = C_UnitAuras.UnitAuraBySlot(unitstr, auraSlots[i]) local name, icon, count, dispelType, duration, expirationTime = C_UnitAuras.UnitAuraBySlot(unitstr, auraSlots[i])
if name then if name then
@@ -1863,24 +1806,7 @@ function pfUI.uf:RefreshUnit(unit, component)
if texture then if texture then
unit.debuffs[i]:Show() unit.debuffs[i]:Show()
if expirationTime > 0 then unit.debuffs[i].auraStart, unit.debuffs[i].auraDuration = AuraTimer(duration, expirationTime)
-- Cap start to now so talent-extended debuffs (expirationTime past
-- the dbc base duration) don't push start into the future and trip
-- CooldownFrame_SetTimer's 2^32-wraparound branch.
local now = GetTime()
local start = expirationTime - duration
local dur = duration
if start > now or dur <= 0 then
start, dur = now, expirationTime - now
end
if dur > 0 then
CooldownFrame_SetTimer(unit.debuffs[i].cd, start, dur, 1)
else
CooldownFrame_SetTimer(unit.debuffs[i].cd, 0, 0, 0)
end
else
CooldownFrame_SetTimer(unit.debuffs[i].cd, 0, 0, 0)
end
if stacks > 1 then if stacks > 1 then
unit.debuffs[i].stacks:SetText(stacks) unit.debuffs[i].stacks:SetText(stacks)
@@ -1891,6 +1817,18 @@ function pfUI.uf:RefreshUnit(unit, component)
unit.debuffs[i]:Hide() unit.debuffs[i]:Hide()
end end
end end
-- own debuffs lead the list; count them only when they're drawn larger
if unit.debuffs.ownsize ~= unit.debuffs.size then
unit.debuffs.own = ScanAuraSlots(unitstr, "HARMFUL|PLAYER", auraSlots, unit.config.debufflimit)
end
end
-- timers start after the layout so each cooldown text is sized to its icon
if component == "all" or component == "aura" then
LayoutAuras(unit, unitstr)
StartAuraTimers(unit.buffs)
StartAuraTimers(unit.debuffs)
end end
-- indicators -- indicators
@@ -2321,7 +2259,7 @@ function pfUI.uf:AddIcon(frame, pos, icon, timeleft, stacks, start, duration)
if not frame.icon[pos] then if not frame.icon[pos] then
frame.icon[pos] = CreateFrame("Frame", nil, frame.icon) frame.icon[pos] = CreateFrame("Frame", nil, frame.icon)
frame.icon[pos]:SetParent(frame) frame.icon[pos]:SetParent(frame)
frame.icon[pos].tex = frame.icon[pos]:CreateTexture("OVERLAY") frame.icon[pos].tex = frame.icon[pos]:CreateTexture(nil, "OVERLAY")
frame.icon[pos].tex:SetAllPoints(frame.icon[pos]) frame.icon[pos].tex:SetAllPoints(frame.icon[pos])
frame.icon[pos].tex:SetTexCoord(.08, .92, .08, .92) frame.icon[pos].tex:SetTexCoord(.08, .92, .08, .92)
frame.icon[pos].stacks = frame.icon[pos]:CreateFontString(nil, "OVERLAY") frame.icon[pos].stacks = frame.icon[pos]:CreateFontString(nil, "OVERLAY")
@@ -2329,17 +2267,7 @@ function pfUI.uf:AddIcon(frame, pos, icon, timeleft, stacks, start, duration)
frame.icon[pos].stacks:SetJustifyH("RIGHT") frame.icon[pos].stacks:SetJustifyH("RIGHT")
frame.icon[pos].stacks:SetJustifyV("BOTTOM") frame.icon[pos].stacks:SetJustifyV("BOTTOM")
-- Check if parent frame has cooldown animation enabled frame.icon[pos].cd = CreateFrame("Cooldown", nil, frame.icon[pos], "CooldownFrameTemplate")
local parent_cooldown_anim = frame.config and tonumber(frame.config.cooldown_anim) or 1
if parent_cooldown_anim == 1 then
frame.icon[pos].cd = CreateFrame("Model", nil, frame.icon[pos])
else
frame.icon[pos].cd = CreateFrame("Frame", nil, frame.icon[pos])
frame.icon[pos].cd.AdvanceTime = DoNothing
frame.icon[pos].cd.SetSequence = DoNothing
frame.icon[pos].cd.SetSequenceTime = DoNothing
end
frame.icon[pos].cd.pfCooldownStyleAnimation = 0 frame.icon[pos].cd.pfCooldownStyleAnimation = 0
frame.icon[pos].cd.pfCooldownType = "ALL" frame.icon[pos].cd.pfCooldownType = "ALL"
frame.icon[pos].cd:SetFrameLevel(48) frame.icon[pos].cd:SetFrameLevel(48)
@@ -2647,7 +2575,7 @@ function pfUI.uf:GetStatusValue(unit, pos)
elseif config == "healthmax" then elseif config == "healthmax" then
return unit:GetColor("health") .. pfUI.api.Abbreviate(rhpmax) return unit:GetColor("health") .. pfUI.api.Abbreviate(rhpmax)
elseif config == "healthperc" then elseif config == "healthperc" then
return unit:GetColor("health") .. ceil(hp / hpmax * 100) return unit:GetColor("health") .. ceil(hp / hpmax * 100) .. "%"
elseif config == "healthmiss" then elseif config == "healthmiss" then
local health = ceil(rhp - rhpmax) local health = ceil(rhp - rhpmax)
if UnitIsDead(unitstr) then if UnitIsDead(unitstr) then
@@ -2700,7 +2628,7 @@ function pfUI.uf:GetStatusValue(unit, pos)
return unit:GetColor("power") .. pfUI.api.Abbreviate(mpmax) return unit:GetColor("power") .. pfUI.api.Abbreviate(mpmax)
elseif config == "powerperc" then elseif config == "powerperc" then
local perc = UnitPowerMax(unitstr) > 0 and ceil(mp / mpmax * 100) or 0 local perc = UnitPowerMax(unitstr) > 0 and ceil(mp / mpmax * 100) or 0
return unit:GetColor("power") .. perc return unit:GetColor("power") .. perc .. "%"
elseif config == "powermiss" then elseif config == "powermiss" then
local power = ceil(mp - mpmax) local power = ceil(mp - mpmax)
if power == 0 then if power == 0 then
+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 = "使用详细模式",
}
-50
View File
@@ -1,50 +0,0 @@
-- barlength = {[formfactor]={cols, rows}}
pfGridmath = {
[1] = {{1,1}},
[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
-3
View File
@@ -200,7 +200,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,
@@ -282,7 +281,6 @@ pfUI_translation["deDE"] = {
["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,
@@ -873,7 +871,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,
+6 -3
View File
@@ -87,6 +87,8 @@ pfUI_translation["enUS"] = {
["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,
@@ -192,6 +194,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,
@@ -205,7 +209,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,
@@ -287,7 +290,6 @@ pfUI_translation["enUS"] = {
["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,
@@ -582,6 +584,8 @@ 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, ["Owner Name"] = nil,
["Pageable"] = nil, ["Pageable"] = nil,
["Paging Actionbar"] = nil, ["Paging Actionbar"] = nil,
@@ -895,7 +899,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,
-3
View File
@@ -200,7 +200,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",
@@ -282,7 +281,6 @@ pfUI_translation["esES"] = {
["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\"",
@@ -873,7 +871,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",
+70 -3
View File
@@ -200,7 +200,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é",
@@ -282,7 +281,6 @@ pfUI_translation["frFR"] = {
["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\"",
@@ -873,7 +871,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é",
@@ -892,4 +889,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",
} }
-3
View File
@@ -200,7 +200,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"] = "가리기",
@@ -282,7 +281,6 @@ pfUI_translation["koKR"] = {
["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"] = "\"루팅 & 스팜\"채팅 창 사용",
@@ -873,7 +871,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,
-3
View File
@@ -200,7 +200,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"] = "Отключено",
@@ -282,7 +281,6 @@ pfUI_translation["ruRU"] = {
["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"] = "Включить окно чата \"Добыча & Спам\"",
@@ -873,7 +871,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"] = "Победа",
-3
View File
@@ -200,7 +200,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"] = "不显示",
@@ -282,7 +281,6 @@ pfUI_translation["zhCN"] = {
["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"] = "启用[拾取、综合]聊天窗口",
@@ -874,7 +872,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"] = "获胜",
-3
View File
@@ -200,7 +200,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"] = "不顯示",
@@ -282,7 +281,6 @@ pfUI_translation["zhTW"] = {
["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"] = "啟用[拾取、綜合]聊天視窗",
@@ -873,7 +871,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,
+1
View File
@@ -2,5 +2,6 @@
<Include file="..\api\api.lua"/> <Include file="..\api\api.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>
+8 -1
View File
@@ -7,7 +7,14 @@
<Include file="..\env\locales_esES.lua"/> <Include file="..\env\locales_esES.lua"/>
<Include file="..\env\locales_ruRU.lua"/> <Include file="..\env\locales_ruRU.lua"/>
<Include file="..\env\tables.lua"/> <Include file="..\env\combatlog_enUS.lua"/>
<Include file="..\env\combatlog_koKR.lua"/>
<Include file="..\env\combatlog_frFR.lua"/>
<Include file="..\env\combatlog_deDE.lua"/>
<Include file="..\env\combatlog_zhCN.lua"/>
<Include file="..\env\combatlog_esES.lua"/>
<Include file="..\env\combatlog_ruRU.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
@@ -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"/>
+1
View File
@@ -30,6 +30,7 @@
<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"/>
+37 -14
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,12 +37,40 @@ 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()
@@ -168,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,
+8 -1616
View File
File diff suppressed because it is too large Load Diff
+192 -348
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,12 +92,6 @@ 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")
@@ -124,43 +104,24 @@ libpredict:SetScript("OnEvent", function()
if origOnEvent then origOnEvent() 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
@@ -235,27 +196,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
@@ -267,32 +218,46 @@ 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 if not targetName then return end
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 -- Heal cast: look up cached amount from a previous cast by this healer
local targetName = resolveNameFromGuid(targetGuid) local _, _, _, startMs, endMs = C_Spell.UnitCastingInfo(unit)
if not targetName then return end if not startMs then return end
local castTime = endMs - startMs
local rankStr = C_Spell.GetSpellSubtext(spellId) or "" local rankStr = C_Spell.GetSpellSubtext(spellId) or ""
local spellKey = spellName .. (rankStr or "") local spellKey = spellName .. (rankStr or "")
@@ -338,86 +303,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
local rankSub = C_Spell.GetSpellSubtext(spellId)
if rankSub and rankSub ~= "" then
rank = tonumber((string.gsub(rankSub, "Rank ", ""))) or 0
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()
@@ -431,13 +341,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)
@@ -451,8 +360,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)}
@@ -462,10 +369,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
@@ -537,25 +440,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
@@ -566,29 +456,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()
@@ -737,41 +604,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)
@@ -794,21 +626,10 @@ 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()
@@ -899,7 +720,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
@@ -912,7 +732,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]
@@ -952,7 +772,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
@@ -976,7 +795,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
@@ -1016,7 +835,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
@@ -1037,7 +855,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]
@@ -1077,8 +895,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)
@@ -1091,6 +911,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)
@@ -1127,15 +948,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:RegisterUnitEvent("UNIT_INVENTORY_CHANGED", "player") 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()
@@ -1145,8 +967,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
@@ -1157,81 +978,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 == UKNOWNBEING 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
@@ -1246,7 +1096,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))
@@ -1256,7 +1105,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()
@@ -1290,16 +1139,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")
+97 -63
View File
@@ -81,6 +81,9 @@ pfUI:RegisterModule("actionbar", function ()
["ACTIONBAR_UPDATE_COOLDOWN"] = true, ["ACTIONBAR_UPDATE_COOLDOWN"] = true,
["ACTIONBAR_UPDATE_USABLE"] = true, ["ACTIONBAR_UPDATE_USABLE"] = true,
["ACTIONBAR_UPDATE_STATE"] = true, ["ACTIONBAR_UPDATE_STATE"] = true,
-- fires on every ammo shot / consumable use, but only counts, equipped
-- state, cooldowns and usability can change from it
["UNIT_INVENTORY_CHANGED"] = true,
} }
-- events that are shared across all buttons -- events that are shared across all buttons
@@ -97,8 +100,6 @@ pfUI:RegisterModule("actionbar", function ()
["TRADE_SKILL_CLOSE"] = true, ["TRADE_SKILL_CLOSE"] = true,
["PLAYER_ENTER_COMBAT"] = true, ["PLAYER_ENTER_COMBAT"] = true,
["PLAYER_LEAVE_COMBAT"] = true, ["PLAYER_LEAVE_COMBAT"] = true,
-- cooldown updates
["UNIT_INVENTORY_CHANGED"] = true,
-- auto repeat action -- auto repeat action
["START_AUTOREPEAT_SPELL"] = true, ["START_AUTOREPEAT_SPELL"] = true,
["STOP_AUTOREPEAT_SPELL"] = true, ["STOP_AUTOREPEAT_SPELL"] = true,
@@ -317,7 +318,7 @@ pfUI:RegisterModule("actionbar", function ()
-- handle button highlight -- handle button highlight
if keystate == "down" then if keystate == "down" then
self.highlight:Show() self.highlight:Show()
elseif not MouseIsOver(self) then elseif not MouseIsOverHitRect(self) then
self.highlight:Hide() self.highlight:Hide()
end end
end end
@@ -381,8 +382,6 @@ pfUI:RegisterModule("actionbar", function ()
end end
elseif self.spellID then elseif self.spellID then
GameTooltip:SetSpellByID(self.spellID) GameTooltip:SetSpellByID(self.spellID)
elseif self.spellslot and self.booktype then
GameTooltip:SetSpell(self.spellslot, self.booktype)
else else
GameTooltip:SetAction(self.id) GameTooltip:SetAction(self.id)
end end
@@ -400,6 +399,28 @@ pfUI:RegisterModule("actionbar", function ()
GameTooltip:Hide() GameTooltip:Hide()
end end
-- item counts and equipped border, the parts of a slot an inventory change touches
local function ButtonInventoryUpdate(self)
if self.bar == 11 or self.bar == 12 then return end
local sid = self.id
-- update consumables
if IsConsumableAction(sid) then
self.count:SetText(GetActionCount(sid))
elseif IsReagentAction and IsReagentAction(sid) then
self.count:SetText(GetReagentCount(sid))
else
self.count:SetText(nil)
end
-- equipped item
if IsEquippedAction(sid) and C.bars.showequipped == "1" then
self.equipped:Show()
else
self.equipped:Hide()
end
end
local start, duration, enable, castable, autocast, token local start, duration, enable, castable, autocast, token
local grid, sid, id, bar, active, texture, _ local grid, sid, id, bar, active, texture, _
local function ButtonSlotUpdate(self) local function ButtonSlotUpdate(self)
@@ -433,11 +454,6 @@ pfUI:RegisterModule("actionbar", function ()
id = self.bar == 1 and self.slot or sid-((self.bar)-1)*12 id = self.bar == 1 and self.slot or sid-((self.bar)-1)*12
end end
-- overwrite with spell macro texture where possible
if self.spellslot and self.booktype then
texture = GetSpellTexture(self.spellslot, self.booktype)
end
if not self.showempty and self.backdrop and not texture and grid == 0 then if not self.showempty and self.backdrop and not texture and grid == 0 then
self.backdrop:Hide() self.backdrop:Hide()
self.hide = true self.hide = true
@@ -460,23 +476,9 @@ pfUI:RegisterModule("actionbar", function ()
self.active:Hide() self.active:Hide()
end end
ButtonInventoryUpdate(self)
if self.bar ~= 11 and self.bar ~= 12 then if self.bar ~= 11 and self.bar ~= 12 then
-- update consumables
if IsConsumableAction(sid) then
self.count:SetText(GetActionCount(sid))
elseif IsReagentAction and IsReagentAction(sid) then
self.count:SetText(GetReagentCount(sid))
else
self.count:SetText(nil)
end
-- equipped item
if IsEquippedAction(sid) and C.bars.showequipped == "1" then
self.equipped:Show()
else
self.equipped:Hide()
end
-- update macro text -- update macro text
if C.bars["bar"..self.bar] and C.bars["bar"..self.bar].showmacro == "1" then if C.bars["bar"..self.bar] and C.bars["bar"..self.bar].showmacro == "1" then
self.macro:SetText(GetActionText(sid)) self.macro:SetText(GetActionText(sid))
@@ -581,9 +583,6 @@ pfUI:RegisterModule("actionbar", function ()
start, duration, enable = GetShapeshiftFormCooldown(button.id) start, duration, enable = GetShapeshiftFormCooldown(button.id)
elseif button.bar == 12 then elseif button.bar == 12 then
start, duration, enable = GetPetActionCooldown(button.id) start, duration, enable = GetPetActionCooldown(button.id)
elseif button.spellslot and button.booktype then
start, duration = GetSpellCooldown(button.spellslot, button.booktype)
enable = 1
else else
start, duration, enable = GetActionCooldown(button.id) start, duration, enable = GetActionCooldown(button.id)
end end
@@ -696,11 +695,29 @@ pfUI:RegisterModule("actionbar", function ()
end end
end end
-- The cached passes below only touch visible buttons. Hidden ones (other
-- pages, hidden bars) are flagged stale and get a full update once the
-- range pass sees them visible again.
-- run cached inventory changes (ammo, reagents, consumables)
if eventcache["UNIT_INVENTORY_CHANGED"] then
eventcache["UNIT_INVENTORY_CHANGED"] = nil
for id, button in pairs(buttoncache) do
if button:IsVisible() then
ButtonInventoryUpdate(button)
ButtonCooldownUpdate(button)
ButtonUsableUpdate(button)
else
button.stale = true
end
end
end
-- run cached usable usable actions -- run cached usable usable actions
if eventcache["ACTIONBAR_UPDATE_USABLE"] then if eventcache["ACTIONBAR_UPDATE_USABLE"] then
eventcache["ACTIONBAR_UPDATE_USABLE"] = nil eventcache["ACTIONBAR_UPDATE_USABLE"] = nil
for id, button in pairs(buttoncache) do for id, button in pairs(buttoncache) do
ButtonUsableUpdate(button) if button:IsVisible() then ButtonUsableUpdate(button) else button.stale = true end
end end
end end
@@ -708,7 +725,7 @@ pfUI:RegisterModule("actionbar", function ()
if eventcache["ACTIONBAR_UPDATE_COOLDOWN"] then if eventcache["ACTIONBAR_UPDATE_COOLDOWN"] then
eventcache["ACTIONBAR_UPDATE_COOLDOWN"] = nil eventcache["ACTIONBAR_UPDATE_COOLDOWN"] = nil
for id, button in pairs(buttoncache) do for id, button in pairs(buttoncache) do
ButtonCooldownUpdate(button) if button:IsVisible() then ButtonCooldownUpdate(button) else button.stale = true end
end end
end end
@@ -716,7 +733,7 @@ pfUI:RegisterModule("actionbar", function ()
if eventcache["ACTIONBAR_UPDATE_STATE"] then if eventcache["ACTIONBAR_UPDATE_STATE"] then
eventcache["ACTIONBAR_UPDATE_STATE"] = nil eventcache["ACTIONBAR_UPDATE_STATE"] = nil
for id, button in pairs(buttoncache) do for id, button in pairs(buttoncache) do
ButtonIsActiveUpdate(button) if button:IsVisible() then ButtonIsActiveUpdate(button) else button.stale = true end
end end
end end
@@ -738,7 +755,13 @@ pfUI:RegisterModule("actionbar", function ()
if ( this.tick or .2) > GetTime() then return else this.tick = GetTime() + .2 end if ( this.tick or .2) > GetTime() then return else this.tick = GetTime() + .2 end
for id, button in pairs(buttoncache) do for id, button in pairs(buttoncache) do
if button:IsShown() then ButtonRangeUpdate(button) end if button.stale and button:IsVisible() then
-- catch up on updates skipped while hidden
button.stale = nil
ButtonFullUpdate(button)
elseif button:IsShown() then
ButtonRangeUpdate(button)
end
end end
end end
@@ -828,17 +851,28 @@ pfUI:RegisterModule("actionbar", function ()
do do
local formpage, shift, ctrl, alt, default = 8, 6, 5, 3, 1 local formpage, shift, ctrl, alt, default = 8, 6, 5, 3, 1
-- set temporary pagemaster bindings keybinds -- while a page modifier is held, MOD-key must run the main bar binding on
if C.bars.pagemaster == "1" then -- that key so the switched page fires. Overrides do this without touching
local modifier = { "ALT", "SHIFT", "CTRL" } -- the saved binding set.
local buttons = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-", "+", "=", "´" } local pagemods = {}
local current = CURRENT_ACTIONBAR_PAGE if C.bars.pagemasteralt == "1" then table.insert(pagemods, "ALT") end
bars.pagemaster = bars.pagemaster or CreateFrame("Frame", "pfPageMaster", UIParent) if C.bars.pagemasterctrl == "1" then table.insert(pagemods, "CTRL") end
bars.pagemaster:RegisterEvent("PLAYER_ENTERING_WORLD") if C.bars.pagemastershift == "1" then table.insert(pagemods, "SHIFT") end
bars.pagemaster:SetScript("OnEvent", function()
for _,mod in pairs(modifier) do if table.getn(pagemods) > 0 then
for _,but in pairs(buttons) do local pagemaster = CreateFrame("Frame", "pfPageMaster", UIParent)
SetBinding(mod.."-"..but) pagemaster:RegisterEvent("PLAYER_ENTERING_WORLD")
pagemaster:RegisterEvent("UPDATE_BINDINGS")
pagemaster:SetScript("OnEvent", function()
ClearOverrideBindings(this)
for i = 1, 12 do
for _, key in ipairs({ GetBindingKey("ACTIONBUTTON"..i) }) do
-- skip keys that already carry a modifier, e.g. "SHIFT-Q"
if not key:find("^%u+%-.") then
for _, mod in ipairs(pagemods) do
SetOverrideBinding(this, false, mod.."-"..key, "ACTIONBUTTON"..i)
end
end
end end
end end
end) end)
@@ -853,6 +887,10 @@ pfUI:RegisterModule("actionbar", function ()
pageswitch:RegisterEvent("UPDATE_SHAPESHIFT_FORM") pageswitch:RegisterEvent("UPDATE_SHAPESHIFT_FORM")
pageswitch:RegisterEvent("PLAYER_AURAS_CHANGED") pageswitch:RegisterEvent("PLAYER_AURAS_CHANGED")
pageswitch:RegisterEvent("PLAYER_LOGOUT") pageswitch:RegisterEvent("PLAYER_LOGOUT")
local PROWL_IDS = { [5215] = true, [6783] = true, [9913] = true }
if class == "DRUID" then
pageswitch:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
end
pageswitch:SetScript("OnEvent", function() pageswitch:SetScript("OnEvent", function()
if event == "PLAYER_LOGOUT" then if event == "PLAYER_LOGOUT" then
this:UnregisterAllEvents() this:UnregisterAllEvents()
@@ -875,6 +913,18 @@ pfUI:RegisterModule("actionbar", function ()
return return
end end
-- Eager prowl detection on the cast itself — zero-latency vs.
-- PLAYER_AURAS_CHANGED, which can land a frame or two behind it.
-- arg3 = spellID
if event == "UNIT_SPELLCAST_SUCCEEDED" then
if PROWL_IDS[arg3] then
inCatForm = true
prowlActive = true
formpaging = true
end
return
end
if event == "UPDATE_SHAPESHIFT_FORM" then if event == "UPDATE_SHAPESHIFT_FORM" then
-- Authoritative form-change signal — recompute and short-circuit. -- Authoritative form-change signal — recompute and short-circuit.
inCatForm = HasCatForm() inCatForm = HasCatForm()
@@ -898,20 +948,6 @@ pfUI:RegisterModule("actionbar", function ()
end end
end) end)
-- Eager prowl detection via Nampower SPELL_GO_SELF — zero-latency vs.
-- PLAYER_AURAS_CHANGED, which can land a frame or two behind the cast.
-- Form changes are no longer hooked here; UPDATE_SHAPESHIFT_FORM covers
-- those without needing a per-spellID watchlist.
local PROWL_IDS = { [5215] = true, [6783] = true, [9913] = true }
pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
pfUI.libdebuff_spell_go_hooks["actionbar_prowl"] = function(spellId)
if class ~= "DRUID" then return end
if PROWL_IDS[spellId] then
inCatForm = true
prowlActive = true
formpaging = true
end
end
pageswitch:SetScript("OnUpdate", function() pageswitch:SetScript("OnUpdate", function()
-- switch actionbar page depending on meta key that is pressed -- switch actionbar page depending on meta key that is pressed
if C.bars.pagemastershift == "1" and IsShiftKeyDown() then if C.bars.pagemastershift == "1" and IsShiftKeyDown() then
@@ -997,8 +1033,9 @@ pfUI:RegisterModule("actionbar", function ()
f.slot = id f.slot = id
-- cooldown -- cooldown
f.cd = CreateFrame("Model", f:GetName() .. "Cooldown", f, "CooldownFrameTemplate") f.cd = CreateFrame("Cooldown", f:GetName() .. "Cooldown", f, "CooldownFrameTemplate")
f.cd.pfCooldownStyleAnimation = 1 f.cd.pfCooldownStyleAnimation = 1
f.cd.pfCooldownReverse = tonumber(C.bars.cooldown_reverse) or 0
f.cd.pfCooldownType = "NOGCD" f.cd.pfCooldownType = "NOGCD"
f.cd.pfCooldownSize = cd_size f.cd.pfCooldownSize = cd_size
@@ -1103,8 +1140,6 @@ pfUI:RegisterModule("actionbar", function ()
f.count:SetJustifyH("RIGHT") f.count:SetJustifyH("RIGHT")
f.count:SetJustifyV("BOTTOM") f.count:SetJustifyV("BOTTOM")
f.scanmacro, f.spellslot, f.booktype = nil, nil, nil
-- range glow color -- range glow color
f.rangeColor = GetStringColorObject(C.bars.rangecolor) f.rangeColor = GetStringColorObject(C.bars.rangecolor)
@@ -1171,8 +1206,7 @@ pfUI:RegisterModule("actionbar", function ()
end end
-- the stored layout is invalid, temporary fallback -- the stored layout is invalid, temporary fallback
local _, _, fcols, frows = string.find(tostring(formfactor or ""), "(%d+)%s*x%s*(%d+)") if not fcols2 or not frows2 then
if not ((fcols and frows) or pfGridmath[buttons][BarLayoutFormfactor(formfactor)]) then
formfactor = BarLayoutOptions(buttons)[1] formfactor = BarLayoutOptions(buttons)[1]
end end
+4 -3
View File
@@ -399,15 +399,16 @@ pfUI:RegisterModule("addonbuttons", function ()
-- Initial setup on the next frame, once other addons' minimap buttons exist -- Initial setup on the next frame, once other addons' minimap buttons exist
RunNextFrame(function() RunNextFrame(function()
-- check if the panel should be shown by default -- rescan before deciding whether the panel should be shown by default
pfUI.addonbuttons:ProcessButtons()
if C.abuttons.showdefault == "1" and GetNumButtons() > 0 then if C.abuttons.showdefault == "1" and GetNumButtons() > 0 then
pfUI.addonbuttons:Show() pfUI.addonbuttons:Show()
else else
pfUI.addonbuttons:Hide() pfUI.addonbuttons:Hide()
end end
-- update all buttons and apply workarounds -- apply workarounds
pfUI.addonbuttons:ProcessButtons()
for k, v in pairs(pfUI.addonbuttons.overrides) do for k, v in pairs(pfUI.addonbuttons.overrides) do
_G[k] = v _G[k] = v
end end
+108 -145
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)
@@ -70,12 +69,42 @@ 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
@@ -91,28 +120,20 @@ pfUI:RegisterModule("addons", function ()
pfUI.addons.profile.dropdown:SetSelectionByText(profile) pfUI.addons.profile.dropdown:SetSelectionByText(profile)
-- 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
@@ -194,23 +215,6 @@ pfUI:RegisterModule("addons", function ()
return menu return menu
end) end)
-- addon list: scroll frame
pfUI.addons.scroll = CreateScrollFrame("pfAddonListScroll", pfUI.addons)
pfUI.addons.scroll:SetSize(360, 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(" ")
@@ -226,137 +230,96 @@ 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() local _, name = pfUI.addons.profile.dropdown:GetSelection()
name = name or T["Current"] name = name or T["Current"]
pfUI_addon_profiles[name] = GetSelectedAddonsList() 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:SetSize(340, 25) -- caption
frame:SetPoint("TOPLEFT", 5, i * -25 + 20) row.caption = row:CreateFontString(nil, "LOW", "GameFontNormal")
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)
+10 -11
View File
@@ -29,20 +29,20 @@ pfUI:RegisterModule("afkcam", function ()
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)
@@ -82,7 +82,6 @@ pfUI:RegisterModule("afkcam", function ()
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)
@@ -166,9 +165,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
+1 -1
View File
@@ -57,7 +57,7 @@ pfUI:RegisterModule("autovendor", function ()
-- Setup Autosell button -- Setup Autosell button
autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame) autovendor.button = CreateFrame("Button", "pfMerchantAutoVendorButton", MerchantFrame)
autovendor.button:SetSize(36, 36) autovendor.button:SetSize(36, 36)
autovendor.button.icon = autovendor.button:CreateTexture("ARTWORK") autovendor.button.icon = autovendor.button:CreateTexture(nil, "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")
+34 -59
View File
@@ -6,8 +6,6 @@ pfUI:RegisterModule("bags", function ()
[1804] = {frame="picklock"}, [1804] = {frame="picklock"},
} }
local scanner = libtipscan:GetScanner("input_search")
local function BagSortOpts() local function BagSortOpts()
return { return {
reverse = C.appearance.bags.sortreverse == "1", reverse = C.appearance.bags.sortreverse == "1",
@@ -95,6 +93,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 = {} }
@@ -122,6 +121,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)
@@ -159,6 +163,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
@@ -377,6 +385,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
@@ -396,14 +419,15 @@ pfUI:RegisterModule("bags", function ()
if tpl == "BankItemButtonGenericTemplate" then if tpl == "BankItemButtonGenericTemplate" then
local bankslot = pfUI.bags[bag].slots[slot].frame local bankslot = pfUI.bags[bag].slots[slot].frame
local name = "pfBag" .. bag .. "item" .. slot .. "Cooldown" local name = "pfBag" .. bag .. "item" .. slot .. "Cooldown"
bankslot.cd = CreateFrame("Model", name, bankslot, "CooldownFrameTemplate") bankslot.cd = CreateFrame("Cooldown", name, bankslot, "CooldownFrameTemplate")
bankslot.cd:SetAllPoints(bankslot)
bankslot.cd.pfCooldownStyleAnimation = 1 bankslot.cd.pfCooldownStyleAnimation = 1
bankslot.cd.pfCooldownType = "ALL" bankslot.cd.pfCooldownReverse = tonumber(C.appearance.bags.cooldown_reverse) or 0
bankslot.cd.pfCooldownType = "NOGCD"
else else
local bagslot = pfUI.bags[bag].slots[slot].frame local bagslot = pfUI.bags[bag].slots[slot].frame
bagslot.cd = _G[bagslot:GetName().."Cooldown"] bagslot.cd = _G[bagslot:GetName().."Cooldown"]
bagslot.cd.pfCooldownType = "ALL" bagslot.cd.pfCooldownType = "NOGCD"
bagslot.cd.pfCooldownReverse = tonumber(C.appearance.bags.cooldown_reverse) or 0
end end
if not pfUI.bags[bag].slots[slot].frame.backdrop then if not pfUI.bags[bag].slots[slot].frame.backdrop then
@@ -464,6 +488,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
@@ -1009,7 +1034,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)
@@ -1034,51 +1058,12 @@ 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()
@@ -1093,17 +1078,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
+44 -4
View File
@@ -19,7 +19,7 @@ pfUI:RegisterModule("buff", function ()
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
@@ -33,7 +33,7 @@ pfUI:RegisterModule("buff", function ()
end end
local slots = buff.btype == "HELPFUL" and helpfulSlots or harmfulSlots local slots = buff.btype == "HELPFUL" and helpfulSlots or harmfulSlots
local name, icon, count, dispelType, _, expirationTime, _, _, _, spellId = C_UnitAuras.UnitAuraBySlot("player", slots[buff.id]) 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
@@ -84,6 +84,28 @@ pfUI:RegisterModule("buff", function ()
return return
end end
-- drive the sweep from the aura duration (weapon enchants and permanent
-- auras report no usable total, so those buttons stay text-only)
if buff.mode == buff.btype and duration and duration > 0 and expirationTime and expirationTime > 0 then
local now = GetTime()
local timeleft = expirationTime - now
if timeleft > 0 then
local effDuration = duration > timeleft and duration or timeleft
local newStart = now + timeleft - effDuration
if buff.cdStart == nil or abs(buff.cdStart - newStart) > .5 or buff.cdDuration ~= effDuration then
CooldownFrame_SetTimer(buff.cd, newStart, effDuration, 1)
buff.cdStart = newStart
buff.cdDuration = effDuration
end
else
CooldownFrame_SetTimer(buff.cd, 0, 0, 0)
buff.cdStart = nil
end
else
CooldownFrame_SetTimer(buff.cd, 0, 0, 0)
buff.cdStart = nil
end
buff:Show() buff:Show()
end end
@@ -106,17 +128,33 @@ 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 texts above the sweep: a child frame renders above
-- all of its parent's own regions, so the timer would dim under the
-- dark wedge otherwise (same reason pfCooldownText is its own frame)
buff.overlay = CreateFrame("Frame", nil, buff)
buff.overlay:SetAllPoints(buff)
buff.timer = buff.overlay:CreateFontString(nil, "OVERLAY", "GameFontNormal")
buff.timer:SetTextColor(1,1,1,1) buff.timer:SetTextColor(1,1,1,1)
buff.timer:SetJustifyH("CENTER") buff.timer:SetJustifyH("CENTER")
buff.timer:SetJustifyV("CENTER") buff.timer:SetJustifyV("CENTER")
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)
-- radial sweep (the template covers the button and starts hidden;
-- the cooldown hook drives it from here, text stays with buff.timer)
buff.cd = CreateFrame("Cooldown", buttonName .. "Cooldown", buff, "CooldownFrameTemplate")
buff.cd:SetFrameLevel(buff:GetFrameLevel() + 1)
buff.overlay:SetFrameLevel(buff:GetFrameLevel() + 2)
buff.cd.pfCooldownType = "ALL"
buff.cd.pfCooldownStyleText = 0
buff.cd.pfCooldownStyleAnimation = tonumber(C.buffs.cooldown_anim) or 0
buff.cd.pfCooldownReverse = tonumber(C.buffs.cooldown_reverse) or 0
buff:RegisterForClicks("RightButtonUp") buff:RegisterForClicks("RightButtonUp")
buff.weapon = weapon buff.weapon = weapon
@@ -307,6 +345,8 @@ pfUI:RegisterModule("buff", function ()
offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+buffSize+2*buffSpacing) offsetY = -(rowcount) * ((C.buffs.textinside == "1" and 0 or (fontsize*1.5))+buffSize+2*buffSpacing)
end end
buff:SetSize(buffSize, buffSize) buff:SetSize(buffSize, buffSize)
buff.cd.pfCooldownStyleAnimation = tonumber(C.buffs.cooldown_anim) or 0
buff.cd.pfCooldownReverse = tonumber(C.buffs.cooldown_reverse) or 0
buff:ClearAllPoints() buff:ClearAllPoints()
buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY) buff:SetPoint("TOPRIGHT", relFrame, "TOPRIGHT",offsetX, offsetY)
+3 -34
View File
@@ -76,10 +76,6 @@ pfUI:RegisterModule("buffwatch", function ()
-- reusable GetAuraSlots buffer, filled once per RefreshBuffBarFrame -- reusable GetAuraSlots buffer, filled once per RefreshBuffBarFrame
local auraSlots = {} local auraSlots = {}
-- Separate buffer for the tooltip handler: OnEnter can fire while a refresh
-- is showing/hiding bars under the cursor, so it must not share the above.
local tooltipSlots = {}
-- Reads one aura by the slot id GetAuraSlots returned (nil slot -> nil). -- Reads one aura by the slot id GetAuraSlots returned (nil slot -> nil).
local function GetBuffData(unit, slot) local function GetBuffData(unit, slot)
local name, icon, count, dispelType, _, expirationTime = C_UnitAuras.UnitAuraBySlot(unit, slot) local name, icon, count, dispelType, _, expirationTime = C_UnitAuras.UnitAuraBySlot(unit, slot)
@@ -116,36 +112,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 unfiltered HARMFUL list. Look up
-- the displayed aura via the PLAYER filter, then find its position in the
-- unfiltered list by name + sourceGUID.
--
-- The unfiltered 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 reports those as harmful too. So enumerate what it has.
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
local n = ScanAuraSlots(this.unit, "HARMFUL", tooltipSlots)
for i = 1, n do
local check = C_UnitAuras.GetAuraDataBySlot(this.unit, tooltipSlots[i])
if check and check.name == ownAura.name and check.sourceGUID == ownAura.sourceGUID then
GameTooltip:SetUnitAura(this.unit, i, "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(" ")
+36 -25
View File
@@ -36,7 +36,7 @@ pfUI:RegisterModule("castbar", function ()
cb.bar:SetValue(1) cb.bar:SetValue(1)
end 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
@@ -86,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, rank) 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
@@ -94,10 +94,13 @@ 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(GetStringColor(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)
-- Rank: prefer the value the UNIT_SPELLCAST_* event delivered (arg5, passed -- Rank: prefer the value the UNIT_SPELLCAST_* event delivered (arg5, passed
-- through by RefreshBar). Only the retarget re-poll has no event in hand, so -- through by RefreshBar). Only the retarget re-poll has no event in hand, so
@@ -147,15 +150,15 @@ pfUI:RegisterModule("castbar", function ()
-- 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, rank) 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
@@ -169,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, rank) 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)
@@ -183,7 +186,6 @@ 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)
@@ -245,8 +247,14 @@ pfUI:RegisterModule("castbar", function ()
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()
@@ -254,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
@@ -271,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
@@ -342,6 +347,12 @@ pfUI:RegisterModule("castbar", function ()
elseif unitstr == "focus" then elseif unitstr == "focus" then
cb:RegisterEvent("PLAYER_FOCUS_CHANGED") cb:RegisterEvent("PLAYER_FOCUS_CHANGED")
end end
-- The shield can flip mid-cast (the caster gains or loses an aura that
-- blocks interrupts). These only fire for target and focus.
if unitstr == "target" or unitstr == "focus" then
cb:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTIBLE", unitstr)
cb:RegisterUnitEvent("UNIT_SPELLCAST_NOT_INTERRUPTIBLE", unitstr)
end
cb:SetScript("OnEvent", function() cb:SetScript("OnEvent", function()
local unit = this.unitstr local unit = this.unitstr
@@ -397,6 +408,10 @@ pfUI:RegisterModule("castbar", function ()
if not this.tradeskillTotal then ClearBar(this) end if not this.tradeskillTotal then ClearBar(this) end
elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then elseif event == "UNIT_SPELLCAST_FAILED" or event == "UNIT_SPELLCAST_INTERRUPTED" then
ClearBar(this, true) ClearBar(this, true)
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
elseif event == "UNIT_SPELLCAST_DELAYED" or event == "UNIT_SPELLCAST_CHANNEL_UPDATE" then elseif event == "UNIT_SPELLCAST_DELAYED" or event == "UNIT_SPELLCAST_CHANNEL_UPDATE" then
-- Pushback: a cast delayed later or a channel shortened. Following -- Pushback: a cast delayed later or a channel shortened. Following
-- Quartz, re-poll just the times and accumulate the shift into a running -- Quartz, re-poll just the times and accumulate the shift into a running
@@ -407,13 +422,12 @@ pfUI:RegisterModule("castbar", function ()
-- endMs. delay is a positive magnitude; OnUpdate signs it "+" for casts -- endMs. delay is a positive magnitude; OnUpdate signs it "+" for casts
-- and "-" for channels. Skipped during a tradeskill merge. -- and "-" for channels. Skipped during a tradeskill merge.
if this.endTime and not this.tradeskillTotal then if this.endTime and not this.tradeskillTotal then
local query = this.unitstr ~= "" and this.unitstr or this.unitname
local startMs, endMs local startMs, endMs
if this.isChannel then if this.isChannel then
local _, _, _, s, e = C_Spell.UnitChannelInfo(query) local _, _, _, s, e = C_Spell.UnitChannelInfo(unit)
startMs, endMs = s, e startMs, endMs = s, e
else else
local _, _, _, s, e = C_Spell.UnitCastingInfo(query) local _, _, _, s, e = C_Spell.UnitCastingInfo(unit)
startMs, endMs = s, e startMs, endMs = s, e
end end
if startMs and endMs then if startMs and endMs then
@@ -528,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)
+82 -73
View File
@@ -376,7 +376,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]
@@ -389,7 +390,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
@@ -526,10 +527,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
@@ -779,33 +780,43 @@ pfUI:RegisterModule("chat", function ()
local r,g,b,a = GetStringColor(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)
-- AddMessage puts the time between these at the start of each line
local timestampStart = timecolorhex .. tleft
local timestampEnd = tright .. "|r "
-- [ StripTimestamp ]
-- Returns a chat line without the timestamp AddMessage put before it.
function pfUI.chat.StripTimestamp(text)
if C.chat.text.time ~= "1" or text:sub(1, #timestampStart) ~= timestampStart then
return text
end
local _, last = text:find(timestampEnd, #timestampStart + 1, true)
return last and text:sub(last + 1) or text
end
local r,g,b = GetStringColor(C.chat.text.unknowncolor) local r,g,b = GetStringColor(C.chat.text.unknowncolor)
local unknowncolorhex = rgbhex(r,g,b) local unknowncolorhex = rgbhex(r,g,b)
-- Suppress FriendsFrame's WHO_LIST_UPDATE handling for our DLL-issued
-- name lookups so they don't pop the friends panel. User-issued /who
-- still works because IsWhoQueryPending only reports true for queries
-- issued via C_FriendList.SendWhoQueryByName.
local original_FriendsFrame_OnEvent = FriendsFrame_OnEvent
_G.FriendsFrame_OnEvent = function()
if _G.event == "WHO_LIST_UPDATE" and C_FriendList.IsWhoQueryPending() then return end
return original_FriendsFrame_OnEvent()
end
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
@@ -821,91 +832,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, _, raceKey, sex = 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
local icon = ""
if match and C.chat.text.playericons == "1" then
icon = GetFactionIcon(raceKey) .. GetRaceIcon(raceKey, sex)
end
text = string.gsub(text, "|Hplayer:"..name.."|h%["..real.."%]|h(.-:-)",
left..icon..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
channel = string.gsub(channel, "(%d+)%..*", "channel%1")
channel = string.gsub(channel, "channel", "")
text = string.gsub(text, "%[%d+%..-%]%s+(.*|Hplayer)", left .. channel .. right .. " %1")
end
end end
-- detect the whisper prefix BEFORE prepending a timestamp; the timestamp -- detect the whisper prefix BEFORE prepending a timestamp; the timestamp
-- pushes the whisper colour code off position 1 and the find below fails -- pushes the whisper colour code off position 1 and the find below fails
local isWhisper = C.chat.global.whispermod == "1" and string.find(text, wcol, 1) == 1 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
-- 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 isWhisper 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 isWhisper then frame:HookAddMessage(text, ...)
-- patch incoming whisper string to match the colors
text = string.gsub(text, "|r", "|r" .. wcol)
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
+50 -106
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,98 +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:SetTexture(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:SetSize(frame:GetSize())
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
+1 -1
View File
@@ -23,7 +23,7 @@ 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
+38 -17
View File
@@ -59,18 +59,14 @@ pfUI:RegisterModule("cooldown", function ()
end end
end end
local height, size local function GetCooldownHeight(cooldown)
local textcount = 0 return cooldown:GetParent() and cooldown:GetParent():GetHeight() or cooldown:GetHeight() or 0
local function pfCreateCoolDown(cooldown, start, duration) end
textcount = textcount + 1
local name = cooldown.GetName and cooldown:GetName() or "pfCooldown" .. textcount
cooldown.pfCooldownText = CreateFrame("Frame", name .. "Text", cooldown:GetParent())
cooldown.pfCooldownText.cooldown = cooldown
cooldown.pfCooldownText:SetAllPoints(cooldown)
cooldown.pfCooldownText:SetFrameLevel(cooldown:GetParent():GetFrameLevel() + 2)
cooldown.pfCooldownText.text = cooldown.pfCooldownText:CreateFontString(name .. "TextString", "OVERLAY")
-- sizes the text to the cooldown's current height; the dynamic size follows
-- the frame, so SetCooldown calls this again whenever that height changes
local function pfUpdateCooldownFont(cooldown)
local size
if not cooldown.pfCooldownType then if not cooldown.pfCooldownType then
size = tonumber(C.appearance.cd.font_size_foreign) size = tonumber(C.appearance.cd.font_size_foreign)
elseif cooldown.pfCooldownType == "BLIZZARD" then elseif cooldown.pfCooldownType == "BLIZZARD" then
@@ -82,12 +78,27 @@ pfUI:RegisterModule("cooldown", function ()
end end
-- enforce dynamic font size -- enforce dynamic font size
if C.appearance.cd.dynamicsize == "1" and cooldown.GetParent then if C.appearance.cd.dynamicsize == "1" then
height = cooldown:GetParent() and cooldown:GetParent():GetHeight() or cooldown:GetHeight() or 0 local height = GetCooldownHeight(cooldown)
cooldown.pfCooldownText.height = height
size = math.max((height > 0 and height * .64 or 16), size) size = math.max((height > 0 and height * .64 or 16), size)
end end
cooldown.pfCooldownText.text:SetFont(pfUI.media[C.appearance.cd.font], size, "OUTLINE") cooldown.pfCooldownText.text:SetFont(pfUI.media[C.appearance.cd.font], size, "OUTLINE")
end
local textcount = 0
local function pfCreateCoolDown(cooldown, start, duration)
textcount = textcount + 1
local name = cooldown.GetName and cooldown:GetName() or "pfCooldown" .. textcount
cooldown.pfCooldownText = CreateFrame("Frame", name .. "Text", cooldown:GetParent())
cooldown.pfCooldownText.cooldown = cooldown
cooldown.pfCooldownText:SetAllPoints(cooldown)
cooldown.pfCooldownText:SetFrameLevel(cooldown:GetParent():GetFrameLevel() + 2)
cooldown.pfCooldownText.text = cooldown.pfCooldownText:CreateFontString(name .. "TextString", "OVERLAY")
pfUpdateCooldownFont(cooldown)
cooldown.pfCooldownText.text:SetPoint("CENTER", cooldown.pfCooldownText, "CENTER", 0, 0) cooldown.pfCooldownText.text:SetPoint("CENTER", cooldown.pfCooldownText, "CENTER", 0, 0)
cooldown.pfCooldownText:SetScript("OnUpdate", pfCooldownOnUpdate) cooldown.pfCooldownText:SetScript("OnUpdate", pfCooldownOnUpdate)
end end
@@ -104,8 +115,10 @@ pfUI:RegisterModule("cooldown", function ()
return return
end end
-- realign cooldown frames -- realign the indicator Models that stock buttons build; the model is
local parent = this.GetParent and this:GetParent() -- drawn at 36px and needs scaling to its button. A Cooldown draws its
-- sweep to its own rect.
local parent = this.GetParent and not this:IsObjectType("Cooldown") and this:GetParent()
if parent and parent:GetWidth() / 36 > 0 then if parent and parent:GetWidth() / 36 > 0 then
this:SetScale(parent:GetWidth() / 36) this:SetScale(parent:GetWidth() / 36)
this:SetPoint("TOPLEFT", parent, "TOPLEFT", -1, 1) this:SetPoint("TOPLEFT", parent, "TOPLEFT", -1, 1)
@@ -129,11 +142,19 @@ pfUI:RegisterModule("cooldown", function ()
this:SetAlpha(0) this:SetAlpha(0)
end end
-- reversed sweep direction (ClassicAPI backports SetReverse with the
-- modern Cooldown frame; stock Model swipes don't have it, so guard it)
if this.pfCooldownReverse == 1 and this.SetReverse then
this:SetReverse(true)
end
-- print time as text on cooldown frames -- print time as text on cooldown frames
if ( not this.pfCooldownStyleText or this.pfCooldownStyleText == 1) if ( not this.pfCooldownStyleText or this.pfCooldownStyleText == 1)
and start > 0 and duration > 0 and (not enable or enable > 0) then and start > 0 and duration > 0 and (not enable or enable > 0) then
if( not this.pfCooldownText ) then if( not this.pfCooldownText ) then
pfCreateCoolDown(this, start, duration) pfCreateCoolDown(this, start, duration)
elseif C.appearance.cd.dynamicsize == "1" and GetCooldownHeight(this) ~= this.pfCooldownText.height then
pfUpdateCooldownFont(this)
end end
this.pfCooldownText.start = start this.pfCooldownText.start = start
@@ -144,7 +165,7 @@ pfUI:RegisterModule("cooldown", function ()
end end
end end
-- vanilla does not have a cooldown frame type, so we hook the -- hook the SetTimer function that every cooldown, Cooldown frame or
-- regular SetTimer function that each one is calling. -- stock indicator Model, is driven through.
hooksecurefunc("CooldownFrame_SetTimer", SetCooldown) hooksecurefunc("CooldownFrame_SetTimer", SetCooldown)
end) end)
+44 -7
View File
@@ -89,6 +89,13 @@ pfUI:RegisterModule("energytick", function()
return C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width return C.unitframes.player.pwidth ~= "-1" and C.unitframes.player.pwidth or C.unitframes.player.width
end 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 -- was this gain the regen tick? if so, re-anchor the sweep on it
local function lockTick(frame) local function lockTick(frame)
local now, period = GetTime(), getAdjustedTickTimer() local now, period = GetTime(), getAdjustedTickTimer()
@@ -199,11 +206,21 @@ pfUI:RegisterModule("energytick", function()
end end
this.tick = GetTime() + 0.020 -- ~50 FPS this.tick = GetTime() + 0.020 -- ~50 FPS
-- five-second rule drains to nothing -- five-second rule drains to nothing. The display is cosmetic and can be
-- hidden on its own; the window itself (fsrEnd/fsrGain) keeps running
-- either way -- it still dims the sweep spark below.
local remaining = this.fsrEnd and (this.fsrEnd - GetTime()) or 0 local remaining = this.fsrEnd and (this.fsrEnd - GetTime()) or 0
if this.mode == "MANA" and remaining > 0 then if this.mode == "MANA" and remaining > 0 then
this.fsrbar:SetWidth(getBarWidth() * remaining / FIVE_SECOND_RULE) if C.unitframes.player.showfsr == "1" then
this.fsrbar:Show() 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 else
this.fsrSpell, this.fsrEnd, this.fsrGain = nil, nil, nil this.fsrSpell, this.fsrEnd, this.fsrGain = nil, nil, nil
this.fsrbar:Hide() this.fsrbar:Hide()
@@ -240,10 +257,26 @@ pfUI:RegisterModule("energytick", function()
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)
energytick.fsrbar = energytick:CreateTexture(nil, "ARTWORK") if fsrOverlay then
energytick.fsrbar:SetTexture(1, 1, 1, .15) -- classic style: a translucent shade on top of the power bar's own fill
energytick.fsrbar:SetPoint("TOPLEFT", 0, 0) energytick.fsrbar = energytick:CreateTexture(nil, "ARTWORK")
energytick.fsrbar:SetPoint("BOTTOMLEFT", 0, 0) energytick.fsrbar:SetTexture(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.fsrbar:Hide()
energytick.spark = energytick:CreateTexture(nil, "OVERLAY") energytick.spark = energytick:CreateTexture(nil, "OVERLAY")
@@ -256,6 +289,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)
+1348 -132
View File
File diff suppressed because it is too large Load Diff
+5 -28
View File
@@ -29,38 +29,15 @@ pfUI:RegisterModule("focus", function ()
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)
+58 -22
View File
@@ -58,10 +58,11 @@ pfUI:RegisterModule("gui", function ()
return return
end end
if MouseIsOver(this) and not this.over then local over = MouseIsOverHitRect(this)
if over and not this.over then
this.tex:Show() this.tex:Show()
this.over = true this.over = true
elseif not MouseIsOver(this) and this.over then elseif not over and this.over then
this.tex:Hide() this.tex:Hide()
this.over = nil this.over = nil
end end
@@ -182,7 +183,7 @@ 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])
@@ -514,14 +515,15 @@ pfUI:RegisterModule("gui", function ()
-- 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
@@ -773,7 +775,10 @@ pfUI:RegisterModule("gui", function ()
end end
end end
if strlen(this:GetText()) < 1 then return end if strlen(this:GetText()) < 1 then
parent:UpdateScrollChildRect()
return
end
local i = 1 local i = 1
local search = strlower(this:GetText()) local search = strlower(this:GetText())
@@ -797,16 +802,9 @@ pfUI:RegisterModule("gui", function ()
end end
end end
-- reload scroll frames -- measure the new results and start at the top
scroll:Hide() parent:UpdateScrollChildRect()
scroll:SetHeight(i * 25 ) parent:SetVerticalScroll(0)
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)
@@ -2072,9 +2070,6 @@ pfUI:RegisterModule("gui", function ()
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")
@@ -2320,6 +2315,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)
@@ -2334,18 +2338,25 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U[c], T["Timer"], nil, nil, "header") CreateConfig(U[c], T["Timer"], nil, nil, "header")
CreateConfig(U[c], T["Show Timer Text"], C.unitframes[c], "cooldown_text", "checkbox") 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(Reload, T["Show Timer Animation"], C.unitframes[c], "cooldown_anim", "checkbox")
CreateConfig(Reload, T["Reverse Timer Animation"], C.unitframes[c], "cooldown_reverse", "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
@@ -2414,6 +2425,21 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Always Show Equipment Slot Flyouts"], C.character.inventory, "equipflyout", "checkbox") CreateConfig(nil, T["Always Show Equipment Slot Flyouts"], C.character.inventory, "equipflyout", "checkbox")
end) 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)
CreateGUIEntry(T["Character"], T["Reputation"], function() CreateGUIEntry(T["Character"], T["Reputation"], function()
CreateConfig(nil, T["Show Reputation Remaining"], C.character.reputation, "repRequired", "checkbox") CreateConfig(nil, T["Show Reputation Remaining"], C.character.reputation, "repRequired", "checkbox")
end) end)
@@ -2430,8 +2456,8 @@ 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(Reload, T["Reverse Cooldown Animation"], C.appearance.bags, "cooldown_reverse", "checkbox")
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")
@@ -2482,6 +2508,8 @@ pfUI:RegisterModule("gui", function ()
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["Buff Font Size"], C.buffs, "fontsize")
CreateConfig(Reload, T["Show Timer Animation"], C.buffs, "cooldown_anim", "checkbox")
CreateConfig(Reload, T["Reverse Timer Animation"], C.buffs, "cooldown_reverse", "checkbox")
end) end)
CreateGUIEntry(T["Buffs"], T["Totem Icons"], function() CreateGUIEntry(T["Buffs"], T["Totem Icons"], function()
@@ -2489,6 +2517,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["totems"], T["Icon Size"], C.totems, "iconsize") CreateConfig(U["totems"], T["Icon Size"], C.totems, "iconsize")
CreateConfig(U["totems"], T["Spacing"], C.totems, "spacing", "dropdown", pfUI.gui.dropdowns.spacing) CreateConfig(U["totems"], T["Spacing"], C.totems, "spacing", "dropdown", pfUI.gui.dropdowns.spacing)
CreateConfig(U["totems"], T["Show Background"], C.totems, "showbg", "checkbox") CreateConfig(U["totems"], T["Show Background"], C.totems, "showbg", "checkbox")
CreateConfig(Reload, T["Reverse Cooldown Animation"], C.totems, "cooldown_reverse", "checkbox")
end) end)
CreateGUIEntry(T["Buffs"], T["Player Buff Bar"], function() CreateGUIEntry(T["Buffs"], T["Player Buff Bar"], function()
@@ -2578,6 +2607,7 @@ pfUI:RegisterModule("gui", function ()
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["Cooldown Text Size"], C.bars, "cd_size")
CreateConfig(Reload, T["Reverse Cooldown Animation"], C.bars, "cooldown_reverse", "checkbox")
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")
@@ -2792,6 +2822,8 @@ pfUI:RegisterModule("gui", 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)
@@ -2860,13 +2892,16 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(nil, T["Timestamp Format"], C.chat.text, "timeformat", nil, nil, nil, nil, "STRING") CreateConfig(nil, 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")
-- read each time chat copy opens, so no reload
CreateConfig(function() end, T["Show Timestamps In Chat Copy"], C.chat.text, "copytime", "checkbox")
CreateConfig(nil, T["Hide Channel Names"], C.chat.text, "channelnumonly", "checkbox") CreateConfig(nil, 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(nil, T["Enable URL Detection"], C.chat.text, "detecturl", "checkbox")
CreateConfig(nil, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox") CreateConfig(nil, T["Enable Class Colors"], C.chat.text, "classcolor", "checkbox")
CreateConfig(nil, T["Show Faction & Race Icons"] .. " " .. GetPlayerRaceIcons(), C.chat.text, "playericons", "checkbox") local _, playerRace = UnitRace("player")
CreateConfig(nil, T["Show Faction Icons"] .. " " .. GetFactionIcon(playerRace), C.chat.text, "factionicons", "checkbox")
CreateConfig(nil, T["Show Race Icons"] .. " " .. GetRaceIcon(playerRace, UnitSex("player")), C.chat.text, "raceicons", "checkbox")
CreateConfig(nil, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox") CreateConfig(nil, T["Enable Player Levels"], C.chat.text, "playerlevel", "checkbox")
CreateConfig(nil, T["Who Search Unknown Classes (|cffffaaaaExperimental|r)"], C.chat.text, "whosearchunknown", "checkbox")
CreateConfig(nil, T["Colorize Unknown Classes"], C.chat.text, "tintunknown", "checkbox") CreateConfig(nil, 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")
@@ -2944,6 +2979,7 @@ pfUI:RegisterModule("gui", function ()
CreateConfig(U["nameplates"], T["Enable Debuff Timers"], C.nameplates, "debufftimers", "checkbox") CreateConfig(U["nameplates"], T["Enable Debuff Timers"], C.nameplates, "debufftimers", "checkbox")
CreateConfig(U["nameplates"], T["Show Timer Text"], C.nameplates, "debufftext", "checkbox") CreateConfig(U["nameplates"], T["Show Timer Text"], C.nameplates, "debufftext", "checkbox")
CreateConfig(Reload, T["Show Timer Animation"], C.nameplates, "debuffanim", "checkbox") CreateConfig(Reload, T["Show Timer Animation"], C.nameplates, "debuffanim", "checkbox")
CreateConfig(Reload, T["Reverse Timer Animation"], C.nameplates, "debreverse", "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")
+21 -5
View File
@@ -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
+38 -58
View File
@@ -1,25 +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
if UnitClassBase("player") ~= "DRUID" then return end if UnitClassBase("player") ~= "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()
@@ -39,57 +27,49 @@ 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()
if spellId ~= INNERVATE_SPELLID then return end
-- 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 the cooldown expires. Read the
-- precise remaining time from C_Spell.GetSpellCooldown (startTime and
-- duration are seconds from the GetTime epoch); fall back to 360s.
local cdRemaining = 360
local cd = C_Spell.GetSpellCooldown(INNERVATE_SPELLID) local cd = C_Spell.GetSpellCooldown(INNERVATE_SPELLID)
if cd and cd.duration and cd.duration > 0 then if not cd or cd.duration <= GCD_DURATION then return end
local remaining = cd.startTime + cd.duration - GetTime()
if remaining > 0 then cdRemaining = remaining end
end
C_Timer.After(cdRemaining, function() pending = false
C_Timer.After(cd.startTime + cd.duration - GetTime(), 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
local frame = CreateFrame("Frame")
frame:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
frame:RegisterEvent("SPELL_UPDATE_COOLDOWN")
frame:SetScript("OnEvent", function()
if event == "SPELL_UPDATE_COOLDOWN" then
if pending then ScheduleReady() end
return
end
-- Innervate is instant, so it logs SPELL_CAST_SUCCESS with its target
-- arg2=subevent, arg4=sourceGUID, arg9=destName, arg12=spellId
if arg2 ~= "SPELL_CAST_SUCCESS" or arg12 ~= INNERVATE_SPELLID then return end
-- Only announce our own casts
if not IsPlayerGuid(arg4) then return end
local destName = arg9
-- 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)
+61 -88
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).
@@ -86,30 +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 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)
@@ -118,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)
@@ -138,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)
@@ -167,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")
@@ -189,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)
@@ -199,15 +183,8 @@ 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 end
local playerPool = CreateObjectPool(CreatePlayerFrame, function(_, pf)
pf:Hide()
pf:ClearAllPoints()
end)
local function SetToggleTexture(toggle, isExpanded) local function SetToggleTexture(toggle, isExpanded)
if isExpanded then if isExpanded then
toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-Up") toggle:SetNormalTexture("Interface\\Buttons\\UI-MinusButton-Up")
@@ -221,13 +198,13 @@ 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)
@@ -279,7 +256,10 @@ 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(PFUI_CLASS_COLORS[class]:GetRGB()) pf.name:SetTextColor(PFUI_CLASS_COLORS[class]:GetRGB())
@@ -289,6 +269,22 @@ pfUI:RegisterModule("loothistory", function ()
if isWinner then pf.winmark:Show() else pf.winmark:Hide() end if isWinner then pf.winmark:Show() else pf.winmark:Hide() end
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.
@@ -298,46 +294,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
playerPool:ReleaseAll()
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 = playerPool:Acquire()
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)
+1 -1
View File
@@ -180,7 +180,7 @@ 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:SetFormattedText('%.1f / %.1f', mx, my) WorldMapButton.coords.text:SetFormattedText('%.1f / %.1f', mx, my)
else else
WorldMapButton.coords.text:SetText("") WorldMapButton.coords.text:SetText("")
+3 -3
View File
@@ -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
+35 -23
View File
@@ -31,7 +31,6 @@ pfUI:RegisterModule("mapreveal", function ()
end) end)
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 overlayPool = CreateTexturePool(WorldMapDetailFrame, "BORDER", nil, nil, function(_, tex) local overlayPool = CreateTexturePool(WorldMapDetailFrame, "BORDER", nil, nil, function(_, tex)
@@ -93,43 +92,45 @@ pfUI:RegisterModule("mapreveal", function ()
-- 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
overlayPool:ReleaseAll() overlayPool:ReleaseAll()
explorePool:ReleaseAll()
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
explorePool:ReleaseAll()
-- 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 {}
-- 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 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. `alreadyknown` stores the FULL paths -- explore magnifying glass icon for overlays the engine still
-- GetMapOverlayInfo returns, so compare with the full path, not the bare -- counts as unexplored.
-- name. if showExplore and unknown[string.upper(name)] then
if C.appearance.worldmap.mapexploration == "1" and not zoneKnown[string.upper(textureName)] then
local explore = explorePool:Acquire() local explore = explorePool:Acquire()
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.name = mapFileName .. " (" .. name .. ")"
@@ -147,7 +148,7 @@ 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
local tex = overlayPool:Acquire() local tex = overlayPool:Acquire()
@@ -174,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.
EventRegistry:RegisterFrameEventAndCallback("MAP_EXPLORATION_UPDATED", function()
if WorldMapFrame and WorldMapFrame:IsShown() then
pfWorldMapFrame_Update()
end
end)
end)
+18 -16
View File
@@ -103,30 +103,32 @@ 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
+56 -45
View File
@@ -77,10 +77,10 @@ pfUI:RegisterModule("nameplates", function ()
-- vs channel itself. Never called per frame. -- vs channel itself. Never called per frame.
local function PollCastInfo(unit) local function PollCastInfo(unit)
if not unit then return nil end if not unit then return nil end
local name, _, texture, startMs, endMs, _, _, _, spellID = C_Spell.UnitCastingInfo(unit) local name, _, texture, startMs, endMs, _, _, noInterrupt, spellID = C_Spell.UnitCastingInfo(unit)
local isChannel local isChannel
if not name then if not name then
name, _, texture, startMs, endMs, _, _, spellID = C_Spell.UnitChannelInfo(unit) name, _, texture, startMs, endMs, _, noInterrupt, spellID = C_Spell.UnitChannelInfo(unit)
isChannel = true isChannel = true
end end
if not name or not startMs or not endMs then return nil end if not name or not startMs or not endMs then return nil end
@@ -92,6 +92,7 @@ pfUI:RegisterModule("nameplates", function ()
endTime = endMs / 1000, endTime = endMs / 1000,
duration = (endMs - startMs) / 1000, duration = (endMs - startMs) / 1000,
isChannel = isChannel, isChannel = isChannel,
noInterrupt = noInterrupt,
} }
end end
@@ -129,8 +130,8 @@ pfUI:RegisterModule("nameplates", function ()
cfg.targetcastbar = C.nameplates["targetcastbar"] == "1" cfg.targetcastbar = C.nameplates["targetcastbar"] == "1"
cfg.notargalpha = tonumber(C.nameplates.notargalpha) or 0.5 cfg.notargalpha = tonumber(C.nameplates.notargalpha) or 0.5
if cfg.notargalpha > 1 then cfg.notargalpha = cfg.notargalpha / 100 end if cfg.notargalpha > 1 then cfg.notargalpha = cfg.notargalpha / 100 end
-- Clamp to 0.99 so non-target plates never reach 1.0 (used for target detection) -- Clamp to 1.0 so a 100% setting yields full opacity (target detection is GUID-based)
if cfg.notargalpha > 0.99 then cfg.notargalpha = 0.99 end if cfg.notargalpha > 1 then cfg.notargalpha = 1 end
cfg.namefightcolor = C.nameplates.namefightcolor == "1" cfg.namefightcolor = C.nameplates.namefightcolor == "1"
cfg.spellname = C.nameplates.spellname == "1" cfg.spellname = C.nameplates.spellname == "1"
cfg.showhp = C.nameplates.showhp == "1" cfg.showhp = C.nameplates.showhp == "1"
@@ -158,6 +159,7 @@ pfUI:RegisterModule("nameplates", function ()
cfg.debufftimers = C.nameplates.debufftimers == "1" cfg.debufftimers = C.nameplates.debufftimers == "1"
cfg.debuffanim = tonumber(C.nameplates.debuffanim) or 0 cfg.debuffanim = tonumber(C.nameplates.debuffanim) or 0
cfg.debufftext = tonumber(C.nameplates.debufftext) or 1 cfg.debufftext = tonumber(C.nameplates.debufftext) or 1
cfg.debreverse = tonumber(C.nameplates.debreverse) or 0
-- Throttle delays, resolved once instead of per plate per tick. -- Throttle delays, resolved once instead of per plate per tick.
-- libthrottle:Get walks the saved-variable table, a defaults fallback and a -- libthrottle:Get walks the saved-variable table, a defaults fallback and a
@@ -279,10 +281,6 @@ pfUI:RegisterModule("nameplates", function ()
return color return color
end end
local function DoNothing()
return
end
local function DisableObject(object) local function DisableObject(object)
if not object then return end if not object then return end
if not object.GetObjectType then return end if not object.GetObjectType then return end
@@ -380,16 +378,23 @@ pfUI:RegisterModule("nameplates", function ()
end end
local function GetUnitType(red, green, blue) -- UnitSelectionType: 0 hostile, 1 unfriendly, 2 neutral, 3 friendly (or a
if red > .9 and green < .2 and blue < .2 then -- PvP-flagged player), 4 unflagged player. Type 3 is ambiguous, so callers
return "ENEMY_NPC" -- still promote *_NPC to *_PLAYER from their own player check.
elseif red > .9 and green > .9 and blue < .2 then local selectionTypes = {
return "NEUTRAL_NPC" [0] = "ENEMY_NPC",
elseif red < .2 and green < .2 and blue > 0.9 then [1] = "ENEMY_NPC",
return "FRIENDLY_PLAYER" [2] = "NEUTRAL_NPC",
elseif red < .2 and green > .9 and blue < .2 then [3] = "FRIENDLY_NPC",
return "FRIENDLY_NPC" [4] = "FRIENDLY_PLAYER",
end }
local function GetUnitType(plate)
-- an unresolved token reads as the player's own type (4), so never ask
-- without a GUID
local guid = plate.cachedGuid
if not guid or guid == "" then return "ENEMY_NPC" end
return selectionTypes[UnitSelectionType(guid)]
end end
local filter, list, cache local filter, list, cache
@@ -436,25 +441,12 @@ pfUI:RegisterModule("nameplates", function ()
plate.debuffs[index].stacks:SetJustifyV("BOTTOM") plate.debuffs[index].stacks:SetJustifyV("BOTTOM")
plate.debuffs[index].stacks:SetTextColor(1,1,0) plate.debuffs[index].stacks:SetTextColor(1,1,0)
-- PERF: Use lightweight fake cooldown frame when animation disabled plate.debuffs[index].cd = CreateFrame("Cooldown", plate.platename.."Debuff"..index.."Cooldown", plate.debuffs[index], "CooldownFrameTemplate")
-- The Model-based CooldownFrameTemplate causes major lag with many nameplates plate.debuffs[index].cd:SetFrameLevel(6)
if cfg.debuffanim ~= 1 then
plate.debuffs[index].cd = CreateFrame("Frame", plate.platename.."Debuff"..index.."Cooldown", plate.debuffs[index])
plate.debuffs[index].cd:SetAllPoints(plate.debuffs[index])
plate.debuffs[index].cd:SetFrameLevel(6)
plate.debuffs[index].cd:SetScript("OnUpdate", CooldownFrame_OnUpdateModel)
plate.debuffs[index].cd.AdvanceTime = DoNothing
plate.debuffs[index].cd.SetSequence = DoNothing
plate.debuffs[index].cd.SetSequenceTime = DoNothing
else
-- Use CooldownFrameTemplate for animation
plate.debuffs[index].cd = CreateFrame("Model", plate.platename.."Debuff"..index.."Cooldown", plate.debuffs[index], "CooldownFrameTemplate")
plate.debuffs[index].cd:SetAllPoints(plate.debuffs[index])
plate.debuffs[index].cd:SetFrameLevel(6)
end
-- Set initial config flags (will be cached per-cooldown later) -- Set initial config flags (will be cached per-cooldown later)
plate.debuffs[index].cd.pfCooldownStyleAnimation = cfg.debuffanim plate.debuffs[index].cd.pfCooldownStyleAnimation = cfg.debuffanim
plate.debuffs[index].cd.pfCooldownReverse = cfg.debreverse or 0
plate.debuffs[index].cd.pfCooldownStyleText = cfg.debufftext plate.debuffs[index].cd.pfCooldownStyleText = cfg.debufftext
plate.debuffs[index].cd.pfCooldownType = "ALL" plate.debuffs[index].cd.pfCooldownType = "ALL"
end end
@@ -496,6 +488,7 @@ pfUI:RegisterModule("nameplates", function ()
local cooldown_anim = tonumber(C.nameplates.debuffanim) or 0 local cooldown_anim = tonumber(C.nameplates.debuffanim) or 0
nameplate.debuffs[i].cd.pfCooldownStyleText = cooldown_text nameplate.debuffs[i].cd.pfCooldownStyleText = cooldown_text
nameplate.debuffs[i].cd.pfCooldownStyleAnimation = cooldown_anim nameplate.debuffs[i].cd.pfCooldownStyleAnimation = cooldown_anim
nameplate.debuffs[i].cd.pfCooldownReverse = tonumber(C.nameplates.debreverse) or 0
end end
end end
@@ -518,6 +511,10 @@ nameplates:RegisterEvent("UPDATE_MOUSEOVER_UNIT")
-- plate's own frame, against its own token -- see OnCreate and -- plate's own frame, against its own token -- see OnCreate and
-- NAME_PLATE_UNIT_ADDED. -- NAME_PLATE_UNIT_ADDED.
nameplates:RegisterEvent("PLAYER_GUILD_UPDATE") nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
-- The interruptible flips only fire for target and focus, not nameplate
-- tokens. castState is keyed by GUID, so they still reach those units' plates.
nameplates:RegisterUnitEvent("UNIT_SPELLCAST_INTERRUPTIBLE", "target", "focus")
nameplates:RegisterUnitEvent("UNIT_SPELLCAST_NOT_INTERRUPTIBLE", "target", "focus")
nameplates:SetScript("OnEvent", function() nameplates:SetScript("OnEvent", function()
-- Stop event handling during logout to prevent crash 132 -- Stop event handling during logout to prevent crash 132
@@ -530,9 +527,11 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
end end
-- The plates hold their own unit subscriptions now, so silencing this -- The plates hold their own unit subscriptions now, so silencing this
-- frame alone would leave them dispatching through logout -- exactly what -- frame alone would leave them dispatching through logout -- exactly what
-- this branch exists to prevent. -- this branch exists to prevent. Leaving the world destroys the units
-- before PLAYER_LOGOUT fires, and a destroyed plate already dropped its
-- events and lost its methods, so only the live ones need silencing.
for plate in pairs(registry) do for plate in pairs(registry) do
if plate.nameplate then if plate.nameplate and plate.nameplate.UnregisterAllEvents then
plate.nameplate:UnregisterAllEvents() plate.nameplate:UnregisterAllEvents()
plate.nameplate:SetScript("OnEvent", nil) plate.nameplate:SetScript("OnEvent", nil)
end end
@@ -679,6 +678,17 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
-- Also propagate to all plates for alpha/strata updates -- Also propagate to all plates for alpha/strata updates
this.eventcache = true this.eventcache = true
elseif event == "UNIT_SPELLCAST_INTERRUPTIBLE" or event == "UNIT_SPELLCAST_NOT_INTERRUPTIBLE" then
local guid = UnitGUID(arg1)
local info = guid and castState[guid]
local plate = info and plateByGuid[guid]
if plate and plate.castbar then
info.noInterrupt = event == "UNIT_SPELLCAST_NOT_INTERRUPTIBLE"
-- UpdateCastbar only restyles on a new cast; force it
plate.castbar.lastEndTime = nil
plate.castUpdate = true
end
elseif event == "PLAYER_COMBO_POINTS" or event == "UNIT_COMBO_POINTS" then elseif event == "PLAYER_COMBO_POINTS" or event == "UNIT_COMBO_POINTS" then
-- Only flag the target's plate for combo point update -- Only flag the target's plate for combo point update
local plate = C_NamePlate.GetNamePlateForUnit("target") local plate = C_NamePlate.GetNamePlateForUnit("target")
@@ -858,7 +868,7 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
combopoints[i] = CreateFrame("Frame", nil, nameplate) combopoints[i] = CreateFrame("Frame", nil, nameplate)
combopoints[i]:Hide() combopoints[i]:Hide()
combopoints[i]:SetFrameLevel(8) combopoints[i]:SetFrameLevel(8)
combopoints[i].tex = combopoints[i]:CreateTexture("OVERLAY") combopoints[i].tex = combopoints[i]:CreateTexture(nil, "OVERLAY")
combopoints[i].tex:SetAllPoints() combopoints[i].tex:SetAllPoints()
if i < 3 then if i < 3 then
@@ -959,6 +969,7 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
nameplate.name:SetJustifyH(nameTextPos) nameplate.name:SetJustifyH(nameTextPos)
nameplate.health:SetOrientation(orientation) nameplate.health:SetOrientation(orientation)
nameplate.health:SetRotatesTexture(orientation == "VERTICAL")
-- Bar anchors to the plate directly so the name's JustifyH (configurable -- Bar anchors to the plate directly so the name's JustifyH (configurable
-- below) can shift left/right without dragging the bar with it. -- below) can shift left/right without dragging the bar with it.
nameplate.health:ClearAllPoints() nameplate.health:ClearAllPoints()
@@ -1081,8 +1092,7 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
levelFromDB = true levelFromDB = true
end end
local red, green, blue = plate.original.healthbar:GetStatusBarColor() local unittype = GetUnitType(plate)
local unittype = GetUnitType(red, green, blue) or "ENEMY_NPC"
local font_size = C.nameplates.use_unitfonts == "1" and C.global.font_unit_size or C.global.font_size local font_size = C.nameplates.use_unitfonts == "1" and C.global.font_unit_size or C.global.font_size
-- ignore players with npc names if plate level is lower than player level -- ignore players with npc names if plate level is lower than player level
@@ -1389,12 +1399,14 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
local cd = plate.debuffs[index].cd local cd = plate.debuffs[index].cd
cd:Show() cd:Show()
if not cachedStart or abs(cachedStart - newStart) > 0.5 then if not cachedStart or abs(cachedStart - newStart) > 0.5 then
if not cd.configCached or cd.cachedAnim ~= cfg.debuffanim or cd.cachedText ~= cfg.debufftext then if not cd.configCached or cd.cachedAnim ~= cfg.debuffanim or cd.cachedText ~= cfg.debufftext or cd.cachedReverse ~= cfg.debreverse then
cd.pfCooldownStyleAnimation = cfg.debuffanim cd.pfCooldownStyleAnimation = cfg.debuffanim
cd.pfCooldownStyleText = cfg.debufftext cd.pfCooldownStyleText = cfg.debufftext
cd.pfCooldownReverse = cfg.debreverse or 0
cd:SetAlpha(cfg.debuffanim == 1 and 1 or 0) cd:SetAlpha(cfg.debuffanim == 1 and 1 or 0)
cd.cachedAnim = cfg.debuffanim cd.cachedAnim = cfg.debuffanim
cd.cachedText = cfg.debufftext cd.cachedText = cfg.debufftext
cd.cachedReverse = cfg.debreverse
cd.configCached = true cd.configCached = true
end end
CooldownFrame_SetTimer(cd, newStart, effDuration, 1) CooldownFrame_SetTimer(cd, newStart, effDuration, 1)
@@ -1438,11 +1450,10 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
if not hasEventUpdate and (nameplate.lasttick or 0) + cfg.throttle_min > now then return end if not hasEventUpdate and (nameplate.lasttick or 0) + cfg.throttle_min > now then return end
-- PERF: Intelligent throttling based on target/castbar status and plate count -- PERF: Intelligent throttling based on target/castbar status and plate count
-- Use GUID comparison as primary target detection: instant, immune to alpha transitions, -- Use GUID comparison for target detection: instant, immune to alpha transitions,
-- and immediately correct on de-target (unlike istarget which updates one tick later) -- and immediately correct on de-target (unlike istarget which updates one tick later)
local targetGuid = state and state.targetGuid local targetGuid = state and state.targetGuid
local target = (targetGuid and nameplate.cachedGuid and targetGuid == nameplate.cachedGuid) or local target = (targetGuid and nameplate.cachedGuid and targetGuid == nameplate.cachedGuid) or nil
(state and state.targetGuid and frame:GetAlpha() >= 0.99) or nil
-- Target plate castbar runs on its own dedicated frame (nameplates.castbarFrame). -- Target plate castbar runs on its own dedicated frame (nameplates.castbarFrame).
-- For non-target plates with castbar active, use castbar throttle to ensure -- For non-target plates with castbar active, use castbar throttle to ensure
-- smooth animation without overloading the central loop. -- smooth animation without overloading the central loop.
@@ -1751,7 +1762,7 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
-- Relative 0..duration range to avoid float precision loss with large -- Relative 0..duration range to avoid float precision loss with large
-- absolute timestamps. -- absolute timestamps.
nameplate.castbar:SetMinMaxValues(0, duration) nameplate.castbar:SetMinMaxValues(0, duration)
nameplate.castbar:SetStatusBarColor(GetStringColor(C.appearance.castbar[(isChannel and "channelcolor" or "castbarcolor")])) SetCastbarShield(nameplate.castbar, nameplate.castbar.icon, castInfo.noInterrupt, isChannel)
if castInfo.icon then if castInfo.icon then
nameplate.castbar.icon.tex:SetTexture(castInfo.icon) nameplate.castbar.icon.tex:SetTexture(castInfo.icon)
nameplate.castbar.icon.tex:SetTexCoord(.1,.9,.1,.9) nameplate.castbar.icon.tex:SetTexCoord(.1,.9,.1,.9)
@@ -1960,4 +1971,4 @@ nameplates:RegisterEvent("PLAYER_GUILD_UPDATE")
end) end)
pfUI.nameplates = nameplates pfUI.nameplates = nameplates
end) end)
+1 -1
View File
@@ -25,7 +25,7 @@ pfUI:RegisterModule("nampower", function ()
pfUI.spellqueue:SetPoint("CENTER", UIParent, "CENTER", 100, -100) pfUI.spellqueue:SetPoint("CENTER", UIParent, "CENTER", 100, -100)
end end
pfUI.spellqueue.icon = pfUI.spellqueue:CreateTexture("OVERLAY") pfUI.spellqueue.icon = pfUI.spellqueue:CreateTexture(nil, "OVERLAY")
pfUI.spellqueue.icon:SetAllPoints(pfUI.spellqueue) pfUI.spellqueue.icon:SetAllPoints(pfUI.spellqueue)
pfUI.spellqueue.icon:SetTexCoord(.08, .92, .08, .92) pfUI.spellqueue.icon:SetTexCoord(.08, .92, .08, .92)
+55 -4
View File
@@ -105,11 +105,12 @@ pfUI:RegisterModule("panel", function()
do -- FPS & Lag do -- FPS & Lag
local widget = CreateFrame("Frame", "pfPanelWidgetLag", UIParent) local widget = CreateFrame("Frame", "pfPanelWidgetLag", UIParent)
local lag, fps, laghex, fpshex, _ local lag, fps, laghex, fpshex, owner, _
widget.Tooltip = function() widget.Tooltip = function(self)
owner = self
local active = 0 local active = 0
GameTooltip:ClearLines() GameTooltip:ClearLines()
GameTooltip_SetDefaultAnchor(GameTooltip, this) GameTooltip_SetDefaultAnchor(GameTooltip, self)
GameTooltip:AddLine("|cff555555" .. T["Systeminfo"]) GameTooltip:AddLine("|cff555555" .. T["Systeminfo"])
for i=1, GetNumAddOns() do for i=1, GetNumAddOns() do
if IsAddOnLoaded(i) then if IsAddOnLoaded(i) then
@@ -122,18 +123,64 @@ pfUI:RegisterModule("panel", function()
local gcmb = gckb and gckb > 0 and round((gckb or 0)/1000, 2) .. " MB" or UNAVAILABLE local gcmb = gckb and gckb > 0 and round((gckb or 0)/1000, 2) .. " MB" or UNAVAILABLE
local nin, nout, nping = GetNetStats() local nin, nout, nping = GetNetStats()
local screenWidth, screenHeight = GetPhysicalScreenSize()
GameTooltip:AddDoubleLine(T["Active Addons"], "|cffffffff" .. active .. "|cff555555 / |cffffffff" .. GetNumAddOns()) GameTooltip:AddDoubleLine(T["Active Addons"], "|cffffffff" .. active .. "|cff555555 / |cffffffff" .. GetNumAddOns())
GameTooltip:AddLine(" ") GameTooltip:AddLine(" ")
GameTooltip:AddDoubleLine(T["Memory Usage"], "|cffffffff" .. memmb) GameTooltip:AddDoubleLine(T["Memory Usage"], "|cffffffff" .. memmb)
GameTooltip:AddDoubleLine(T["Next Memory Cleanup"], "|cffffffff" .. gcmb) GameTooltip:AddDoubleLine(T["Next Memory Cleanup"], "|cffffffff" .. gcmb)
-- AddOn memory usage (see MainMenuBarPerformanceBarFrame_OnEnter in MainMenuBar.lua)
local ADDON_MEM_KB_ABBR = _G.ADDON_MEM_KB_ABBR or "(%.0f KB) %s";
local ADDON_MEM_MB_ABBR = _G.ADDON_MEM_MB_ABBR or "(%.2f MB) %s";
local TOTAL_MEM_KB_ABBR = _G.TOTAL_MEM_KB_ABBR or "AddOn Memory: %.0f KB";
local TOTAL_MEM_MB_ABBR = _G.TOTAL_MEM_MB_ABBR or "AddOn Memory: %.2f MB";
UpdateAddOnMemoryUsage()
local totalMem = 0
local topAddOns = {}
for i = 1, GetNumAddOns() do
local mem = GetAddOnMemoryUsage(i)
if mem and mem > 0 then
totalMem = totalMem + mem
for j = 1, 3 do
if not topAddOns[j] or mem > topAddOns[j].value then
for k = 3, j + 1, -1 do
topAddOns[k] = topAddOns[k - 1]
end
topAddOns[j] = { value = mem, name = C_AddOns.GetAddOnName(i) }
break
end
end
end
end
if totalMem > 0 then
local str
if totalMem > 1000 then
str = format(TOTAL_MEM_MB_ABBR, totalMem / 1000)
else
str = format(TOTAL_MEM_KB_ABBR, totalMem)
end
GameTooltip:AddLine(" ")
GameTooltip:AddLine(str, 1, 1, 1)
for i = 1, 3 do
if not topAddOns[i] then break end
if topAddOns[i].value > 1000 then
str = format(ADDON_MEM_MB_ABBR, topAddOns[i].value / 1000, topAddOns[i].name)
else
str = format(ADDON_MEM_KB_ABBR, topAddOns[i].value, topAddOns[i].name)
end
GameTooltip:AddLine(str, 1, 1, 1)
end
end
GameTooltip:AddLine(" ") GameTooltip:AddLine(" ")
GameTooltip:AddDoubleLine(T["Network Down"], "|cffffffff" .. round(nin,1) .. "KB/s") GameTooltip:AddDoubleLine(T["Network Down"], "|cffffffff" .. round(nin,1) .. "KB/s")
GameTooltip:AddDoubleLine(T["Network Up"], "|cffffffff" .. round(nout,1) .. "KB/s") GameTooltip:AddDoubleLine(T["Network Up"], "|cffffffff" .. round(nout,1) .. "KB/s")
GameTooltip:AddDoubleLine(T["Network Latency"], "|cffffffff" .. nping .. "ms") GameTooltip:AddDoubleLine(T["Network Latency"], "|cffffffff" .. nping .. "ms")
GameTooltip:AddLine(" ") GameTooltip:AddLine(" ")
GameTooltip:AddDoubleLine(T["Graphic Renderer"], "|cffffffff" .. GetCVar("gxApi")) GameTooltip:AddDoubleLine(T["Graphic Renderer"], "|cffffffff" .. GetCVar("gxApi"))
GameTooltip:AddDoubleLine(T["Screen Resolution"], "|cffffffff" .. GetCVar("gxResolution")) GameTooltip:AddDoubleLine(T["Screen Resolution"], "|cffffffff" .. screenWidth .. 'x' .. screenHeight)
GameTooltip:AddDoubleLine(T["UI-Scale"], "|cffffffff" .. round(UIParent:GetEffectiveScale(),2)) GameTooltip:AddDoubleLine(T["UI-Scale"], "|cffffffff" .. round(UIParent:GetEffectiveScale(),2))
GameTooltip:Show() GameTooltip:Show()
end end
@@ -156,6 +203,10 @@ pfUI:RegisterModule("panel", function()
end end
pfUI.panel:OutputPanel("fps", fps .. " " .. T["fps"] .. " & " .. lag .. " " .. T["ms"], widget.Tooltip, widget.Click) pfUI.panel:OutputPanel("fps", fps .. " " .. T["fps"] .. " & " .. lag .. " " .. T["ms"], widget.Tooltip, widget.Click)
if owner and GameTooltip:IsOwned(owner) then
widget.Tooltip(owner)
end
end) end)
end end
+1 -1
View File
@@ -100,7 +100,7 @@ pfUI:RegisterModule("roll", function ()
f.icon:SetWidth(esize) f.icon:SetWidth(esize)
f.icon:SetHeight(esize) f.icon:SetHeight(esize)
f.icon.tex = f.icon:CreateTexture("OVERLAY") f.icon.tex = f.icon:CreateTexture(nil, "OVERLAY")
f.icon.tex:SetTexCoord(.08, .92, .08, .92) f.icon.tex:SetTexCoord(.08, .92, .08, .92)
f.icon.tex:SetAllPoints(f.icon) f.icon.tex:SetAllPoints(f.icon)
+17 -33
View File
@@ -205,36 +205,23 @@ pfUI:RegisterModule("share", function ()
table.insert(UISpecialFrames, "pfShare") table.insert(UISpecialFrames, "pfShare")
do -- Edit Box do -- Edit Box
f.scroll = pfUI.api.CreateScrollFrame("pfShareScroll", f) f.scroll = CreateFrame("Frame", "pfShareScroll", f, "pfUIScrollingEditBoxTemplate")
f.scroll:SetPoint("TOPLEFT", f, "TOPLEFT", 10, -30) f.scroll:SetPoint("TOPLEFT", f, "TOPLEFT", 10, -30)
f.scroll:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -10, 50) f.scroll:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", -10, 50)
f.scroll:SetWidth(560) f.scroll:SetFont(pfUI.media["font:RobotoMono.ttf"], 9)
f.scroll:SetHeight(400) f.scroll:SetTextInsets(15,15,15,15)
f.scroll.backdrop = CreateFrame("Frame", "pfShareScrollBackdrop", f.scroll) -- the ScrollBox clips its children, so the backdrop is a sibling
f.scroll.backdrop:SetFrameLevel(1) f.scroll.backdrop = CreateFrame("Frame", "pfShareScrollBackdrop", f)
f.scroll.backdrop:SetPoint("TOPLEFT", f.scroll, "TOPLEFT", -5, 5) f.scroll.backdrop:SetPoint("TOPLEFT", f.scroll, "TOPLEFT", -5, 5)
f.scroll.backdrop:SetPoint("BOTTOMRIGHT", f.scroll, "BOTTOMRIGHT", 5, -5) f.scroll.backdrop:SetPoint("BOTTOMRIGHT", f.scroll, "BOTTOMRIGHT", 5, -5)
pfUI.api.CreateBackdrop(f.scroll.backdrop, nil, true) pfUI.api.CreateBackdrop(f.scroll.backdrop, nil, true)
f.scroll.backdrop.tint = f.scroll.backdrop:CreateTexture(nil, "ARTWORK")
f.scroll.backdrop.tint:SetAllPoints(f.scroll)
f.scroll.backdrop.tint:SetTexture(1,1,1,.05)
f.scroll.text = CreateFrame("EditBox", "pfShareEditBox", f.scroll) f.scroll:RegisterCallback("OnTextChanged", function()
f.scroll.text.bg = f.scroll.text:CreateTexture(nil, "OVERLAY") local text = f.scroll:GetText()
f.scroll.text.bg:SetAllPoints(f.scroll.text)
f.scroll.text.bg:SetTexture(1,1,1,.05)
f.scroll.text:SetMultiLine(true)
f.scroll.text:SetWidth(560)
f.scroll.text:SetHeight(400)
f.scroll.text:SetAllPoints(f.scroll)
f.scroll.text:SetTextInsets(15,15,15,15)
f.scroll.text:SetFont(pfUI.media["font:RobotoMono.ttf"], 9)
f.scroll.text:SetAutoFocus(false)
f.scroll.text:SetJustifyH("LEFT")
f.scroll.text:SetScript("OnEscapePressed", function() this:ClearFocus() end)
f.scroll.text:SetScript("OnTextChanged", function()
this:GetParent():UpdateScrollChildRect()
this:GetParent():UpdateScrollState()
local text = this:GetText()
local blob = Decode(text) local blob = Decode(text)
local json = not blob and DecodeJSON(text) or nil local json = not blob and DecodeJSON(text) or nil
local legacy = not blob and not json and DecodeLegacy(text) or nil local legacy = not blob and not json and DecodeLegacy(text) or nil
@@ -253,27 +240,26 @@ pfUI:RegisterModule("share", function ()
f.readButton:Enable() f.readButton:Enable()
f.readButton.text:SetText(T["Decode"]) f.readButton.text:SetText(T["Decode"])
f.readButton.func = function() f.readButton.func = function()
local current = f.scroll.text:GetText() local current = f.scroll:GetText()
local config = Decode(current) or DecodeLegacy(current) local config = Decode(current) or DecodeLegacy(current)
if config then if config then
f.scroll.text:SetText(C_EncodingUtil.SerializeJSON(config)) f.scroll:SetText(C_EncodingUtil.SerializeJSON(config))
end end
end end
elseif json then elseif json then
f.readButton:Enable() f.readButton:Enable()
f.readButton.text:SetText(T["Encode"]) f.readButton.text:SetText(T["Encode"])
f.readButton.func = function() f.readButton.func = function()
local config = DecodeJSON(f.scroll.text:GetText()) local config = DecodeJSON(f.scroll:GetText())
if config then if config then
f.scroll.text:SetText(Encode(config)) f.scroll:SetText(Encode(config))
end end
end end
else else
f.readButton:Disable() f.readButton:Disable()
f.readButton.text:SetText(T["N/A"]) f.readButton.text:SetText(T["N/A"])
end end
end) end, f)
f.scroll:SetScrollChild(f.scroll.text)
end end
do -- button: close do -- button: close
@@ -322,7 +308,7 @@ pfUI:RegisterModule("share", function ()
f.loadButton.text:SetFont(pfUI.font_default, pfUI_config.global.font_size, "OUTLINE") f.loadButton.text:SetFont(pfUI.font_default, pfUI_config.global.font_size, "OUTLINE")
f.loadButton.text:SetText(T["Import"]) f.loadButton.text:SetText(T["Import"])
f.loadButton:SetScript("OnClick", function() f.loadButton:SetScript("OnClick", function()
local text = f.scroll.text:GetText() local text = f.scroll:GetText()
local config = Decode(text) or DecodeJSON(text) or DecodeLegacy(text) local config = Decode(text) or DecodeJSON(text) or DecodeLegacy(text)
if not config then return end if not config then return end
@@ -383,9 +369,7 @@ pfUI:RegisterModule("share", function ()
ignored["disabled"] = f.ignorePosition:GetChecked() ignored["disabled"] = f.ignorePosition:GetChecked()
local encoded = Encode(DiffConfig(myconfig, defconfig, ignored) or {}) local encoded = Encode(DiffConfig(myconfig, defconfig, ignored) or {})
f.scroll.text:SetText(encoded) f.scroll:SetText(encoded)
f.scroll.text.value = encoded
f.scroll:SetVerticalScroll(0)
end) end)
end end
+1 -36
View File
@@ -1,39 +1,4 @@
pfUI:RegisterModule("skin", function () pfUI:RegisterModule("skin", function ()
-- align UIParent panels
pfUI.panelalign = CreateFrame("Frame", "pfUIParentPanelAlign", UIParent)
pfUI.panelalign:SetScript("OnUpdate", function()
-- throttle to 5 updates per second instead of every frame
if (this.tick or 0.2) > GetTime() then return else this.tick = GetTime() + 0.2 end
local left = UIParent.left
local center = UIParent.center
local rbpos, ropos
-- detect outer frame backdrops
if left and not left.rightObj then
left.rightObj = left.backdrop or left
for _, frame in pairs({left:GetChildren()}) do
rbpos = frame.backdrop and frame.backdrop.GetRight and frame.backdrop:GetRight()
ropos = left.rightObj and left.rightObj.GetRight and left.rightObj:GetRight()
if rbpos and ropos and rbpos > ropos then
left.rightObj = frame.backdrop
end
end
end
-- reset anchors
if not left or not left:IsShown() or not center or not center:IsShown() then
UIParent.pfLeftAligned = nil
return
elseif center and center:IsShown() and left and left:IsShown() then
local width = left.rightObj:GetRight()
if width and width ~= UIParent.pfLeftAligned then
center:SetPoint("TOPLEFT", "UIParent", "TOPLEFT", width + 10, -104)
UIParent.pfLeftAligned = width
end
end
end)
-- durability frame -- durability frame
pfUI.durability = CreateFrame("Frame", "pfDurability", UIParent) pfUI.durability = CreateFrame("Frame", "pfDurability", UIParent)
if pfUI.minimap then if pfUI.minimap then
@@ -79,4 +44,4 @@ pfUI:RegisterModule("skin", function ()
else else
UIErrorsFrame:RegisterEvent("UI_ERROR_MESSAGE") UIErrorsFrame:RegisterEvent("UI_ERROR_MESSAGE")
end end
end) end)
+59 -266
View File
@@ -1,10 +1,6 @@
pfUI:RegisterModule("swingtimer", function () pfUI:RegisterModule("swingtimer", function ()
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
-- HitInfo flags (EVENTS.md)
local HITINFO_LEFTSWING = 4 -- 4: Off-hand attack
local HITINFO_NOACTION = 65536 -- 65536: server did not advance the swing clock
-- SPELL_QUEUE_EVENT codes (EVENTS.md) -- SPELL_QUEUE_EVENT codes (EVENTS.md)
local ON_SWING_QUEUED = 0 local ON_SWING_QUEUED = 0
local ON_SWING_QUEUE_POPPED = 1 local ON_SWING_QUEUE_POPPED = 1
@@ -19,8 +15,6 @@ pfUI:RegisterModule("swingtimer", function ()
lastMhMarkerX = -1, lastOhMarkerX = -1, lastRaMarkerX = -1, lastMhMarkerX = -1, lastOhMarkerX = -1, lastRaMarkerX = -1,
autoAttackActive = false, autoAttackActive = false,
inCombat = false, inCombat = false,
pendingCastSpellId = nil,
mhFrozenAt = nil,
hsQueued = false, cleaveQueued = false, maulQueued = false, hsQueued = false, cleaveQueued = false, maulQueued = false,
hsSeenCurrent = false, cleaveSeenCurrent = false, maulSeenCurrent = false, hsSeenCurrent = false, cleaveSeenCurrent = false, maulSeenCurrent = false,
isWarrior = false, isWarrior = false,
@@ -31,13 +25,6 @@ pfUI:RegisterModule("swingtimer", function ()
onSwingCache = {}, onSwingCache = {},
} }
-- Wand "Shoot" runs on the ranged bar but is INDEPENDENT of the melee
-- swing clock — casters melee-weave between mainhand swings and wand
-- fires, both timers tick concurrently. Every other ranged-auto-attack
-- (Hunter Auto Shot, any future auto-repeat ranged spell) replaces MH.
local WAND_SHOOT_SPELLID = 5019
local THROW_SPELLID = 2764 -- one-shot ranged, not auto-repeat
-- On-next-swing spells replace the next auto-attack swing. -- On-next-swing spells replace the next auto-attack swing.
-- Covers Raptor Strike, Maul, Mongoose Bite, Holy Strike, etc. automatically. -- Covers Raptor Strike, Maul, Mongoose Bite, Holy Strike, etc. automatically.
local function IsOnSwingSpell(spellId) local function IsOnSwingSpell(spellId)
@@ -203,36 +190,19 @@ pfUI:RegisterModule("swingtimer", function ()
CreateBackdropShadow(pfUI.swingtimer.offhand) CreateBackdropShadow(pfUI.swingtimer.offhand)
-- Ranged bar -- Ranged bar
pfUI.swingtimer.ranged = CreateFrame("Frame", "pfSwingTimerRanged", UIParent) -- Hunters fill from the center: the bar drains toward the middle during
-- the reload, then the auto shot deadzone grows back out in the warn color.
pfUI.swingtimer.ranged = CreateFrame("StatusBar", "pfSwingTimerRanged", UIParent)
pfUI.swingtimer.ranged:SetPoint("BOTTOM", UIParent, "CENTER", -189, 83) pfUI.swingtimer.ranged:SetPoint("BOTTOM", UIParent, "CENTER", -189, 83)
pfUI.swingtimer.ranged:SetWidth(sw_width) pfUI.swingtimer.ranged:SetWidth(sw_width)
pfUI.swingtimer.ranged:SetHeight(sw_height) pfUI.swingtimer.ranged:SetHeight(sw_height)
pfUI.swingtimer.ranged:SetMinMaxValues(0, 1)
pfUI.swingtimer.ranged:SetValue(0)
pfUI.swingtimer.ranged:SetStatusBarTexture(sw_texture)
pfUI.swingtimer.ranged:SetStatusBarColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged:SetFillStyle(isHunter and "CENTER" or "STANDARD")
pfUI.swingtimer.ranged:Hide() pfUI.swingtimer.ranged:Hide()
pfUI.swingtimer.ranged.left = pfUI.swingtimer.ranged:CreateTexture(nil, "ARTWORK")
pfUI.swingtimer.ranged.left:SetTexture(sw_texture)
pfUI.swingtimer.ranged.left:SetPoint("RIGHT", pfUI.swingtimer.ranged, "CENTER", 0, 0)
pfUI.swingtimer.ranged.left:SetHeight(sw_height)
pfUI.swingtimer.ranged.left:SetWidth(sw_width / 2)
pfUI.swingtimer.ranged.left:SetTexCoord(0, 0.5, 0, 1)
pfUI.swingtimer.ranged.left:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.right = pfUI.swingtimer.ranged:CreateTexture(nil, "ARTWORK")
pfUI.swingtimer.ranged.right:SetTexture(sw_texture)
pfUI.swingtimer.ranged.right:SetPoint("LEFT", pfUI.swingtimer.ranged, "CENTER", 0, 0)
pfUI.swingtimer.ranged.right:SetHeight(sw_height)
pfUI.swingtimer.ranged.right:SetWidth(sw_width / 2)
pfUI.swingtimer.ranged.right:SetTexCoord(0.5, 1, 0, 1)
pfUI.swingtimer.ranged.right:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.warn = pfUI.swingtimer.ranged:CreateTexture(nil, "ARTWORK")
pfUI.swingtimer.ranged.warn:SetTexture(sw_texture)
pfUI.swingtimer.ranged.warn:SetPoint("CENTER", pfUI.swingtimer.ranged, "CENTER", 0, 0)
pfUI.swingtimer.ranged.warn:SetHeight(sw_height)
pfUI.swingtimer.ranged.warn:SetWidth(1)
pfUI.swingtimer.ranged.warn:SetVertexColor(rwR, rwG, rwB, rwA)
pfUI.swingtimer.ranged.warn:Hide()
pfUI.swingtimer.ranged.text = pfUI.swingtimer.ranged:CreateFontString("Status", "DIALOG", "GameFontNormal") pfUI.swingtimer.ranged.text = pfUI.swingtimer.ranged:CreateFontString("Status", "DIALOG", "GameFontNormal")
pfUI.swingtimer.ranged.text:SetPoint("CENTER", pfUI.swingtimer.ranged, "CENTER", 0, 0) pfUI.swingtimer.ranged.text:SetPoint("CENTER", pfUI.swingtimer.ranged, "CENTER", 0, 0)
pfUI.swingtimer.ranged.text:SetFont(pfUI.font_default, sw_fontsize, "OUTLINE") pfUI.swingtimer.ranged.text:SetFont(pfUI.font_default, sw_fontsize, "OUTLINE")
@@ -304,67 +274,41 @@ pfUI:RegisterModule("swingtimer", function ()
S.raSpeed = (rs and rs > 0) and rs or 0 S.raSpeed = (rs and rs > 0) and rs or 0
end end
-- Reset MH countdown to full speed (server confirmed swing) -- Start* restart a countdown from a PLAYER_SWING reset. `remaining` can be
local function ResetMH() -- shorter than the weapon speed (parry haste, ranged wind-up), so the bar
if S.mhFrozenAt then -- length stays the full swing and the fill starts part-way along.
S.mhFrozenAt = nil local function StartMH(remaining)
end
UpdateWeaponSpeeds() UpdateWeaponSpeeds()
pfUI.swingtimer.mhGraceAt = nil -- cancel any pending hide pfUI.swingtimer.mhGraceAt = nil -- cancel any pending hide
S.mhTimerMax = S.mhSpeed S.mhTimerMax = math.max(S.mhSpeed, remaining)
S.mhTimer = S.mhSpeed S.mhTimer = remaining
S.mhActive = true S.mhActive = true
pfUI.swingtimer.mainhand:Show() pfUI.swingtimer.mainhand:Show()
pfUI.swingtimer:Show() pfUI.swingtimer:Show()
end end
-- Reset OH countdown to full speed local function StartOH(remaining)
local function ResetOH()
UpdateWeaponSpeeds() UpdateWeaponSpeeds()
-- The off-hand attack time stays set with a shield equipped
if S.ohSpeed <= 0 then return end if S.ohSpeed <= 0 then return end
pfUI.swingtimer.ohGraceAt = nil -- cancel any pending hide pfUI.swingtimer.ohGraceAt = nil -- cancel any pending hide
S.ohTimerMax = S.ohSpeed S.ohTimerMax = math.max(S.ohSpeed, remaining)
S.ohTimer = S.ohSpeed S.ohTimer = remaining
S.ohActive = true S.ohActive = true
if sw_showoh then pfUI.swingtimer.offhand:Show() end if sw_showoh then pfUI.swingtimer.offhand:Show() end
pfUI.swingtimer:Show() pfUI.swingtimer:Show()
end end
-- Reset ranged countdown. replaceMH=true (Hunter Auto Shot, Throw) stops local function StartRanged(remaining)
-- the melee swing clock while ranged ticks; replaceMH=false (wand Shoot)
-- leaves it running for melee weaving.
local function ResetRanged(replaceMH)
if not sw_showranged then return end if not sw_showranged then return end
UpdateWeaponSpeeds() UpdateWeaponSpeeds()
if S.raSpeed <= 0 then return end if S.raSpeed <= 0 then return end
if replaceMH then S.raTimerMax = math.max(S.raSpeed, remaining)
S.mhActive = false S.raTimer = remaining
pfUI.swingtimer.mainhand:Hide()
end
S.raTimerMax = S.raSpeed
S.raTimer = S.raSpeed
S.raActive = true S.raActive = true
if isHunter then pfUI.swingtimer.ranged:SetStatusBarColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.left:ClearAllPoints() pfUI.swingtimer.ranged:SetValue(isHunter and 1 or 0)
pfUI.swingtimer.ranged.left:SetPoint("RIGHT", pfUI.swingtimer.ranged, "CENTER", 0, 0)
pfUI.swingtimer.ranged.left:SetWidth(sw_width / 2)
pfUI.swingtimer.ranged.left:SetTexCoord(0, 0.5, 0, 1)
pfUI.swingtimer.ranged.right:SetWidth(sw_width / 2)
pfUI.swingtimer.ranged.right:SetTexCoord(0.5, 1, 0, 1)
else
pfUI.swingtimer.ranged.left:ClearAllPoints()
pfUI.swingtimer.ranged.left:SetPoint("TOPLEFT", pfUI.swingtimer.ranged, "TOPLEFT", 0, 0)
pfUI.swingtimer.ranged.left:SetWidth(0.1)
pfUI.swingtimer.ranged.left:Hide()
pfUI.swingtimer.ranged.left:SetTexCoord(0, 0, 0, 1)
pfUI.swingtimer.ranged.right:SetWidth(0.1)
pfUI.swingtimer.ranged.right:Hide()
end
pfUI.swingtimer.ranged.left:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.right:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.warn:SetWidth(1)
pfUI.swingtimer.ranged.warn:Hide()
pfUI.swingtimer.ranged:Show() pfUI.swingtimer.ranged:Show()
pfUI.swingtimer:Show() pfUI.swingtimer:Show()
end end
@@ -486,23 +430,17 @@ pfUI:RegisterModule("swingtimer", function ()
local anyActive = false local anyActive = false
-- Tick timers down. When a timer expires we give a short grace period before -- Tick timers down. When a timer expires we give a short grace period before
-- hiding the bar, to bridge the 1-2 frame gap until AUTO_ATTACK_SELF arrives. -- hiding the bar, to bridge the 1-2 frame gap until PLAYER_SWING arrives.
-- If AUTO_ATTACK_SELF arrives during the grace period it resets the timer -- If PLAYER_SWING arrives during the grace period it resets the timer
-- normally and the grace timer is cleared. If not (e.g. auto-attack was -- normally and the grace timer is cleared. If not (e.g. auto-attack was
-- turned off), the bar hides after the grace period ends. -- turned off), the bar hides after the grace period ends.
local GRACE = 0.15 -- seconds to wait after timer hits 0 before hiding local GRACE = 0.15 -- seconds to wait after timer hits 0 before hiding
if S.mhActive then if S.mhActive then
-- Don't tick while frozen (swing-delay spell like Slam is being cast) S.mhTimer = S.mhTimer - delta
if not S.mhFrozenAt then
S.mhTimer = S.mhTimer - delta
end
if S.mhTimer <= 0 then if S.mhTimer <= 0 then
S.mhTimer = 0 S.mhTimer = 0
if S.mhFrozenAt then if not pfUI.swingtimer.mhGraceAt then
-- Swing-delay spell cast in progress: bar holds at 0, skip grace/hide.
-- SPELL_GO handler will unfreeze and add cast duration to timer.
elseif not pfUI.swingtimer.mhGraceAt then
pfUI.swingtimer.mhGraceAt = GetTime() + GRACE pfUI.swingtimer.mhGraceAt = GetTime() + GRACE
elseif GetTime() >= pfUI.swingtimer.mhGraceAt then elseif GetTime() >= pfUI.swingtimer.mhGraceAt then
pfUI.swingtimer.mhGraceAt = nil pfUI.swingtimer.mhGraceAt = nil
@@ -641,30 +579,12 @@ pfUI:RegisterModule("swingtimer", function ()
local remaining = S.raTimer local remaining = S.raTimer
if isHunter then if isHunter then
local DEADZONE = 0.5 local DEADZONE = 0.5
local halfW = sw_width / 2
if remaining > DEADZONE then if remaining > DEADZONE then
local elapsed = S.raTimerMax - remaining pfUI.swingtimer.ranged:SetStatusBarColor(raR, raG, raB, raA)
local phase1dur = S.raTimerMax - DEADZONE pfUI.swingtimer.ranged:SetValue((remaining - DEADZONE) / (S.raTimerMax - DEADZONE))
local p = elapsed / phase1dur
local w = halfW * (1 - p)
if w < 1 then w = 1 end
pfUI.swingtimer.ranged.left:Show()
pfUI.swingtimer.ranged.left:SetWidth(w)
pfUI.swingtimer.ranged.left:SetTexCoord(0, (1 - p) * 0.5, 0, 1)
pfUI.swingtimer.ranged.left:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.right:Show()
pfUI.swingtimer.ranged.right:SetWidth(w)
pfUI.swingtimer.ranged.right:SetTexCoord(1 - (1 - p) * 0.5, 1, 0, 1)
pfUI.swingtimer.ranged.right:SetVertexColor(raR, raG, raB, raA)
pfUI.swingtimer.ranged.warn:Hide()
else else
local p = 1 - (remaining / DEADZONE) pfUI.swingtimer.ranged:SetStatusBarColor(rwR, rwG, rwB, rwA)
local w = sw_width * p pfUI.swingtimer.ranged:SetValue(1 - (remaining / DEADZONE))
if w < 1 then w = 1 end
pfUI.swingtimer.ranged.left:Hide()
pfUI.swingtimer.ranged.right:Hide()
pfUI.swingtimer.ranged.warn:SetWidth(w)
pfUI.swingtimer.ranged.warn:Show()
end end
if sw_showtext then if sw_showtext then
if remaining <= 0.5 then if remaining <= 0.5 then
@@ -674,14 +594,7 @@ pfUI:RegisterModule("swingtimer", function ()
end end
end end
else else
local progress = 1 - (remaining / S.raTimerMax) pfUI.swingtimer.ranged:SetValue(1 - (remaining / S.raTimerMax))
local w = sw_width * progress
if w < 1 then w = 1 end
pfUI.swingtimer.ranged.left:Show()
pfUI.swingtimer.ranged.left:SetWidth(w)
pfUI.swingtimer.ranged.left:SetTexCoord(0, progress, 0, 1)
pfUI.swingtimer.ranged.right:Hide()
pfUI.swingtimer.ranged.warn:Hide()
if sw_showtext then if sw_showtext then
pfUI.swingtimer.ranged.text:SetFormattedText("%.1f", math.floor(remaining * 10) / 10) pfUI.swingtimer.ranged.text:SetFormattedText("%.1f", math.floor(remaining * 10) / 10)
end end
@@ -722,164 +635,46 @@ pfUI:RegisterModule("swingtimer", function ()
end end
end) end)
-- SPELL_START_SELF: fires only for cast-time spells, never instants
local spellStartFrame = CreateFrame("Frame")
spellStartFrame:RegisterEvent("SPELL_START_SELF")
spellStartFrame:SetScript("OnEvent", function()
if not (arg1 and arg1 > 0) then return end
S.pendingCastSpellId = arg1
-- Freeze the swing timer for cast-time spells that DON'T reset auto-
-- attack on completion (Slam, Hammer of Wrath on Turtle, etc.) — those
-- let the swing resume from where it paused. C_Spell.ResetsMeleeSwing
-- mirrors the server rule; spells that reset don't need freezing (they
-- reset on SPELL_GO_SELF). Subsumes the old hardcoded swingDelaySpells
-- list (no list maintenance for new Slam-style spells).
if S.mhActive then
if not C_Spell.ResetsMeleeSwing(arg1) then
S.mhFrozenAt = GetTime()
end
end
end)
-- Cast cancel/fail/interrupt: unfreeze swing timer if a delay spell was interrupted
local spellFailFrame = CreateFrame("Frame")
spellFailFrame:RegisterEvent("SPELLCAST_FAILED")
spellFailFrame:RegisterEvent("SPELLCAST_INTERRUPTED")
spellFailFrame:SetScript("OnEvent", function()
if S.mhFrozenAt then
S.mhFrozenAt = nil
end
S.pendingCastSpellId = nil
end)
-- SPELL_GO hook via libdebuff
pfUI.libdebuff_spell_go_hooks = pfUI.libdebuff_spell_go_hooks or {}
pfUI.libdebuff_spell_go_hooks["swingtimer"] = function(spellId)
-- C_Spell.IsRangedAutoAttackSpell catches both Auto Shot (75) and
-- wand Shoot (5019) via Spell.dbc's AUTO_REPEAT attribute (covers
-- any future auto-repeat ranged spell automatically). Wand is the
-- one independent of the MH swing — everything else replaces it.
-- Throw isn't auto-repeat (single-shot) so it's handled explicitly.
if C_Spell.IsRangedAutoAttackSpell(spellId) then
ResetRanged(spellId ~= WAND_SHOOT_SPELLID)
return
elseif spellId == THROW_SPELLID then
ResetRanged(true)
return
elseif IsOnSwingSpell(spellId) then
-- On-next-swing ability (HS / Cleave / Maul / Raptor Strike / etc.)
-- — the swing fires as the spell consumes it. Drop the queued color.
S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false
ResetMH()
else
-- C_Spell.ResetsMeleeSwing mirrors the server rule (Turtle's
-- Spell::IsMeleeAttackResetSpell): InterruptFlags has AUTOATTACK and
-- AttributesEx2 lacks NOT_RESET_AUTO_ACTIONS. When the spell resets the
-- swing, snap the timers to full. Otherwise (elseif) a frozen-swing-
-- during-cast is a Slam-style cast — push the timer forward by the cast
-- duration so the bar resumes from where it paused.
if C_Spell.ResetsMeleeSwing(spellId) then
if S.mhActive and S.mhSpeed > 0 then
UpdateWeaponSpeeds()
S.mhTimerMax = S.mhSpeed
S.mhTimer = S.mhSpeed
end
if S.ohActive and S.ohSpeed > 0 then
S.ohTimerMax = S.ohSpeed
S.ohTimer = S.ohSpeed
end
elseif S.mhFrozenAt then
local castDuration = GetTime() - S.mhFrozenAt
S.mhTimer = S.mhTimer + castDuration
S.mhTimerMax = S.mhTimerMax + castDuration
S.mhFrozenAt = nil
end
end
S.pendingCastSpellId = nil
end
-- SPELL_CAST_EVENT hook: HS/Cleave/Maul queue tracking
pfUI.libdebuff_spell_cast_hooks = pfUI.libdebuff_spell_cast_hooks or {}
pfUI.libdebuff_spell_cast_hooks["swingtimer"] = function(success, spellId)
local kind = ClassifyOnSwingSpell(spellId)
if not kind then return end
S.useSpellQueueEvent = true
SetQueuedKind(kind)
end
local events = CreateFrame("Frame") local events = CreateFrame("Frame")
events:RegisterEvent("AUTO_ATTACK_SELF") events:RegisterEvent("PLAYER_SWING")
events:RegisterEvent("AUTO_ATTACK_OTHER")
events:RegisterEvent("PLAYER_ENTERING_WORLD") events:RegisterEvent("PLAYER_ENTERING_WORLD")
events:RegisterEvent("PLAYER_EQUIPMENT_CHANGED") -- ClassicAPI: per-slot, equipment-only events:RegisterEvent("PLAYER_EQUIPMENT_CHANGED") -- ClassicAPI: per-slot, equipment-only
events:RegisterEvent("PLAYER_REGEN_DISABLED") events:RegisterEvent("PLAYER_REGEN_DISABLED")
events:RegisterEvent("PLAYER_REGEN_ENABLED") events:RegisterEvent("PLAYER_REGEN_ENABLED")
events:RegisterEvent("ACTIONBAR_SLOT_CHANGED") events:RegisterEvent("ACTIONBAR_SLOT_CHANGED")
events:RegisterUnitEvent("UNIT_DIED", UnitGUID("player")) events:RegisterEvent("PLAYER_DEAD")
events:RegisterUnitEvent("UNIT_SPELLCAST_SENT", "player")
events:RegisterUnitEvent("UNIT_SPELLCAST_SUCCEEDED", "player")
events:RegisterEvent("SPELL_QUEUE_EVENT") events:RegisterEvent("SPELL_QUEUE_EVENT")
events:RegisterEvent("START_AUTOATTACK") events:RegisterEvent("START_AUTOATTACK")
events:RegisterEvent("STOP_AUTOATTACK") events:RegisterEvent("STOP_AUTOATTACK")
events:SetScript("OnEvent", function() events:SetScript("OnEvent", function()
if event == "AUTO_ATTACK_SELF" then if event == "PLAYER_SWING" then
local hitInfo = arg4 or 0 -- ClassicAPI tracks the server's swing clock (white hits, on-next-swing
local isOffhand = bit.band(hitInfo, HITINFO_LEFTSWING) ~= 0 -- abilities, swing-reset casts, parry haste, extra attacks, weapon
local noAction = bit.band(hitInfo, HITINFO_NOACTION) ~= 0 -- swaps) and hands over the seconds left until the next swing.
-- NOACTION means server did not advance swing clock (dodge/parry/miss). if arg2 == Enum.PlayerSwingType.MainHand then
-- Only skip if the timer is already running - if it's not active yet StartMH(arg1)
-- (first swing ever), we still want to start it so the bar appears. elseif arg2 == Enum.PlayerSwingType.OffHand then
if noAction then StartOH(arg1)
if isOffhand and S.ohActive then return end elseif arg2 == Enum.PlayerSwingType.Ranged then
if not isOffhand and S.mhActive then return end StartRanged(arg1)
end end
-- Extra attack detection: if timer still has >20% remaining for that hand, elseif event == "UNIT_SPELLCAST_SENT" then
-- the server did NOT reset the swing clock -> this is an extra attack, skip. -- arg4 = spellID: an on-next-swing ability (HS / Cleave / Maul) queued
-- Use 20% here (SP_SwingTimer's ShouldResetTimer threshold). local kind = ClassifyOnSwingSpell(arg4)
-- Exception: if timer is already at 0 (expired), always accept. if kind then
if isOffhand then S.useSpellQueueEvent = true
local pct = S.ohActive and (S.ohTimer / S.ohTimerMax) or 0 SetQueuedKind(kind)
if S.ohActive and S.ohTimer > 0 and pct > 0.20 then
return
end
ResetOH()
else
local pct = S.mhActive and (S.mhTimer / S.mhTimerMax) or 0
if S.mhActive and S.mhTimer > 0 and pct > 0.20 then
return
end
ResetMH()
end end
elseif event == "AUTO_ATTACK_OTHER" then elseif event == "UNIT_SPELLCAST_SUCCEEDED" then
-- Parry haste: enemy attacked the player and player parried -- arg3 = spellID: the on-next-swing ability resolved, which consumes
local targetGuid = arg2 -- the queue, so drop the queued color
if not targetGuid or not IsPlayerGuid(targetGuid) then return end if IsOnSwingSpell(arg3) then
local victimState = arg5 or 0 S.hsQueued = false; S.cleaveQueued = false; S.maulQueued = false
-- VICTIMSTATE_PARRY = 3
-- Vanilla: parry reduces the NEXT swing timer by 40% of weapon speed,
-- minimum 20% of weapon speed remaining (SP_SwingTimer approach)
if victimState == 3 then
-- Apply to whichever swing comes next (smallest % remaining = closest to firing)
if S.ohActive and S.ohSpeed > 0 and (S.ohTimer / S.ohTimerMax) < (S.mhTimer / S.mhTimerMax) then
local minimum = S.ohSpeed * 0.20
if S.ohTimer > minimum then
local reduct = S.ohSpeed * 0.40
local before = S.ohTimer
S.ohTimer = S.ohTimer - reduct
if S.ohTimer < minimum then S.ohTimer = minimum end
end
elseif S.mhActive and S.mhSpeed > 0 then
local minimum = S.mhSpeed * 0.20
if S.mhTimer > minimum then
local reduct = S.mhSpeed * 0.40
local before = S.mhTimer
S.mhTimer = S.mhTimer - reduct
if S.mhTimer < minimum then S.mhTimer = minimum end
end
else
end
end end
elseif event == "SPELL_QUEUE_EVENT" then elseif event == "SPELL_QUEUE_EVENT" then
@@ -931,10 +726,8 @@ pfUI:RegisterModule("swingtimer", function ()
S.cleaveQueued = false S.cleaveQueued = false
S.maulQueued = false S.maulQueued = false
elseif event == "UNIT_DIED" then elseif event == "PLAYER_DEAD" then
if IsPlayerGuid(arg1) then ResetAll()
ResetAll()
end
end end
end) end)
+2 -26
View File
@@ -866,9 +866,6 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
if C.thirdparty.supermacro.enable == "0" then return end if C.thirdparty.supermacro.enable == "0" then return end
if not pfUI.bars then return end if not pfUI.bars then return end
-- skin game menu button
SkinButton(GameMenuButtonSuperMacro)
-- hook events to include SuperMacro refreshs -- hook events to include SuperMacro refreshs
local ButtonFullUpdate = pfUI.bars.ButtonFullUpdate local ButtonFullUpdate = pfUI.bars.ButtonFullUpdate
pfUI.bars.ButtonFullUpdate = function(button) pfUI.bars.ButtonFullUpdate = function(button)
@@ -1175,21 +1172,9 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
end) end)
local EnableHealComm = function() local EnableHealComm = function()
-- hook healcomm's addon message to parse single-player events -- HealComm-1.0 already broadcasts this player's casts: keep libpredict
-- tracking them, but stop it sending a second copy
if AceLibrary and AceLibrary:HasInstance("HealComm-1.0") and pfUI.api.libpredict then if AceLibrary and AceLibrary:HasInstance("HealComm-1.0") and pfUI.api.libpredict then
local HealComm = AceLibrary("HealComm-1.0")
-- use pfUI frames to draw healComm predictions
local pfHookHealCommSendAddonMessage = HealComm.SendAddonMessage
function HealComm.SendAddonMessage(this, msg)
if not IsInGroup() then
libpredict:ParseChatMessage(UnitName("player"), msg, "HealComm")
end
pfHookHealCommSendAddonMessage(this, msg)
end
-- disable pfUI predictions
pfUI.api.libpredict.sender:UnregisterAllEvents()
pfUI.api.libpredict.sender.enabled = nil pfUI.api.libpredict.sender.enabled = nil
end end
end end
@@ -1197,16 +1182,7 @@ pfUI:RegisterModule("thirdparty-vanilla", function()
HookAddonOrVariable("LunaUnitFrames", EnableHealComm) HookAddonOrVariable("LunaUnitFrames", EnableHealComm)
HookAddonOrVariable("NotGrid", EnableHealComm) HookAddonOrVariable("NotGrid", EnableHealComm)
HookAddonOrVariable("MoveAnything", function()
SkinButton(GameMenuButtonMoveAnything)
end)
HookAddonOrVariable("MCP", function()
SkinButton(GameMenuButtonAddOns)
end)
HookAddonOrVariable("HardcoreDeath", function() HookAddonOrVariable("HardcoreDeath", function()
SkinButton(GameMenuButtonHardcoreDeathLogGUI)
GameMenuFrame:SetHeight(GameMenuFrame:GetHeight() + 20) GameMenuFrame:SetHeight(GameMenuFrame:GetHeight() + 20)
end) end)
+2 -1
View File
@@ -113,8 +113,9 @@ pfUI:RegisterModule("totems", function ()
self.bar[i].cdbg = self.bar[i].cdbg or CreateFrame("Frame", nil, self.bar[i]) self.bar[i].cdbg = self.bar[i].cdbg or CreateFrame("Frame", nil, self.bar[i])
self.bar[i].cdbg:SetSize(self.iconsize - 3, self.iconsize - 3) self.bar[i].cdbg:SetSize(self.iconsize - 3, self.iconsize - 3)
self.bar[i].cdbg:SetPoint("CENTER", self.bar[i], "CENTER", 0, 0) self.bar[i].cdbg:SetPoint("CENTER", self.bar[i], "CENTER", 0, 0)
self.bar[i].cd = self.bar[i].cd or CreateFrame("Model", "pfTotemsBar"..i.."Cooldown", self.bar[i].cdbg, "CooldownFrameTemplate") self.bar[i].cd = self.bar[i].cd or CreateFrame("Cooldown", "pfTotemsBar"..i.."Cooldown", self.bar[i].cdbg, "CooldownFrameTemplate")
self.bar[i].cd.pfCooldownStyleAnimation = 1 self.bar[i].cd.pfCooldownStyleAnimation = 1
self.bar[i].cd.pfCooldownReverse = tonumber(pfUI_config.totems.cooldown_reverse) or 0
self.bar[i].cd.pfCooldownType = "ALL" self.bar[i].cd.pfCooldownType = "ALL"
self.bar[i]:RegisterForClicks("LeftButtonUp", "RightButtonUp") self.bar[i]:RegisterForClicks("LeftButtonUp", "RightButtonUp")
+12 -19
View File
@@ -30,10 +30,18 @@ pfUI:RegisterModule("tracking", function ()
pfUI.tracking:SetWidth(size) pfUI.tracking:SetWidth(size)
pfUI.tracking:SetHeight(size) pfUI.tracking:SetHeight(size)
pfUI.tracking.icon = pfUI.tracking:CreateTexture("BACKGROUND") pfUI.tracking.icon = pfUI.tracking:CreateTexture(nil, "BACKGROUND")
pfUI.tracking.icon:SetTexCoord(.08, .92, .08, .92) pfUI.tracking.icon:SetTexCoord(.08, .92, .08, .92)
pfUI.tracking.icon:SetAllPoints(pfUI.tracking) pfUI.tracking.icon:SetAllPoints(pfUI.tracking)
-- Pulses the icon while no tracking spell is active
pfUI.tracking.pulse = pfUI.tracking.icon:CreateAnimationGroup()
pfUI.tracking.pulse:SetLooping("BOUNCE")
local fade = pfUI.tracking.pulse:CreateAnimation("Alpha")
fade:SetChange(-.5)
fade:SetDuration(.5)
fade:SetSmoothing("IN_OUT")
pfUI.tracking.menu = CreateFrame("Frame", "pfUIDropDownMenuTracking", nil, "UIDropDownMenuTemplate") pfUI.tracking.menu = CreateFrame("Frame", "pfUIDropDownMenuTracking", nil, "UIDropDownMenuTemplate")
pfUI.tracking:RegisterEvent("PLAYER_ENTERING_WORLD") pfUI.tracking:RegisterEvent("PLAYER_ENTERING_WORLD")
@@ -48,19 +56,6 @@ pfUI:RegisterModule("tracking", function ()
this:RefreshMenu() this:RefreshMenu()
end) end)
pfUI.tracking:SetScript("OnUpdate", function()
if this.pulse then
local _,_,_,alpha = this.icon:GetVertexColor()
local fpsmod = GetFramerate() / 30
if not alpha or alpha >= 0.9 then
this.modifier = -0.03 / fpsmod
elseif alpha <= .5 then
this.modifier = 0.03 / fpsmod
end
this.icon:SetVertexColor(1,1,1,alpha + this.modifier)
end
end)
pfUI.tracking:RegisterForClicks("LeftButtonUp", "RightButtonUp") pfUI.tracking:RegisterForClicks("LeftButtonUp", "RightButtonUp")
pfUI.tracking:SetScript("OnClick", function() pfUI.tracking:SetScript("OnClick", function()
if arg1 == "RightButton" then if arg1 == "RightButton" then
@@ -113,20 +108,18 @@ pfUI:RegisterModule("tracking", function ()
local texture = GetTrackingTexture() local texture = GetTrackingTexture()
if texture and texture ~= state.texture then if texture and texture ~= state.texture then
state.texture = texture state.texture = texture
pfUI.tracking.pulse = nil pfUI.tracking.pulse:Stop()
pfUI.tracking.icon:SetTexture(texture) pfUI.tracking.icon:SetTexture(texture)
pfUI.tracking.icon:SetVertexColor(1,1,1,1)
pfUI.tracking:Show() pfUI.tracking:Show()
elseif not texture then elseif not texture then
state.texture = nil state.texture = nil
if pulse and next(state.spells) ~= nil then if pulse and next(state.spells) ~= nil then
pfUI.tracking.pulse = true
pfUI.tracking.icon:SetTexture("Interface\\Icons\\INV_Misc_QuestionMark") pfUI.tracking.icon:SetTexture("Interface\\Icons\\INV_Misc_QuestionMark")
pfUI.tracking.icon:SetVertexColor(1,1,1,1) if not pfUI.tracking.pulse:IsPlaying() then pfUI.tracking.pulse:Play() end
pfUI.tracking:Show() pfUI.tracking:Show()
else else
pfUI.tracking.pulse = nil pfUI.tracking.pulse:Stop()
pfUI.tracking:Hide() pfUI.tracking:Hide()
end end
end end
+2 -4
View File
@@ -98,11 +98,9 @@ pfUI:RegisterModule("turtle-wow", function ()
GameMenuButtonOptions:ClearAllPoints() GameMenuButtonOptions:ClearAllPoints()
GameMenuButtonOptions:SetPoint("TOP", GameMenuButtonShop, "BOTTOM", 0, -16) GameMenuButtonOptions:SetPoint("TOP", GameMenuButtonShop, "BOTTOM", 0, -16)
-- apply pfUI skin to the new shop button -- match the shop button's text to the other skinned menu buttons
if pfUI.skin["Game Menu"] and pfUI_config["disabled"]["skin_Game Menu"] ~= "1" then if pfUI.skin["Game Menu"] and pfUI_config["disabled"]["skin_Game Menu"] ~= "1" then
local font = GameMenuButtonShop:GetFontString() GameMenuButtonShop:GetFontString():SetTextColor(1,1,1,1)
font:SetTextColor(1,1,1,1)
SkinButton(GameMenuButtonShop)
end end
end end
+11 -12
View File
@@ -130,15 +130,6 @@ pfUI:RegisterModule("unlock", function ()
return frames return frames
end end
local function DraggerOnUpdate()
this.text:SetAlpha(this.text:GetAlpha() -0.05)
if this.text:GetAlpha() < 0.1 then
this.text:SetText(strsub(this:GetParent():GetName(),3))
this.text:SetAlpha(1)
this:SetScript("OnUpdate", function() return end)
end
end
local function SaveScale(frame, scale) local function SaveScale(frame, scale)
frame:SetScale(scale) frame:SetScale(scale)
@@ -148,9 +139,8 @@ pfUI:RegisterModule("unlock", function ()
C.position[frame:GetName()]["scale"] = scale C.position[frame:GetName()]["scale"] = scale
frame.drag.text:SetText(T["Scale"] .. ": " .. scale) frame.drag.text:SetText(T["Scale"] .. ": " .. scale)
frame.drag.text:SetAlpha(1) frame.drag.fade:Stop()
frame.drag.fade:Play()
frame.drag:SetScript("OnUpdate", DraggerOnUpdate)
end end
local function SavePosition(frame) local function SavePosition(frame)
@@ -455,6 +445,15 @@ pfUI:RegisterModule("unlock", function ()
d.text:SetPoint("CENTER", 0, 0) d.text:SetPoint("CENTER", 0, 0)
d.text:SetFontObject(GameFontWhite) d.text:SetFontObject(GameFontWhite)
-- Fades out the scale readout, then puts the frame name back
d.fade = d.text:CreateAnimationGroup()
local fade = d.fade:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(.3)
d.fade:SetScript("OnFinished", function()
d.text:SetText(strsub(f:GetName(),3))
end)
d.frame = f d.frame = f
d.fname = fname d.fname = fname
d.label = label d.label = label
+21
View File
@@ -34,4 +34,25 @@ pfUI:RegisterModule("unusable", function ()
hooksecurefunc("BankFrameItemButton_UpdateLock", function() hooksecurefunc("BankFrameItemButton_UpdateLock", function()
pfUI.unusable:UpdateSlot(-1, this:GetID()) pfUI.unusable:UpdateSlot(-1, this:GetID())
end) end)
-- requirement changes (level, proficiency/skill, required spell, reputation,
-- honor rank) don't touch the bags; queue a full rebag through pfUI.bag's
-- coalesced delay, whose UpdateSlot resets the tint before we reapply it
local refresh = CreateFrame("Frame")
refresh:RegisterEvent("PLAYER_LEVEL_UP")
refresh:RegisterEvent("SKILL_LINES_CHANGED")
refresh:RegisterEvent("SPELLS_CHANGED")
refresh:RegisterEvent("FACTION_STANDING_CHANGED")
refresh:RegisterEvent("PLAYER_PVP_RANK_CHANGED")
refresh:SetScript("OnEvent", function()
for _, bag in pairs(pfUI.BACKPACK) do
pfUI.bag.delay.UpdateBag[bag] = true
end
-- the bank frame is only created on first bank visit
if pfUI.bag.left and pfUI.bag.left:IsShown() then
for _, bag in pairs(pfUI.BANK) do
pfUI.bag.delay.UpdateBag[bag] = true
end
end
end)
end) end)
+29 -9
View File
@@ -63,9 +63,16 @@ pfUI:RegisterModule("xpbar", function ()
end end
end) end)
-- Cancel a running fade-out and show the bar at full alpha
local function Reveal(self)
self.fade:Stop()
self:SetAlpha(1)
end
local function OnLeave(self) local function OnLeave(self)
local self = self or this local self = self or this
self.hover = nil
self.tick = GetTime() + 3.00 self.tick = GetTime() + 3.00
GameTooltip:Hide() GameTooltip:Hide()
end end
@@ -82,7 +89,8 @@ local function OnEnter(self)
mode = "REP" mode = "REP"
end end
self:SetAlpha(1) self.hover = true
Reveal(self)
if mode == "XP" then if mode == "XP" then
local xp, xpmax, exh = UnitXP("player"), UnitXPMax("player"), GetXPExhaustion() local xp, xpmax, exh = UnitXP("player"), UnitXPMax("player"), GetXPExhaustion()
@@ -183,13 +191,15 @@ end
local self = self or this local self = self or this
if self.text_mouse == "1" then if self.text_mouse == "1" then
self.bar.text:SetShown(MouseIsOver(self)) self.bar.text:SetShown(self.hover)
end end
if self.always then return end if self.always then return end
if self:GetAlpha() == 0 or MouseIsOver(self) then return end -- Hover comes from OnEnter/OnLeave, the same mouse focus that reveals the
if ( self.tick or 1) > GetTime() then return else self.tick = GetTime() + .01 end -- bar, so the fade can't restart under the cursor
self:SetAlpha(self:GetAlpha() - .05) if self:GetAlpha() == 0 or self.hover or self.fade:IsPlaying() then return end
if ( self.tick or 1) > GetTime() then return end
self.fade:Play()
end end
local function OnEvent(self) local function OnEvent(self)
@@ -210,7 +220,7 @@ end
end end
if self.always then if self.always then
self:SetAlpha(1) Reveal(self)
self:Show() self:Show()
end end
@@ -220,7 +230,7 @@ end
if mode == "XP" then if mode == "XP" then
self.enabled = true self.enabled = true
self:SetAlpha(1) Reveal(self)
self.bar:SetMinMaxValues(0, UnitXPMax("player")) self.bar:SetMinMaxValues(0, UnitXPMax("player"))
self.bar:SetValue(UnitXP("player")) self.bar:SetValue(UnitXP("player"))
if GetXPExhaustion() then if GetXPExhaustion() then
@@ -246,7 +256,7 @@ end
elseif mode == "PETXP" then elseif mode == "PETXP" then
self.restedbar:Hide() self.restedbar:Hide()
self.enabled = true self.enabled = true
self:SetAlpha(1) Reveal(self)
local currXP, nextXP = GetPetExperience() local currXP, nextXP = GetPetExperience()
self.bar:SetMinMaxValues(min(0, currXP), nextXP) self.bar:SetMinMaxValues(min(0, currXP), nextXP)
@@ -264,7 +274,7 @@ end
local name, standingID, barMin, barMax, barValue = GetRepDisplay(self.factionID) local name, standingID, barMin, barMax, barValue = GetRepDisplay(self.factionID)
if name then if name then
self.enabled = true self.enabled = true
self:SetAlpha(1) Reveal(self)
barMax = barMax - barMin barMax = barMax - barMin
barValue = barValue - barMin barValue = barValue - barMin
@@ -342,6 +352,7 @@ end
local cr, cg, cb, ca = pfUI.api.GetStringColor(b.xp_color) local cr, cg, cb, ca = pfUI.api.GetStringColor(b.xp_color)
b.bar:SetStatusBarColor(cr,cg,cb,ca) b.bar:SetStatusBarColor(cr,cg,cb,ca)
b.bar:SetOrientation(b.mode) b.bar:SetOrientation(b.mode)
b.bar:SetRotatesTexture(b.mode == "VERTICAL")
b.bar.text = b.bar.text or b.bar:CreateFontString() b.bar.text = b.bar.text or b.bar:CreateFontString()
b.bar.text:SetPoint("CENTER", b, "CENTER", 0, b.text_off_y) b.bar.text:SetPoint("CENTER", b, "CENTER", 0, b.text_off_y)
@@ -358,10 +369,19 @@ end
local cr, cg, cb, ca = pfUI.api.GetStringColor(b.rest_color) local cr, cg, cb, ca = pfUI.api.GetStringColor(b.rest_color)
b.restedbar:SetStatusBarColor(cr,cg,cb,ca) b.restedbar:SetStatusBarColor(cr,cg,cb,ca)
b.restedbar:SetOrientation(b.mode) b.restedbar:SetOrientation(b.mode)
b.restedbar:SetRotatesTexture(b.mode == "VERTICAL")
-- auto hide -- auto hide
b:EnableMouse(true) b:EnableMouse(true)
if not b.fade then
b.fade = b:CreateAnimationGroup()
local fade = b.fade:CreateAnimation("Alpha")
fade:SetChange(-1)
fade:SetDuration(.3)
b.fade:SetScript("OnFinished", function() b:SetAlpha(0) end)
end
b:RegisterEvent("FACTION_STANDING_CHANGED") b:RegisterEvent("FACTION_STANDING_CHANGED")
b:RegisterUnitEvent("UNIT_PET", "player") b:RegisterUnitEvent("UNIT_PET", "player")
b:RegisterUnitEvent("UNIT_LEVEL", "player") b:RegisterUnitEvent("UNIT_LEVEL", "player")
-15
View File
@@ -497,19 +497,4 @@ function pfUI.SetupCVars()
UIParentLoadAddOn("Blizzard_CombatText") UIParentLoadAddOn("Blizzard_CombatText")
end end
do -- RunMacroText
local obj = setmetatable({ ["GetText"] = function(self) return self.text end }, {
__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
_G.PLAYER_BUFF_START_ID = -1 _G.PLAYER_BUFF_START_ID = -1
+2 -2
View File
@@ -4,8 +4,8 @@
## Notes: A complete user interface replacement. ## Notes: A complete user interface replacement.
## Notes-ruRU: Полная замена пользовательского интерфейса. ## Notes-ruRU: Полная замена пользовательского интерфейса.
## Version: @project-version@ ## Version: @project-version@
## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle ## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle, pfUI_combatlog
## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB ## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB, pfUI_eqmgr
## X-Website: https://github.com/brues-code/pfUI ## X-Website: https://github.com/brues-code/pfUI
# ClassicAPI-less fallback. ClassicAPI redirects this read to pfUI_Turtle.toc # ClassicAPI-less fallback. ClassicAPI redirects this read to pfUI_Turtle.toc
+2 -2
View File
@@ -4,8 +4,8 @@
## Notes: A complete user interface replacement. ## Notes: A complete user interface replacement.
## Notes-ruRU: Полная замена пользовательского интерфейса. ## Notes-ruRU: Полная замена пользовательского интерфейса.
## Version: @project-version@ ## Version: @project-version@
## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle ## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle, pfUI_combatlog
## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB ## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB, pfUI_eqmgr
## X-Website: https://github.com/brues-code/pfUI ## X-Website: https://github.com/brues-code/pfUI
# Selected by ClassicAPI on every non-Turtle client. Turtle clients get # Selected by ClassicAPI on every non-Turtle client. Turtle clients get
+2 -2
View File
@@ -4,8 +4,8 @@
## Notes: A complete user interface replacement. ## Notes: A complete user interface replacement.
## Notes-ruRU: Полная замена пользовательского интерфейса. ## Notes-ruRU: Полная замена пользовательского интерфейса.
## Version: @project-version@ ## Version: @project-version@
## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle ## SavedVariables: pfUI_profiles, pfUI_addon_profiles, pfUI_cache, pfUI_throttle, pfUI_combatlog
## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB ## SavedVariablesPerCharacter: pfUI_config, pfUI_init, pfUI_playerDB, pfUI_eqmgr
## X-Website: https://github.com/brues-code/pfUI ## X-Website: https://github.com/brues-code/pfUI
# Selected by ClassicAPI on Turtle WoW, where it wins over pfUI_ClassicAPI.toc. # Selected by ClassicAPI on Turtle WoW, where it wins over pfUI_ClassicAPI.toc.
+30
View File
@@ -279,6 +279,36 @@ pfUI:RegisterSkin("Character", function ()
SkinCheckbox(ReputationDetailInactiveCheckBox) SkinCheckbox(ReputationDetailInactiveCheckBox)
SkinCheckbox(ReputationDetailMainScreenCheckBox) SkinCheckbox(ReputationDetailMainScreenCheckBox)
-- Expand or collapse every header at once, as the Skills tab's button
-- does. It shows "+" while any header is collapsed.
local collapseAll = CreateFrame("Button", "pfReputationCollapseAllButton", ReputationFrame, "ReputationHeaderTemplate")
collapseAll:SetText(ALL)
collapseAll:SetWidth(collapseAll:GetTextWidth() + 20)
-- on the "Faction" label's row, in the headers' +/- column
collapseAll:SetPoint("LEFT", ReputationFrameFactionLabel, "LEFT", -43, 0)
collapseAll:SetScript("OnClick", function()
if this.isCollapsed then
ExpandAllFactionHeaders()
else
CollapseAllFactionHeaders()
end
end)
SkinCollapseButton(collapseAll, true)
-- GetFactionInfo, not C_Reputation.GetFactionDataByIndex: the latter
-- returns nil for the Other and Inactive headers.
hooksecurefunc("ReputationFrame_Update", function()
collapseAll.isCollapsed = nil
for i = 1, GetNumFactions() do
local _, _, _, _, _, _, _, _, isHeader, isCollapsed = GetFactionInfo(i)
if isHeader and isCollapsed then
collapseAll.isCollapsed = true
break
end
end
collapseAll:SetNormalTexture(collapseAll.isCollapsed and "Interface\\Buttons\\UI-PlusButton-Up" or "Interface\\Buttons\\UI-MinusButton-Up")
end)
-- Append "(N)" to each standing label where N is rep remaining to the -- Append "(N)" to each standing label where N is rep remaining to the
-- next reaction. Skip exalted (reaction 8) and effectively-capped bars. -- next reaction. Skip exalted (reaction 8) and effectively-capped bars.
-- Each bar's OnLeave handler (Blizzard's ReputationFrame.xml) restores -- Each bar's OnLeave handler (Blizzard's ReputationFrame.xml) restores
+2 -2
View File
@@ -8,8 +8,8 @@ pfUI:RegisterSkin("Friends", function ()
CreateBackdropShadow(FriendsFrame) CreateBackdropShadow(FriendsFrame)
FriendsFrame.backdrop:SetPoint("TOPLEFT", 8, -10) FriendsFrame.backdrop:SetPoint("TOPLEFT", 8, -10)
FriendsFrame.backdrop:SetPoint("BOTTOMRIGHT", -32, 74) FriendsFrame.backdrop:SetPoint("BOTTOMRIGHT", -32, 72)
FriendsFrame:SetHitRectInsets(8,32,10,74) FriendsFrame:SetHitRectInsets(8,32,10,72)
EnableMovable("FriendsFrame") EnableMovable("FriendsFrame")
SkinCloseButton(FriendsFrameCloseButton, FriendsFrame.backdrop, -6, -6) SkinCloseButton(FriendsFrameCloseButton, FriendsFrame.backdrop, -6, -6)
+11 -15
View File
@@ -19,24 +19,20 @@ pfUI:RegisterSkin("Game Menu", function ()
pfUI.gui:Show() pfUI.gui:Show()
HideUIPanel(GameMenuFrame) HideUIPanel(GameMenuFrame)
end) end)
SkinButton(pfUIButton)
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)
local buttons = { -- skin every button on the menu, including ones other addons add later
GameMenuButtonOptions, local function SkinMenuButtons()
GameMenuButtonSoundOptions, for _, child in pairs({GameMenuFrame:GetChildren()}) do
GameMenuButtonUIOptions, if child:GetFrameType() == "Button" and not child._pfMenuSkinned then
GameMenuButtonKeybindings, SkinButton(child)
GameMenuButtonMacros, child._pfMenuSkinned = true
GameMenuButtonRatings, end
GameMenuButtonLogout, end
GameMenuButtonQuit,
GameMenuButtonContinue,
}
for _, button in pairs(buttons) do
if button then SkinButton(button) end
end end
SkinMenuButtons()
GameMenuFrame:HookScript("OnShow", SkinMenuButtons)
end) end)
+49
View File
@@ -0,0 +1,49 @@
pfUI:RegisterSkin("Options - Interface", function ()
local rawborder, border = GetBorderSize()
local bpad = rawborder > 1 and border - GetPerfectPixel() or GetPerfectPixel()
local cr, cg, cb = PFUI_CLASS_COLORS[UnitClassBase("player")]:GetRGB()
StripTextures(InterfaceOptionsFrame)
CreateBackdrop(InterfaceOptionsFrame, nil, nil, .75)
CreateBackdropShadow(InterfaceOptionsFrame)
local title = GetNoNameObject(InterfaceOptionsFrame, "FontString", "ARTWORK", ADDON_OPTIONS)
title:ClearAllPoints()
title:SetPoint("TOP", InterfaceOptionsFrame, "TOP", 0, -10)
CreateBackdrop(InterfaceOptionsFrameAddOns, nil, true, .75)
CreateBackdrop(InterfaceOptionsFramePanelContainer, nil, true, .75)
SkinScrollbar(InterfaceOptionsFrameAddOnsListScrollBar)
for _, button in ipairs(InterfaceOptionsFrameAddOns.buttons) do
button:GetHighlightTexture():SetTexture(cr, cg, cb, .25)
-- the list update swaps plus/minus textures on the toggle by path
local toggle = _G[button:GetName() .. "Toggle"]
SkinCollapseButton(toggle)
toggle:SetPushedTexture("")
toggle:SetHighlightTexture("")
toggle.SetPushedTexture = function() end
end
-- ClassicAPI's own pages (Options\Panel.lua) number their controls
local i = 1
while _G["ClassicAPIOptionsControl" .. i] do
local control = _G["ClassicAPIOptionsControl" .. i]
local ctype = control:GetFrameType()
if ctype == "CheckButton" then
SkinCheckbox(control)
elseif ctype == "Slider" then
SkinSlider(control)
else
SkinDropDown(control, nil, nil, nil, true)
end
i = i + 1
end
SkinButton(InterfaceOptionsFrameDefaults)
SkinButton(InterfaceOptionsFrameCancel)
SkinButton(InterfaceOptionsFrameOkay)
InterfaceOptionsFrameOkay:ClearAllPoints()
InterfaceOptionsFrameOkay:SetPoint("RIGHT", InterfaceOptionsFrameCancel, "LEFT", -2*bpad, 0)
end)
+2 -2
View File
@@ -28,12 +28,12 @@ pfUI:RegisterSkin("Petition", function ()
local texture = "StationeryTest" local texture = "StationeryTest"
if date("%m%d") == "0223" then texture = "Stationery_Val" end if date("%m%d") == "0223" then texture = "Stationery_Val" end
local tex_Left = PetitionFrame:CreateTexture("BACKGROUND") local tex_Left = PetitionFrame:CreateTexture(nil, "BACKGROUND")
tex_Left:SetTexture("Interface\\Stationery\\"..texture.."1") tex_Left:SetTexture("Interface\\Stationery\\"..texture.."1")
tex_Left:SetPoint("TOPLEFT", 23, -81) tex_Left:SetPoint("TOPLEFT", 23, -81)
tex_Left:SetWidth(tex_Left:GetWidth() + 10) tex_Left:SetWidth(tex_Left:GetWidth() + 10)
tex_Left:SetHeight(330) tex_Left:SetHeight(330)
local tex_Right = PetitionFrame:CreateTexture("BACKGROUND") local tex_Right = PetitionFrame:CreateTexture(nil, "BACKGROUND")
tex_Right:SetTexture("Interface\\Stationery\\"..texture.."2") tex_Right:SetTexture("Interface\\Stationery\\"..texture.."2")
tex_Right:SetPoint("LEFT", tex_Left, "RIGHT", 0, 0) tex_Right:SetPoint("LEFT", tex_Left, "RIGHT", 0, 0)
tex_Right:SetWidth(tex_Right:GetWidth() + 10) tex_Right:SetWidth(tex_Right:GetWidth() + 10)
+9 -9
View File
@@ -2,19 +2,19 @@ pfUI:RegisterSkin("Quest Log", function ()
local rawborder, border = GetBorderSize() local rawborder, border = GetBorderSize()
local bpad = rawborder > 1 and border - GetPerfectPixel() or GetPerfectPixel() local bpad = rawborder > 1 and border - GetPerfectPixel() or GetPerfectPixel()
_G.QUESTS_DISPLAYED = 23 _G.QUESTS_DISPLAYED = 22
_G.MAX_WATCHABLE_QUESTS = 20 -- TODO _G.MAX_WATCHABLE_QUESTS = 20 -- TODO
do -- quest log frame do -- quest log frame
QuestLogQuestCount:ClearAllPoints() QuestLogQuestCount:ClearAllPoints()
QuestLogQuestCount:SetPoint("TOPRIGHT", -10, -30) QuestLogQuestCount:SetPoint("TOPRIGHT", -10, -30)
hooksecurefunc("QuestLog_OnShow", function() -- let the panel manager anchor this doublewide panel at 10, -114
QuestLogFrame:ClearAllPoints() UIPanelWindows["QuestLogFrame"].xoffset = 10
QuestLogFrame:SetPoint("TOPLEFT", 10, -104) UIPanelWindows["QuestLogFrame"].yoffset = -10
end)
QuestLogFrame:SetSize(676, 440) -- match the 430px height and top edge of the other skinned panels
QuestLogFrame:SetSize(676, 430)
QuestLogFrame:DisableDrawLayer("BACKGROUND") QuestLogFrame:DisableDrawLayer("BACKGROUND")
StripTextures(QuestLogFrame, true) StripTextures(QuestLogFrame, true)
@@ -144,7 +144,7 @@ pfUI:RegisterSkin("Quest Log", function ()
end end
QuestLogListScrollFrame:SetPoint("TOPLEFT", 10, -54) QuestLogListScrollFrame:SetPoint("TOPLEFT", 10, -54)
QuestLogListScrollFrame:SetHeight(350) QuestLogListScrollFrame:SetHeight(340)
hooksecurefunc("QuestLog_Update", function() hooksecurefunc("QuestLog_Update", function()
local numEntries = GetNumQuestLogEntries() local numEntries = GetNumQuestLogEntries()
@@ -181,8 +181,8 @@ pfUI:RegisterSkin("Quest Log", function ()
QuestLogDetailScrollFrame:ClearAllPoints() QuestLogDetailScrollFrame:ClearAllPoints()
QuestLogDetailScrollFrame:SetPoint("TOPLEFT", QuestLogListScrollFrame, "TOPRIGHT", 35, 0) QuestLogDetailScrollFrame:SetPoint("TOPLEFT", QuestLogListScrollFrame, "TOPRIGHT", 35, 0)
QuestLogDetailScrollFrame:SetHeight(376) QuestLogDetailScrollFrame:SetHeight(366)
QuestLogDetailScrollChildFrame:SetHeight(376) QuestLogDetailScrollChildFrame:SetHeight(366)
local bg = QuestLogDetailScrollFrame:CreateTexture(nil, "BACKGROUND") local bg = QuestLogDetailScrollFrame:CreateTexture(nil, "BACKGROUND")
bg:SetAllPoints() bg:SetAllPoints()
+2 -2
View File
@@ -6,9 +6,9 @@ pfUI:RegisterSkin("Spellbook", function ()
CreateBackdrop(SpellBookFrame, nil, nil, .75) CreateBackdrop(SpellBookFrame, nil, nil, .75)
CreateBackdropShadow(SpellBookFrame) CreateBackdropShadow(SpellBookFrame)
SpellBookFrame.backdrop:SetPoint("TOPLEFT", 12, -12) SpellBookFrame.backdrop:SetPoint("TOPLEFT", 10, -10)
SpellBookFrame.backdrop:SetPoint("BOTTOMRIGHT", -30, 72) SpellBookFrame.backdrop:SetPoint("BOTTOMRIGHT", -30, 72)
SpellBookFrame:SetHitRectInsets(12,30,12,72) SpellBookFrame:SetHitRectInsets(10,30,10,72)
EnableMovable(SpellBookFrame) EnableMovable(SpellBookFrame)
SpellBookTitleText:ClearAllPoints() SpellBookTitleText:ClearAllPoints()
+17 -9
View File
@@ -22,19 +22,27 @@ pfUI:RegisterSkin("Pet Stable Master", function ()
PetStablePetInfo:ClearAllPoints() PetStablePetInfo:ClearAllPoints()
PetStablePetInfo:SetPoint("TOPLEFT", PetStableModel, "TOPLEFT", 10, 0) PetStablePetInfo:SetPoint("TOPLEFT", PetStableModel, "TOPLEFT", 10, 0)
local buttons = {"PetStableCurrentPet", "PetStableStabledPet1", "PetStableStabledPet2"} -- Servers differ in stable size (Turtle WoW has 4 slots), so collect
for _,v in pairs(buttons) do -- every PetStableStabledPetN the client created.
local button = _G[v] local buttons = { PetStableCurrentPet }
local i = 1
while _G["PetStableStabledPet"..i] do
table.insert(buttons, _G["PetStableStabledPet"..i])
i = i + 1
end
for _, button in pairs(buttons) do
StripTextures(button) StripTextures(button)
SkinButton(button, nil, nil, nil, _G[button:GetName().."IconTexture"]) SkinButton(button, nil, nil, nil, _G[button:GetName().."IconTexture"])
button.Enable = function() local b = button
button:SetBackdropColor() b.Enable = function()
button.locked = false b:SetBackdropColor()
b.locked = false
end end
button.Disable = function() b.Disable = function()
button:SetBackdropColor(1, .1, .1, .3) b:SetBackdropColor(1, .1, .1, .3)
button.locked = true b.locked = true
end end
end end