Add files via upload

CHANGELOG.md

@@ -1,5 +1,382 @@
 # Changelog
 
+## 1.4.6 (2026-10-06)
+
+Performance pass over the display loop, with no change in behaviour: only the units that actually changed are redrawn, and two loops that ran empty five times a second now stop early.
+
+### English
+
+**Performance**
+
+- **Only the units that changed are redrawn.** The 0.2 second pass used to set a single dirty flag: if any heal over time ticked anywhere, everything was redrawn, which in a full raid meant forty cells plus ten plates although exactly one unit had changed. The pass now collects the affected unit names in a reused table and hands them to `FBHealBox_RefreshUnitsByName`, and the raid module picks up the same list through the new `RefreshNames` hook. With several HoTs running this turns three to five full sweeps a second into at most one plus a handful of single-unit updates.
+- **A full sweep stays as a safety net.** At most once a second, and only while something is actually changing, the old full refresh still runs, so a name that does not match a plate for any reason can never leave a stale bar behind for longer than that.
+- **Empty leftovers are cleared.** When the last heal over time or the last foreign heal on a unit expires, the now-empty sub-table is removed instead of being left behind. Several places read `FBHoTs[name]` as "is anything running on this unit", and an empty table answered yes.
+- **Raid spell timers skip cells with nothing to show.** The intent to skip was already in the code but the result was thrown away two lines later, so the button loop ran anyway: in a full raid that was 160 do-nothing calls five times a second. The cell is now skipped outright, exactly as the plates already did.
+- **Spell timers get an early out.** When no heal over time and no shield of yours is running anywhere, the plate loop no longer asks every slot for its unit and name five times a second; it only looks where a timer still has to be cleared. Classes without HoTs and the time between fights benefit.
+
+**Checked and left alone**
+
+- The three `OnUpdate` loops do no unnecessary work. The prediction checks three dirty flags and two counters per frame, the mana ticker leaves at its gate (a full mana bar means no pass at all), and the raid ghost ticker is hidden outside test mode. Event handling filters unit events through a lookup table rather than walking every frame.
+- The global cooldown has been drawn as a sweep since 1.4.5.1, which means every visible button gets a fresh sweep after every cast. That is the intended behaviour and the animation runs in the client, not in Lua, so it stays. Should it ever feel heavy in a dense raid, `FBCD_SHOW_MIN` set to 2 limits the sweep to real cooldowns again.
+
+### Deutsch
+
+**Leistung**
+
+- **Nur noch die Einheiten neu zeichnen, bei denen sich etwas geaendert hat.** Der 0,2-Sekunden-Takt setzte bisher ein einziges Dirty-Flag: Lief irgendwo ein HoT-Tick ab, wurde alles neu gezeichnet, im Vierzigerraid also vierzig Zellen und zehn Plaketten, obwohl sich bei genau einer Einheit etwas geaendert hatte. Der Takt sammelt die betroffenen Namen jetzt in einer wiederverwendeten Tabelle und reicht sie an `FBHealBox_RefreshUnitsByName`; das Raidmodul bekommt dieselbe Liste ueber den neuen Hook `RefreshNames`. Mit mehreren laufenden HoTs werden aus drei bis fuenf vollen Durchlaeufen je Sekunde hoechstens einer plus eine Handvoll Einzel-Updates.
+- **Der volle Durchlauf bleibt als Sicherheitsnetz.** Hoechstens einmal je Sekunde, und nur solange sich ueberhaupt etwas aendert, laeuft er weiterhin. Ein Name, der aus irgendeinem Grund zu keiner Plakette passt, kann so nie laenger als eine Sekunde einen alten Balken stehen lassen.
+- **Leere Reste werden weggeraeumt.** Laeuft der letzte HoT oder die letzte fremde Heilung auf einer Einheit ab, verschwindet die nun leere Untertabelle, statt liegen zu bleiben. Mehrere Stellen lesen `FBHoTs[name]` als "laeuft da ueberhaupt etwas", und eine leere Tabelle hat darauf mit ja geantwortet.
+- **Raid-Zaubertimer ueberspringen Zellen ohne Anzeige.** Die Absicht zu ueberspringen stand schon im Code, das Ergebnis wurde aber zwei Zeilen spaeter wieder verworfen, sodass die Buttonschleife trotzdem lief: im Vierzigerraid 160 Leeraufrufe fuenfmal je Sekunde. Die Zelle wird jetzt wirklich uebersprungen, genau wie es die Plaketten laengst machen.
+- **Zaubertimer steigen frueher aus.** Laeuft nirgends ein eigener HoT und kein eigener Schild, fragt die Plakettenschleife nicht mehr fuenfmal je Sekunde jeden Slot nach Einheit und Namen, sondern schaut nur noch dort hinein, wo ein Timer wegzuraeumen ist. Davon profitieren Klassen ohne HoTs und die Zeit zwischen den Kaempfen.
+
+**Geprueft und so gelassen**
+
+- Die drei `OnUpdate`-Schleifen arbeiten nicht unnoetig. Die Vorhersage prueft je Frame drei Dirty-Flags und zwei Zaehler, der Mana-Ticker steigt am Torwaechter aus (voller Manabalken heisst gar kein Durchlauf), und der Geister-Ticker im Raid ist ausserhalb des Testmodus versteckt. Die Ereignisverarbeitung filtert Unit-Events ueber eine Nachschlagetabelle, statt je Frame zu suchen.
+- Der globale Cooldown laeuft seit 1.4.5.1 als Uhr mit, das heisst nach jedem Zauber bekommt jeder sichtbare Button eine neue Uhr gesetzt. Das ist das gewollte Verhalten, und die Animation laeuft im Client, nicht in Lua, deshalb bleibt es so. Sollte es im dichten Raid doch schwer wirken, beschraenkt `FBCD_SHOW_MIN` auf 2 die Uhr wieder auf echte Abklingzeiten.
+
+
+## 1.4.5.3 (2026-10-05)
+
+A readability option suggested by a user: the area behind the bars can be given a solid background, so the game world no longer shows through where health is missing.
+
+### English
+
+**New**
+
+- **Bar background.** New slider *Bar background* on the *General* tab, 0 to 100 per cent in steps of 5. At 0, which is the default, nothing changes: the plate stays see-through and grass, sky or stone show through the empty part of the health bar. Turned up, a quiet dark grey surface sits behind the bars, so the green of the health bar stands on a fixed background. At 100 the plate is opaque. The shade is `FBBAR_BG_COLOR` (0.15 grey) and the setting is kept per character in `HealBox.BarBG`.
+- **Where it sits.** The texture hangs on the lowest of the four stacked bars, the incoming-heal bar, on the `BACKGROUND` layer. That puts it under the prediction, the shield, the health and the mana bar, and it is shown and hidden together with them, so nothing is left behind on a plate that is currently empty or hidden by the attach mode. At 0 per cent no texture is set at all, rather than a fully transparent one.
+- **Raid cells need nothing.** They already have their own backdrop at 80 per cent black, so there is no world shining through there; the slider deliberately only touches the plates.
+
+**Thanks**
+
+- The idea and a working patch came from a user who finds the translucent bar hard to read. The patch used `WHITE8X8` plus `SetVertexColor`; the version shipped here uses `SetTexture(r, g, b, a)`, which creates a solid colour directly in 1.12 and is what the mana strip already does. Same result, no texture file involved.
+
+### Deutsch
+
+**Neu**
+
+- **Balkenhintergrund.** Neuer Regler *Balkenhintergrund* im Reiter *Allgemein*, 0 bis 100 Prozent in Fuenferschritten. Bei 0, dem Standard, aendert sich nichts: Die Plakette bleibt durchscheinend, durch den leeren Teil des Lebensbalkens sieht man Gras, Himmel oder Stein. Hochgedreht liegt eine ruhige dunkelgraue Flaeche hinter den Balken, das Gruen des Lebensbalkens steht dann auf festem Grund. Bei 100 ist die Plakette undurchsichtig. Der Grundton ist `FBBAR_BG_COLOR` (0,15 Grau), die Einstellung bleibt je Charakter in `HealBox.BarBG` gespeichert.
+- **Wo die Flaeche haengt.** Die Textur sitzt auf der untersten der vier gestapelten Balken, der Heilvorhersage, auf der Ebene `BACKGROUND`. Damit liegt sie unter Vorhersage, Schild, Leben und Mana, und sie wird zusammen mit ihnen ein- und ausgeblendet; auf einer leeren oder im Anheftmodus versteckten Plakette bleibt also nichts stehen. Bei 0 Prozent wird gar keine Textur gesetzt statt einer voellig durchsichtigen.
+- **Raidzellen brauchen nichts.** Sie haben bereits ihren eigenen Hintergrund mit 80 Prozent Schwarz, dort scheint keine Welt durch; der Regler fasst bewusst nur die Plaketten an.
+
+**Dank**
+
+- Idee und ein lauffaehiger Patch kamen von einem Nutzer, dem der durchscheinende Balken schlecht lesbar ist. Der Patch benutzte `WHITE8X8` mit `SetVertexColor`; hier ausgeliefert wird `SetTexture(r, g, b, a)`, das in 1.12 direkt eine Vollfarbe erzeugt und genau das ist, was der Manastreifen ohnehin schon macht. Gleiches Ergebnis, ohne Texturdatei.
+
+
+## 1.4.5.2 (2026-09-12)
+
+One fix: a running HoT no longer pulls Smart Healing down a rank.
+
+### English
+
+**Fixed**
+
+- **A HoT on the target no longer talks Smart Healing into a lower rank.** The full healing still owed by a running HoT was subtracted from the deficit as if it had already landed, so a ticking Renew could turn a Heal rank 4 into a Lesser Heal. Only healing that arrives right away is deducted now, meaning direct heals and spells reported over HealComm, roughly one to three seconds out; HoTs stay out of the calculation because they spread their healing over up to fifteen seconds. They are of course still shown on the bar, and the rule that HoTs are never downranked themselves is untouched.
+
+### Deutsch
+
+**Behoben**
+
+- **Ein HoT auf dem Ziel redet Smart Healing keinen kleineren Rang mehr ein.** Die noch offene Heilung eines laufenden HoT wurde vom Fehlbetrag abgezogen, als waere sie schon angekommen; ein tickendes Erneuerung konnte so aus einem Heilen Rang 4 ein Geringes Heilen machen. Abgezogen wird jetzt nur noch Heilung, die gleich ankommt, also Direktheilungen und ueber HealComm gemeldete Zauber, grob ein bis drei Sekunden; HoTs bleiben aus der Rechnung heraus, weil sie ihre Heilung ueber bis zu fuenfzehn Sekunden verteilen. Angezeigt werden sie auf dem Balken selbstverstaendlich weiterhin, und die Regel, dass HoTs selbst nie abgerangt werden, bleibt unberuehrt.
+
+
+## 1.4.5.1 (2026-09-11)
+
+Button and ticker fixes: the mana ticker spark moves smoothly again, and the global cooldown no longer greys out every button but runs as a sweep instead.
+
+### English
+
+**Fixed**
+
+- **The mana ticker spark moves smoothly again.** The spark was only redrawn once it had travelled half a pixel. That sounds frugal, but it crosses the bar in five seconds, roughly 20 pixels per second, so at 60 frames it advanced on every second frame at best and, depending on rounding, sometimes after one frame and sometimes after two. That uneven step was the stutter, and the fixed 0.03 second redraw step introduced in 1.4.5 made it worse. The threshold is now effectively gone (0.05 px) and the spark is drawn every frame again, which doubles its motion from 30 to 60 steps per second with an even gap.
+- **Drawing every frame still costs nothing.** Each spark remembers the width and height of its bar and re-reads them four times a second (`FBTICK_GEOM_STEP`) instead of asking the frame on every pass, and the gate check sits in front of it all: with a full mana bar there is no pass at all.
+- **The global cooldown no longer darkens every button.** After casting anything, the client reports every spell as unusable for the length of the global cooldown. Taken literally, that turned all icons dark grey for a second and a half after every cast, as if nothing were available at all. A running cooldown no longer than the global one (`FBCD_MIN_DURATION`) is no longer treated as a reason to darken a button. Blue for missing mana, red for out of range and grey for a spell that really cannot be cast, for instance in the wrong shapeshift form, all work as before. This affects the plates and the raid cells alike, both go through `FBHealBox_ButtonUsable`.
+- **It runs as a sweep instead.** Not showing it at all was the other half of the inconsistency: an instant like Renew or Abolish Disease left every button untouched, while Power Word: Shield, which has a real cooldown in 1.12, showed one. The sweep is the calm way to show a short wait, so after every cast you watch it run out on all buttons, the way the action bars do it.
+- **Two thresholds instead of one.** The display threshold moved into its own constant `FBCD_SHOW_MIN` (0, show every running cooldown) and is no longer tied to `FBCD_MIN_DURATION` (2), which now only answers whether a cooldown is a reason to darken a button. The two were the same value before, which is why showing the global cooldown and not darkening for it could not be had at the same time. Setting `FBCD_SHOW_MIN` to 2 restores the quiet display. A cooldown is also only shown when one is really running (`cd[1] > 0`), and the sweep starts in the very next frame because the button pass is not throttled.
+
+### Deutsch
+
+**Behoben**
+
+- **Der Funke im Manabalken laeuft wieder rund.** Neu gezeichnet wurde er erst, wenn er einen halben Pixel weitergewandert war. Das klingt sparsam, er braucht fuer den Balken aber fuenf Sekunden, also rund 20 Pixel je Sekunde: Bei 60 Bildern kam er damit bestenfalls in jedem zweiten Frame voran und je nach Rundung mal nach einem, mal nach zwei Frames. Genau dieser ungleiche Schritt war das Ruckeln, und der feste Zeichentakt von 0,03 Sekunden aus 1.4.5 hat es verstaerkt. Die Schwelle ist jetzt praktisch weg (0,05 px) und gezeichnet wird wieder in jedem Frame, das verdoppelt die Bewegung von 30 auf 60 gleichmaessige Schritte je Sekunde.
+- **Das Zeichnen je Frame kostet trotzdem nichts.** Jeder Funke merkt sich Breite und Hoehe seines Balkens und liest sie viermal je Sekunde nach (`FBTICK_GEOM_STEP`), statt sie bei jedem Durchlauf zu erfragen, und der Torwaechter sitzt weiterhin davor: Bei vollem Manabalken laeuft gar kein Durchlauf.
+- **Der globale Cooldown dunkelt nicht mehr alle Buttons ab.** Nach jedem gewirkten Zauber meldet der Client fuer die Dauer des globalen Cooldowns saemtliche Zauber als nicht nutzbar. Woertlich genommen wurden dadurch nach jedem Zauber anderthalb Sekunden lang alle Symbole dunkelgrau, als waere gar nichts mehr verfuegbar. Eine laufende Abklingzeit, die nicht laenger ist als der globale Cooldown (`FBCD_MIN_DURATION`), gilt jetzt nicht mehr als Grund zum Abdunkeln. Blau fuer fehlendes Mana, Rot fuer ausser Reichweite und Grau fuer einen Zauber, der wirklich nicht geht, etwa in der falschen Gestalt, arbeiten unveraendert weiter. Das gilt fuer Plaketten und Raidzellen gleichermassen, beide laufen ueber `FBHealBox_ButtonUsable`.
+- **Stattdessen laeuft er als Uhr mit.** Ihn gar nicht zu zeigen war die andere Haelfte der Ungereimtheit: Ein Instant wie Erneuerung oder Krankheit aufheben liess alle Buttons unberuehrt, waehrend Machtwort: Schild, das in 1.12 eine echte Abklingzeit hat, eine Uhr zeigte. Die Uhr ist die ruhige Art, eine kurze Wartezeit anzuzeigen: Nach jedem Zauber laeuft sie auf allen Buttons ab, so wie es die Aktionsleisten machen.
+- **Zwei Schwellen statt einer.** Die Anzeigeschwelle sitzt jetzt in einer eigenen Konstante `FBCD_SHOW_MIN` (0, also jede laufende Abklingzeit zeigen) und haengt nicht mehr an `FBCD_MIN_DURATION` (2), die nur noch beantwortet, ob eine Abklingzeit ein Grund zum Abdunkeln ist. Vorher war beides derselbe Wert, deshalb liess sich "globalen Cooldown zeigen" und "wegen ihm nicht abdunkeln" nicht gleichzeitig haben. Wer `FBCD_SHOW_MIN` auf 2 setzt, hat die ruhige Anzeige zurueck. Gezeigt wird ausserdem nur, wenn wirklich eine Abklingzeit laeuft (`cd[1] > 0`), und die Uhr startet im naechsten Frame, weil der Button-Durchgang nicht gedrosselt ist.
+
+
+## 1.4.5 (2026-09-08)
+
+Three additions around the frames and the prediction: Blizzard's party frames can go away, the resource bar is no longer reserved for mana, and gear healing is counted where an API can supply it. Plus a performance pass with no change in behaviour.
+
+### English
+
+**New & Changed**
+
+- **Hide Blizzard party frames.** New switch on the *General* tab that hides `PartyMemberFrame1` to `4` while you are grouped, leaving only the Heal Box plates. Off by default. Blizzard shows those frames again on every roster change, so the addon hooks their `OnShow` once instead of hiding them a single time; a frame that reappears is hidden again in the same moment.
+- **Mutually exclusive with the attach mode.** *Default party frames* docks the plates onto exactly those frames, so the two options can never both be on. Whichever one is ticked disables and greys out the other (`FBHealBox_UpdatePartyExclusion`), and `FBHealBox_HideBlizzPartyActive()` re-checks the same rule in code for saved settings that were edited by hand. Switching the option off brings the frames back immediately, and so does the class gate: an addon that stays asleep for warriors, rogues and hunters returns the frames as well.
+- **Rage, energy and focus in the resource bar.** The thin strip under the health bar used to be reserved for mana and stayed empty for everyone else. New switch *Show rage, energy, focus* on the *General* tab gives every unit its own resource in its usual colour, from the new table `FBPOWER_COLORS`: mana blue, rage red, focus orange, energy yellow. `FBUnitMana()` now returns the power type as a fourth value, and both the plates and the raid cells colour their bar from it. Off by default, and it still needs the mana bar to be on.
+- **Equipment healing bonus in the prediction.** Vanilla spell tooltips show the naked base value; the bonus from your gear is missing. Learned values from the combat log carry it automatically, so the gap only affected ranks you had never cast. `FBHealBox_ProbeHealBonus()` now looks for `GetSpellBonusHealing`, `GetSpellBonusHeal` and `GetHealingBonus`, first as globals and then inside a `ClassicAPI` table, and `FBPredict_ExpectedDirect()` adds the share that belongs to the spell.
+- **Weighted the vanilla way.** The bonus counts as cast time divided by 3.5, capped at 3.5 seconds, with instants counting as 1.5 and an unreadable cast time as 2.5. Cast time is read once per spellbook slot from the tooltip (`FBHealBox_SpellCastSeconds`, right-hand side of line 2), so a 3 second Greater Heal takes 600 of a +700 bonus and a 1.5 second Flash Heal takes 300. Without a suitable API the bonus stays 0 and nothing about the old behaviour changes.
+- **New command `/fbp healbonus`.** Turns the equipment bonus off and on, saved per character in `HealBox.HealBonus` (on by default). `/fbp` reports the value found and whether it is being applied; the command says so when no API supplies a bonus at all.
+
+**Performance (no change in behaviour)**
+
+- **Own buff timers read once per frame.** `FBPredict_PlayerBuffTimeLeft` used to walk the whole player buff list once per watched buff, calling `strupper` on every texture along the way: with six watches and thirty buffs that was around 200 API calls and 200 throwaway strings a second. The list is now read once per frame into a texture-to-seconds map (`FBPredict_ScanPlayerBuffTimes`), the way `FBHealBox_UnitBuffs` already worked, and every watch is served from it. Texture paths are upper-cased once and remembered (`FBHealBox_UpperTex`), which also removes the same allocation from the unit buff scan.
+- **Range and line of sight in raid mode are spread over several ticks.** `FBRaid_Tick` used to check up to 40 cells in one frame every half second. It now walks a quarter of the groups per tick at a quarter of the interval (`FBRAID_TICK_SLICES`), so a full sweep still takes the same half second while the peak load per frame drops to a quarter.
+- **`pcall` per sweep instead of per unit.** Range, distance and line of sight went through a protected call for every single unit, up to 160 a second in a full raid. The first successful call now marks the form as safe and the individual calls go straight through, while the sweep as a whole stays protected: one `pcall` per pass in `FBHealBox_CheckRangeAll`, `FBHealBox_CheckLOSAll` and `FBRaid_Tick`. A client that throws on the very first call keeps the old per-call protection and its fallback path.
+- **Self-healing if an API throws late.** Should a sweep throw after the form had already proven itself, `FBHealBox_ApiFailed()` puts all three queries back to the protected single call, where the error is caught and the fallback takes over as before. The frame is never torn open, and at worst one pass is skipped.
+- **Raid health text no longer builds strings it throws away.** The percentage and deficit texts were formatted before the change check, so every `UNIT_HEALTH` in a 40 man raid produced a string that was usually discarded immediately. The cell now compares the number and only formats on a real change, the way the plates always did.
+- **Cheap pre-test before the combat log patterns.** Up to four anchored patterns ran on every message from twenty registered events. A plain substring test now filters first, with the words cut out of the client's own message templates so it works in every language. The tick test deliberately comes from the self template, because "You gain" and "%s gains" differ in the verb but share what follows.
+- **Equipment bonus read once instead of per candidate.** With heal chains a single Smart Healing click asked the API for the bonus up to fifteen times. The value is now remembered and dropped again on `UNIT_INVENTORY_CHANGED` or a spellbook rebuild.
+- **Cast time comes free with the spell scan.** `FBHealBox_SpellCastSeconds` used to build its own tooltip on a cache miss, which could mean a dozen tooltip builds in the middle of combat on the first click. `FBPredict_TooltipText` now picks the cast time off the right-hand side while the tooltip is standing anyway and fills the cache; the standalone scan remains only as a fallback. The cast time is deliberately kept out of the parsed text, because a number like 2.5 would confuse the shield duration and heal amount patterns.
+- **Smaller things.** The range spell of the first assigned button is remembered instead of being searched over ten slots on every range check (invalidated on rebinding and on a spellbook rebuild). The ticker redraws on a fixed 0.03 second step instead of every frame (taken back in 1.4.5.1, it made the spark stutter). Blizzard's party frames are re-evaluated in the same collection point as the name updates instead of on every event of a burst. Two `or {}` fallbacks in loops no longer allocate a throwaway table.
+
+### Deutsch
+
+**Neu & Geaendert**
+
+- **Blizzards Gruppenfenster ausblenden.** Neuer Schalter im Reiter *Allgemein*, der `PartyMemberFrame1` bis `4` versteckt, solange du in einer Gruppe bist, sodass nur die Plaketten der Heal Box uebrig bleiben. Standardmaessig aus. Blizzard zeigt diese Frames bei jeder Gruppenaenderung neu an, deshalb haengt sich das Addon einmalig in deren `OnShow` statt sie nur einmal zu verstecken; ein Frame, der wieder auftaucht, verschwindet im selben Moment erneut.
+- **Schliesst sich mit dem Anheftmodus aus.** *Standard-Gruppenfenster* haengt die Plaketten genau an diese Frames, beide Optionen koennen also nie zusammen an sein. Was angehakt ist, sperrt und graut das andere aus (`FBHealBox_UpdatePartyExclusion`), und `FBHealBox_HideBlizzPartyActive()` prueft dieselbe Regel im Code noch einmal nach, fuer von Hand bearbeitete gespeicherte Werte. Ausschalten holt die Frames sofort zurueck, ebenso die Klassensperre: Ein Addon, das fuer Krieger, Schurken und Jaeger schlaeft, gibt die Frames mit zurueck.
+- **Wut, Energie und Fokus im Ressourcenbalken.** Der schmale Streifen unter dem Lebensbalken war dem Mana vorbehalten und blieb bei allen anderen leer. Der neue Schalter *Wut, Energie, Fokus zeigen* im Reiter *Allgemein* gibt jeder Einheit ihre eigene Ressource in der gewohnten Farbe, aus der neuen Tabelle `FBPOWER_COLORS`: Mana blau, Wut rot, Fokus orange, Energie gelb. `FBUnitMana()` liefert die Energieart jetzt als vierten Rueckgabewert, Plaketten und Raidzellen faerben ihren Balken danach. Standardmaessig aus, und der Manabalken muss weiterhin an sein.
+- **Heilbonus der Ausruestung in der Vorhersage.** Vanilla-Tooltips zeigen den nackten Grundwert, der Bonus der Ausruestung fehlt darin. Gelernte Werte aus dem Combatlog tragen ihn von selbst, die Luecke betraf also nur Raenge, die nie gewirkt wurden. `FBHealBox_ProbeHealBonus()` sucht jetzt nach `GetSpellBonusHealing`, `GetSpellBonusHeal` und `GetHealingBonus`, erst als globale Funktion, dann in einer `ClassicAPI`-Tabelle, und `FBPredict_ExpectedDirect()` schlaegt den Anteil auf, der auf den Zauber entfaellt.
+- **Gewichtet wie in Vanilla ueblich.** Der Bonus zaehlt mit Zauberzeit geteilt durch 3,5, gedeckelt bei 3,5 Sekunden, Instants rechnen mit 1,5 und eine unlesbare Zauberzeit mit 2,5. Die Zauberzeit wird einmal je Zauberbuchplatz aus dem Tooltip gelesen (`FBHealBox_SpellCastSeconds`, rechte Seite der zweiten Zeile). Eine Grosse Heilung mit 3 Sekunden nimmt von +700 Heilung also 600 mit, eine Blitzheilung mit 1,5 Sekunden 300. Ohne passende API bleibt der Bonus 0 und am bisherigen Verhalten aendert sich nichts.
+- **Neuer Befehl `/fbp healbonus`.** Schaltet den Ausruestungsbonus aus und wieder ein, gespeichert je Charakter in `HealBox.HealBonus` (Standard an). `/fbp` nennt den gefundenen Wert und ob er angewandt wird; der Befehl sagt es, wenn ueberhaupt keine API einen Bonus liefert.
+
+**Leistung (ohne Funktionsaenderung)**
+
+- **Eigene Bufflaufzeiten einmal je Frame.** `FBPredict_PlayerBuffTimeLeft` lief bisher je ueberwachtem Buff einmal durch die gesamte Buffliste und rief dabei fuer jede Textur `strupper` auf: bei sechs Wachen und dreissig Buffs rund 200 API-Aufrufe und 200 Wegwerf-Strings je Sekunde. Die Liste wird jetzt einmal je Frame in eine Tabelle Textur nach Sekunden gelesen (`FBPredict_ScanPlayerBuffTimes`), genau wie es `FBHealBox_UnitBuffs` schon vormacht, und alle Wachen bedienen sich daraus. Texturpfade werden einmal gross geschrieben und gemerkt (`FBHealBox_UpperTex`), was dieselbe Zuteilung auch aus dem Buffscan der Einheiten nimmt.
+- **Reichweite und Sichtlinie im Raid auf mehrere Ticks verteilt.** `FBRaid_Tick` pruefte alle halbe Sekunde bis zu 40 Zellen in einem einzigen Frame. Jetzt kommt je Tick ein Viertel der Gruppen dran, dafuer viermal so oft (`FBRAID_TICK_SLICES`): Der volle Durchlauf dauert weiterhin eine halbe Sekunde, die Spitzenlast je Frame sinkt auf ein Viertel.
+- **`pcall` je Durchlauf statt je Einheit.** Reichweite, Abstand und Sichtlinie liefen fuer jede einzelne Einheit durch einen geschuetzten Aufruf, im Vierzigerraid bis zu 160 je Sekunde. Der erste erfolgreiche Aufruf erklaert die Form jetzt fuer sicher und die Einzelaufrufe gehen direkt hinein, der Durchlauf als Ganzes bleibt aber geschuetzt: ein `pcall` je Durchgang in `FBHealBox_CheckRangeAll`, `FBHealBox_CheckLOSAll` und `FBRaid_Tick`. Ein Client, der schon beim ersten Aufruf wirft, behaelt den geschuetzten Einzelaufruf samt Rueckfallweg.
+- **Selbstheilung, wenn eine API doch spaet wirft.** Wirft ein Durchlauf, obwohl die Form sich vorher bewaehrt hatte, stellt `FBHealBox_ApiFailed()` alle drei Abfragen auf den geschuetzten Einzelaufruf zurueck, wo der Fehler abgefangen wird und der Rueckfall wie frueher greift. Der Frame wird nie aufgerissen, schlimmstenfalls faellt ein Durchgang aus.
+- **Kein HP-Text im Raid, der gleich wieder weggeworfen wird.** Prozent- und Deficit-Text wurden vor dem Vergleich gebaut, jedes `UNIT_HEALTH` im Vierzigerraid erzeugte also einen String, der meist sofort verfiel. Die Zelle vergleicht jetzt die Zahl und formatiert nur bei echter Aenderung, so wie es die Plaketten immer schon tun.
+- **Billiger Vortest vor den Combatlog-Mustern.** Bei jeder Meldung aus zwanzig registrierten Ereignissen liefen bis zu vier verankerte Muster. Ein einfacher Textvergleich filtert jetzt vorweg, mit Wortstuecken, die aus den Meldungsvorlagen des Clients geschnitten werden und damit in jeder Sprache passen. Der Tick-Vortest kommt bewusst aus der Selbst-Vorlage, weil sich "You gain" und "%s gains" im Verb unterscheiden, im Rest aber gleich sind.
+- **Ausruestungsbonus einmal statt je Kandidat.** Mit Heilketten fragte ein einziger Smart-Healing-Klick die API bis zu fuenfzehnmal nach dem Bonus. Der Wert wird jetzt gemerkt und bei `UNIT_INVENTORY_CHANGED` oder einem Neuaufbau des Zauberbuchs wieder verworfen.
+- **Zauberzeit faellt beim Auslesen der Zauber mit ab.** `FBHealBox_SpellCastSeconds` baute bei einem Fehlgriff einen eigenen Tooltip, was beim ersten Klick mitten im Kampf ein Dutzend Tooltip-Aufbauten bedeuten konnte. `FBPredict_TooltipText` liest die Zauberzeit jetzt nebenbei von der rechten Seite ab, solange der Tooltip ohnehin steht, und fuellt den Zwischenspeicher; der eigene Scan bleibt nur als Rueckfall. Der Wert kommt bewusst nicht in den ausgewerteten Text, weil eine Zahl wie 2.5 die Muster fuer Schilddauer und Heilbetrag durcheinanderbraechte.
+- **Kleinigkeiten.** Der Reichweiten-Zauber des ersten belegten Buttons wird gemerkt, statt bei jeder Pruefung ueber zehn Plaetze zu suchen (verworfen beim Umbelegen und beim Neuaufbau des Zauberbuchs). Der Ticker zeichnet in einem festen Takt von 0,03 Sekunden statt in jedem Frame (in 1.4.5.1 zurueckgenommen, der Funke ruckelte dadurch). Blizzards Gruppenfenster werden im selben Sammelpunkt wie die Namen neu bewertet statt bei jedem Ereignis einer Salve. Zwei `or {}`-Rueckfaelle in Schleifen legen keine Wegwerf-Tabelle mehr an.
+
+
+## 1.4.4.3 (2026-09-08)
+
+Class gate, heal chains and a Smart Healing fix. The addon no longer loads its display for warriors, rogues and hunters, Smart Healing keeps its hands off heal over time spells, and downranking may now switch spell inside a heal chain.
+
+### English
+
+**New & Changed**
+
+- **Smartcross option in UI.** Added a *Smartcross* checkbox under Smart Healing in the *Buttons* tab. It is automatically enabled/disabled and grayed out based on the Smart Healing master switch (also toggleable via `/fbp smartcross`).
+- **Streamlined Smart Healing tooltip.** Overhauled the options tooltip for Smart Healing across all languages. Replaced the screen-filling block of text with a compact, readable bullet-point summary of key rules.
+- **Priest heal chain cleaned.** Completely removed *Flash Heal* from the Priest heal chain (`Lesser Heal · Heal · Greater Heal`). Flash Heal is preserved as a dedicated fast emergency heal and is never swapped into from Greater Heal or Heal.
+- **Downranking across spells.** Until now Smart Healing only ever lowered the rank of the spell on the button, so Greater Heal (rank 4) could become Greater Heal (rank 1) but never Lesser Heal (rank 3), even though that would have covered the deficit for a fraction of the mana. Every single-target direct heal of a class now forms a *heal chain*, and the whole chain is searched: Priest `Lesser Heal · Heal · Greater Heal`, Paladin `Flash of Light · Holy Light`, Shaman `Lesser Healing Wave · Healing Wave`, Druid `Healing Touch`. The candidate with the smallest expected heal that still covers the need wins.
+- **The button never gets stronger.** Nothing that heals more than the rank you assigned is ever chosen, and a tie keeps the assigned spell. Note that the cast time can change: for a small deficit a Greater Heal click may come out as Lesser Heal, and Holy Light as Flash of Light.
+- **What stays out of the chains.** Group heals (Prayer of Healing, Chain Heal), fast emergency heals (Flash Heal), HoTs (Renew, Rejuvenation, Regrowth), shields and cooldown spells (Holy Shock, Lay on Hands) are never swapped. The chains sit in `FBHealChains` and can be edited freely; German spell names are included, with special characters stored as byte sequences for both Latin-1 and UTF-8 clients.
+- **New command `/fbp smartcross`.** Turns chain switching off and on, saved per character in `HealBox.SmartCross` (on by default). With it off, Smart Healing stays on the assigned spell and only lowers its rank. `/fbp` shows the state next to the Smart Healing line, and the command says so when Smart Healing itself is still off.
+- **Class gate for warriors, rogues and hunters.** The addon is built for healing and buffing, and those three classes get nothing out of it: no heals, no heal prediction, and a mana ticker with either no mana to watch (rage, energy) or nobody to heal (hunter). Logging in on one of them now leaves the whole display switched off: no plates, no raid grid, no minimap button, no options window. All event handlers and `OnUpdate` loops of the core and of the raid, ticker and Smart Damage modules return immediately (`FBAddonSuppressed`), so the addon costs nothing while it sleeps. Two lines in the chat explain what happened and how to change it.
+- **New command `/fbp forceload`.** Shows the addon on a blocked class anyway. It starts immediately, without `/reload`, and the setting is kept per character in `HealBox.ForceLoad`. The same command switches it back off. On every other class the command reports that it is not needed. While the addon sleeps, every other `/fbp` command answers with the same hint instead of reporting on a display that was never built.
+- **Class detection.** Uses the client's English class token (`WARRIOR`, `ROGUE`, `HUNTER`) with a fallback to the displayed class name in five languages, plus a last resort over the power type (rage and energy are never mana classes).
+- **New hook `Suppress`.** Modules hide their own frames when the core goes to sleep; the raid module hides the grid, the ticker hides its sparks.
+- **Startup message moved.** The greeting and the modules' `Loaded` hooks now run on `ADDON_LOADED` / `VARIABLES_LOADED` instead of `FBHealBox_OnLoad`, so the saved language is applied and nothing is announced for a class that stays asleep.
+- **Rank rules generalised.** The upper limit is no longer "never above the assigned rank" but "never more expected healing than the assigned rank", which is the same thing inside one spell and the right rule across spells. A rank whose tooltip cannot be read is now skipped instead of ending the search.
+
+**Fixed**
+
+- **Smart Healing no longer downranks heal over time spells.** Renew, Rejuvenation, Regrowth, Tranquility, Lifebloom, Wild Growth, Riptide and Earth Shield now always go out at the assigned rank, for every class. A HoT spreads its healing over many seconds, so the health missing at the moment of the click says nothing about which rank fits, and a downranked HoT keeps ticking too weakly for its whole duration. Mixed spells such as Regrowth count as HoTs as well.
+- **HoT detection** The new `FBHealBox_IsHoT()` checks the name list `FBHoTSpells` (English and German names, umlauts stored as byte sequences for both Latin-1 and UTF-8 clients), the tooltip evaluation (`info.hot`), the spell watch (`hasHoT`) and the HoTs currently running from the combat log. The exception therefore also applies to spells that are not in the list, for instance on custom servers. In addition the per-rank check now rejects any rank with a HoT portion.
+
+---
+
+### Deutsch
+
+**Neu & Geaendert**
+
+- **Smartcross im Optionsfenster.** Checkbox unter Smart Healing im Reiter *Buttons* hinzugefügt. Sie steuert das zauberübergreifende Abrangen in Heilketten und wird dynamisch gesperrt und ausgegraut, wenn Smart Healing deaktiviert ist (weiterhin auch per `/fbp smartcross` schaltbar).
+- **Gestraffter Smart-Healing-Tooltip.** Der bisherige riesige Fließtextblock im Optionsfenster wurde in allen Sprachen durch eine übersichtliche, stichpunktartige Zusammenfassung der Kernregeln ersetzt. Der Tooltip sprengt damit nicht mehr den Bildschirm.
+- **Priester-Heilkette bereinigt.** *Blitzheilung* (*Flash Heal*) vollständig aus der Priesterkette entfernt (`Geringes Heilen · Heilen · Große Heilung`). Blitzheilung bleibt ein reiner schneller Notfallzauber und wird von Großer Heilung / Heilen nie ungewollt ausgewählt.
+- **Abrangen ueber Zaubergrenzen.** Bisher senkte Smart Healing nur den Rang des Zaubers auf dem Button: Aus Große Heilung (Rang 4) konnte Große Heilung (Rang 1) werden, nie aber Geringes Heilen (Rang 3), obwohl das den Fehlbetrag für einen Bruchteil des Manas gedeckt hätte. Alle Einzelziel-Direktheilungen einer Klasse bilden nun eine *Heilkette*, und die ganze Kette wird durchsucht: Priester `Geringes Heilen · Heilen · Große Heilung`, Paladin `Blitz des Lichts · Heiliges Licht`, Schamane `Geringe Welle der Heilung · Welle der Heilung`, Druide `Heilende Berührung`. Gewonnen hat der Kandidat mit der kleinsten erwarteten Heilung, die den Bedarf noch deckt.
+- **Der Button wird nie staerker.** Nie gewählt wird etwas, das mehr heilt als der belegte Rang; bei Gleichstand bleibt es beim belegten Zauber. Die Zauberzeit kann sich dabei ändern: Bei kleinem Fehlbetrag wird aus einem Klick auf Große Heilung ein Geringes Heilen, aus Heiligem Licht ein Blitz des Lichts.
+- **Was draussen bleibt.** Gruppenheilungen (Gebet der Heilung, Kettenheilung), schnelle Notfallzauber (Blitzheilung), HoTs (Erneuerung, Verjüngung, Nachwachsen), Schilde und Zauber mit Abklingzeit (Heiliger Schock, Handauflegung) werden nie getauscht. Die Ketten stehen in `FBHealChains` und lassen sich frei bearbeiten; die deutschen Zaubernamen sind enthalten, Sonderzeichen als Bytefolge für Latin-1- und UTF-8-Clients.
+- **Neuer Befehl `/fbp smartcross`.** Schaltet den Kettenwechsel aus und wieder ein, gespeichert je Charakter in `HealBox.SmartCross` (Standard an). Aus bleibt Smart Healing beim belegten Zauber und senkt nur dessen Rang. `/fbp` zeigt den Zustand neben der Smart-Healing-Zeile, und der Befehl weist darauf hin, wenn Smart Healing selbst noch aus ist.
+- **Klassensperre fuer Krieger, Schurke und Jaeger.** Das Addon ist fürs Heilen und Buffen gebaut, diese drei Klassen haben nichts davon: keine Heilzauber, keine Heilvorhersage, und ein Mana-Ticker, der entweder kein Mana zu beobachten hat (Wut, Energie) oder niemanden zu heilen (Jäger). Wer sich damit einloggt, bekommt die Anzeige nun gar nicht mehr zu sehen: keine Plaketten, kein Raid-Raster, kein Minimap-Button, kein Optionsfenster. Sämtliche Event-Handler und `OnUpdate`-Schleifen des Kerns und der Module Raid, Ticker und Smart Damage steigen sofort aus (`FBAddonSuppressed`), das Addon kostet im Ruhezustand also nichts. Zwei Zeilen im Chat erklären, was passiert ist und wie man es ändert.
+- **Neuer Befehl `/fbp forceload`.** Zeigt das Addon bei einer gesperrten Klasse trotzdem an. Es startet sofort, ohne `/reload`, und die Einstellung bleibt je Charakter in `HealBox.ForceLoad` gespeichert. Derselbe Befehl schaltet wieder aus. Bei jeder anderen Klasse meldet der Befehl, dass er nicht nötig ist. Solange das Addon ruht, antworten alle übrigen `/fbp`-Befehle mit demselben Hinweis, statt über eine Anzeige zu berichten, die nie aufgebaut wurde.
+- **Klassenerkennung.** Über das englische Klassen-Token des Clients (`WARRIOR`, `ROGUE`, `HUNTER`), mit Rückfall auf den angezeigten Klassennamen in fünf Sprachen und als letzter Notnagel über den Energietyp (Wut und Energie sind nie Manaklassen).
+- **Neuer Hook `Suppress`.** Module blenden ihre eigenen Rahmen aus, wenn der Kern schlafen geht: Das Raidmodul versteckt das Raster, der Ticker seine Funken.
+- **Startmeldung verschoben.** Begrüßung und die `Loaded`-Hooks der Module laufen jetzt bei `ADDON_LOADED` / `VARIABLES_LOADED` statt in `FBHealBox_OnLoad`. So gilt die gespeicherte Sprache, und bei einer schlafenden Klasse meldet sich niemand.
+- **Rangregel verallgemeinert.** Die Obergrenze heißt nicht mehr "nie über dem belegten Rang", sondern "nie mehr erwartete Heilung als der belegte Rang". Innerhalb eines Zaubers ist das dasselbe, über Zaubergrenzen hinweg ist es die richtige Regel. Ein Rang, dessen Tooltip sich nicht lesen lässt, wird jetzt übersprungen, statt die Suche zu beenden.
+
+**Behoben**
+
+- **Smart Healing rangt keine HoTs mehr ab.** Erneuerung, Verjüngung, Nachwachsen, Gelassenheit, Lebensblüte, Wildwuchs, Springflut und Erdschild gehen nun immer im belegten Rang raus, bei jeder Klasse. Ein HoT verteilt seine Heilung über viele Sekunden, das im Moment des Klicks fehlende Leben sagt also nichts darüber aus, welcher Rang passt, und ein abgerangter HoT tickt die volle Laufzeit zu schwach. Gemischte Zauber wie Nachwachsen zählen ebenfalls als HoT.
+- **HoT Erkennung** Die neue Funktion `FBHealBox_IsHoT()` prüft die Namensliste `FBHoTSpells` (englische und deutsche Namen, Umlaute als Bytefolge für Latin-1- und UTF-8-Clients), die Tooltip-Auswertung (`info.hot`), die Zauberwache (`hasHoT`) und die gerade aus dem Combatlog laufenden HoTs. Die Ausnahme greift damit auch bei Zaubern, die nicht in der Liste stehen, etwa auf abweichenden Servern. Zusätzlich weist die Rangprüfung jeden Rang mit HoT-Anteil ab.
+
+## 1.4.4.2 (2026-09-07)
+
+Buff duration display update & bugfix. Replaces the 4-quadrant clock division for buff icons with a 32-step vertical duration wipe, offering much finer timer resolution, and fixes an <eof> syntax error when loading.
+
+### English
+
+**New & Changed**
+
+- **32-step buff icon duration display.** The buff icons left of the health bar previously divided the remaining duration into 4 coarse quadrants (quarters). They now transition in 32 fine vertical steps (`FBBUFFICON_STEPS = 32`) from top to bottom. As a buff expires, the top portion is progressively desaturated and darkened in 32 increments. For a 30-minute buff like *Power Word: Fortitude* or *Divine Spirit*, the visual display now updates approximately every 56 seconds rather than once every 7.5 minutes.
+- **Optimised texture usage.** Replaced the 4 quadrant textures and 4 wash textures per buff icon with a single dynamically cropped desaturated overlay (`ic.qTex`) and dark wash (`ic.wTex`), reducing texture objects by 75 % per buff icon while increasing visual granularity eightfold.
+- **Shortened addon notes.** Better display in WoW-Launcher addon managers.
+
+
+### Deutsch
+
+**Neu & Geaendert**
+
+- **32-Stufen-Ablaufanzeige fuer Buff-Icons.** Die Buff-Symbole links neben dem Lebensbalken teilten die Restlaufzeit bisher in 4 grobe Bloecke (Quadranten) auf. Dies wurde auf 32 feine Ablaufstufen (`FBBUFFICON_STEPS = 32`) von oben nach unten umgestellt. Bei ablaufender Restzeit wird das Icon in 32 Teilschritten von oben nach unten schrittweise entsaettigt (schwarz-weiss) und abgedunkelt. Bei einem 30-Minuten-Buff (z. B. *Machtwort: Seelenstaerke*) aktualisiert sich die visuelle Anzeige nun ca. alle 56 Sekunden statt nur alle 7,5 Minuten.
+- **Ressourcenschonende Textur-Struktur.** Statt 4 separaten Quadranten-Texturen und 4 Abdunklungs-Overlays nutzt jedes Icon nun nur noch je eine dynamisch skalierte und beschnittene Overlay-Textur (`ic.qTex` und `ic.wTex`). Das spart 75 % der Texturobjekte pro Icon ein und erhoeht gleichzeitig die Anzeigegenauigkeit um das Achtfache.
+- **Addon Beschreibung eingekuerzt** Fuer bessere Übersicht in WoW-Launchern.
+
+
+## 1.4.4.1 (2026-09-06)
+
+Buff tracking & class spells update. Fixes buff clock icons (Divine Spirit, etc.) not appearing next to the health bar, adds group buff alternate matching, and completes the spell selection lists across all healer classes with buffs, utility and rez spells.
+
+### English
+
+**Fixed**
+
+- **Buff tracking & Tooltip scanning.** In Vanilla 1.12.1, `ClearLines()` on the hidden scan tooltip (`FBHealBoxScanTip`) does not clear hidden text lines. Because `FBPredict_TooltipText` did not check `fs:IsShown()`, leftover lines from previously scanned heal spells (e.g. "Heals a friendly target...") lingered and were read when inspecting buff tooltips like *Divine Spirit*. This erroneously flagged `info.isHeal = true`, skipping buff duration detection (`info.buff`) and causing *Divine Spirit* not to display its clock icon and timer in the plate UI.
+- **Group buff alternate detection.** `FBPredict_BuildWatch` and `FBPredict_ScanUnit` now track group buff variants (`altTex`). When a group buff is applied or present (*Prayer of Fortitude*, *Prayer of Spirit*, *Gift of the Wild*, *Greater Blessings*), the addon correctly recognises the aura, confirms pending casts, and displays the buff clock icon.
+- **Buff watch textures.** `FBLoadSpellData` now flags all spells in `FBBuffWatchSpells` as addon spells (`isHealBoxSpell = true`), ensuring their textures and ranks are gathered and monitored even if they are not yet assigned to a heal button.
+- **Drag & drop instant sync.** Dropping a spell onto a button now immediately calls `FBPredict_BuildWatch()`, updating tracked buffs and predictions without requiring a `/reload`.
+
+**New & Changed**
+
+- **Expanded class spell lists.** Greatly expanded `Spell.Name` for all classes so that all relevant buffs, utility spells, dispels, and resurrections appear in the cascading spell menus:
+  - **Priest:** Added *Power Word: Fortitude*, *Prayer of Fortitude*, *Divine Spirit*, *Prayer of Spirit*, *Shadow Protection*, *Prayer of Shadow Protection*, *Fear Ward*, *Power Infusion*, *Resurrection*.
+  - **Druid:** Added *Mark of the Wild*, *Gift of the Wild*, *Thorns*, *Tranquility*, *Innervate*, *Rebirth*, *Cure Poison*.
+  - **Paladin:** Added all normal and Greater Blessings (*Wisdom, Might, Kings, Salvation, Light, Sanctuary*), *Blessing of Freedom*, *Blessing of Sacrifice*, *Redemption*, *Divine Intervention*.
+  - **Shaman:** Added *Ancestral Spirit*, *Purge*, *Water Walking*, *Water Breathing*, *Water Shield*.
+  - Added optional support for **Mage** (*Remove Lesser Curse*, *Arcane Intellect*, *Arcane Brilliance*, *Dampen Magic*, *Amplify Magic*) and **Warlock** (*Unending Breath*, *Detect Invisibility*).
+- **Fear Ward in Buff Watch.** Added *Fear Ward* to `FBBuffWatchSpells` for Priests.
+
+### Deutsch
+
+**Behoben**
+
+- **Buff-Erkennung & Tooltip-Scan.** Im 1.12.1-Client leert `ClearLines()` auf dem versteckten Scan-Tooltip (`FBHealBoxScanTip`) ausgeblendete Textzeilen nicht. Da `FBPredict_TooltipText` nicht pruefte, ob eine Zeile sichtbar ist (`fs:IsShown()`), wurden Textzeilen zuvor gescannter Heilzauber (z. B. „Heals a friendly target...") faelschlicherweise auch bei Buff-Tooltips wie *Goettlicher Willen* (*Divine Spirit*) mitgelesen. Dadurch wurde fehlerhaft `isHeal = true` gesetzt, was die Erkennung der Buff-Laufzeit (`info.buff`) verhinderte und dazu fuehrte, dass das Buff-Icon links am Lebensbalken nicht erschien.
+- **Erkennung von Gruppen-Buffs.** `FBPredict_BuildWatch` und `FBPredict_ScanUnit` unterstuetzen nun Gruppenversionen (`altTex`). Gruppen-Buffs (*Gebet der Seelenstaerke*, *Gebet der Willenskraft*, *Gabe der Wildnis*, *Grosse Segen*) werden nun zuverlaessig bestaetigt und mit Laufzeit/Icon dargestellt.
+- **Buff-Wache Texturen.** `FBLoadSpellData` markiert nun alle Zauber aus `FBBuffWatchSpells` automatisch als Addon-Zauber (`isHealBoxSpell = true`), sodass ihre Texturen und Daten auch dann geladen und getrackt werden, wenn sie noch auf keinem Button liegen.
+- **Drag & Drop Sofort-Synchronisation.** Das Ablegen eines Zaubers auf einen Button ruft nun direkt `FBPredict_BuildWatch()` auf, sodass neue Buffs und Vorhersagen ohne `/reload` sofort aktiv sind.
+
+**Neu & Geaendert**
+
+- **Vollstaendige Klassen-Zauberlisten.** `Spell.Name` fuer alle Heilerklassen stark erweitert, sodass saemtliche Heiler-Buffs, Gruppen-Buffs, Hilfszauber und Wiederbelebungen in den Auswahlmenues verfuegbar sind:
+  - **Priester:** *Machtwort: Seelenstaerke*, *Gebet der Seelenstaerke*, *Goettlicher Willen*, *Gebet der Willenskraft*, *Schattenschutz*, *Gebet des Schattenschutzes*, *Furchtzauberschutz*, *Seele der Macht*, *Auferstehung* hinzugefuegt.
+  - **Druide:** *Mal der Wildnis*, *Gabe der Wildnis*, *Dornen*, *Gelassenheit*, *Anregen*, *Wiedergeburt*, *Vergiftung heilen* hinzugefuegt.
+  - **Paladin:** Alle normalen und Grossen Segen (*Weisheit, Macht, Koenige, Rettung, Licht, Schutz*), *Segen der Freiheit*, *Segen der Opferung*, *Erloesung*, *Goettliches Eingreifen* hinzugefuegt.
+  - **Schamane:** *Geist der Ahnen*, *Reinigen*, *Wasserwandeln*, *Wasseratmung*, *Wasserschild* hinzugefuegt.
+  - Zusaetzliche Unterstuetzung fuer **Magier** (*Geringen Fluch aufheben*, *Arkane Intelligenz*, *Arkane Brillanz*, *Magie daempfen*, *Magie verstaerken*) und **Hexenmeister** (*Unendlicher Atem*, *Unsichtbarkeit entdecken*) ergaenzt.
+- **Furchtzauberschutz in Buff-Wache.** *Fear Ward* fuer Priester in `FBBuffWatchSpells` aufgenommen.
+
+
+## 1.4.4 (2026-09-06)
+
+Performance pass. No feature was added or changed; every visible behaviour is meant to be identical. A simulated five-second raid fight (40 players, aura and health events, mana changes, combat log, 60 frames per second) went from about 63,900 API and widget calls to about 14,450, a reduction of 77 %.
+
+### English
+
+**Changed (internals)**
+
+- **Button states centralised.** The up to 260 heal buttons (10 plates x 10, 40 raid cells x 4) no longer carry their own `SPELL_UPDATE_USABLE` / `SPELL_UPDATE_COOLDOWN` handlers. One pass over the *visible* buttons queries usability and cooldown once per spell id and range once per button, and sets colours and cooldown sweeps only when the state changes. Several such events within one frame are merged into one pass.
+- **Display caches.** Health text, bar maxima, bar values, bar colour and mana strip visibility are only written when they change. Dispellable debuffs are searched on `UNIT_AURA` only; `UNIT_HEALTH` and the prediction tick reuse the last result.
+- **Aura scans shared.** A unit's buff textures are read once per frame and shared between the heal prediction and the buff watch. Buff names resolved through tooltip scans are remembered per texture, so a unit missing the watched buff no longer costs up to 32 tooltip scans per aura event. Raid units are only scanned when something depends on them (own cast pending, tracked HoT or shield, or a visible cell).
+- **Cheaper ticks.** Spell timers use precomputed base spell names instead of string parsing per button per tick and skip units without tracked HoTs or shields. Buff icons reuse their work tables, iterate a presorted list instead of sorting per tick, and update on change or once a second instead of five times a second. The attacked-member check skips entirely while there is no hostile target and nothing is marked, and compares names before calling `UnitIsUnit`.
+- **Event bursts coalesced.** `PARTY_MEMBERS_CHANGED`, `UNIT_PET` and `RAID_ROSTER_UPDATE` set a flag that is processed once in the next frame instead of rebuilding plates and grid for every event of a burst.
+- **Mana ticker.** Enabled/mana/full checks moved from every frame to mana events and option changes; the spark is re-anchored only when it has moved at least half a pixel; sizes and visibility are cached.
+- **Combat log.** Heal patterns run only for buff events, the absorb pattern only for hit events that contain the word absorbed. Smart Damage parses damage lines only while enabled and while there is a target being measured or an own cast waiting; its live target line is refreshed only while the options window is open.
+- Raid test ghost animation frame is hidden outside the raid test instead of running an empty update every frame.
+- **Client API compatibility.** `IsSpellInRange` and `IsUsableSpell` do not exist in the 1.12 client (they came with 2.0). All range and usability checks now go through wrappers that use them when a client offers them and otherwise fall back to 1.12 means: spell range from the tooltip against `UnitXP("distanceBetween")` where available, else `CheckInteractDistance` (28 m, beyond that undecided rather than red); mana cost from the tooltip against your current mana. Because clients differ (2.0 style `(id, "spell", unit)` versus the Turtle client's `(name, unit)`), the addon probes both signatures once at login with `pcall` and uses the one the client understands; a function that keeps throwing is switched off in favour of the fallback. `/fbp` reports the detected form. Without this the new central button pass crashed at login.
+
+**Fixed**
+
+- The old per-button event handler declared `this`, `event` and `arg1` as parameters, which shadowed the 1.12 globals; range colouring and cooldown sweeps on the buttons never worked in the game. They do now.
+
+### Deutsch
+
+**Geaendert (intern)**
+
+- **Button-Zustaende zentral.** Die bis zu 260 Heil-Buttons (10 Plaketten x 10, 40 Raid-Zellen x 4) tragen keine eigenen `SPELL_UPDATE_USABLE`/`SPELL_UPDATE_COOLDOWN`-Handler mehr. Ein Durchgang ueber die *sichtbaren* Buttons fragt Nutzbarkeit und Cooldown je Zauber-ID einmal und die Reichweite je Button ab und setzt Farben und Cooldown-Uhren nur bei Zustandswechsel. Mehrere solche Events in einem Frame werden zu einem Durchgang zusammengefasst.
+- **Anzeige-Zwischenspeicher.** Lebenstext, Balkenmaxima, Balkenwerte, Balkenfarbe und Sichtbarkeit des Manastreifens werden nur geschrieben, wenn sie sich aendern. Entfernbare Debuffs werden nur bei `UNIT_AURA` gesucht; `UNIT_HEALTH` und der Vorhersage-Tick nutzen den letzten Befund.
+- **Aura-Scans gemeinsam.** Die Buff-Texturen einer Einheit werden je Frame einmal gelesen und von Heilvorhersage und Buff-Wache geteilt. Per Tooltip ermittelte Buffnamen werden je Textur gemerkt, sodass eine Einheit ohne den ueberwachten Buff nicht mehr bis zu 32 Tooltip-Scans je Aura-Event kostet. Raid-Einheiten werden nur gescannt, wenn etwas davon abhaengt (eigener Cast wartet, HoT oder Schild verfolgt, sichtbare Zelle).
+- **Guenstigere Ticks.** Zauber-Timer nutzen vorberechnete Basisnamen statt String-Parsing je Button und Tick und ueberspringen Einheiten ohne verfolgten HoT oder Schild. Buff-Icons verwenden ihre Arbeitstabellen wieder, laufen ueber eine vorsortierte Liste statt je Tick zu sortieren und aktualisieren bei Aenderung oder einmal je Sekunde statt fuenfmal. Der Angegriffenen-Abgleich entfaellt ganz, solange kein feindliches Ziel besteht und nichts markiert ist, und vergleicht Namen, bevor `UnitIsUnit` gerufen wird.
+- **Event-Salven zusammengefasst.** `PARTY_MEMBERS_CHANGED`, `UNIT_PET` und `RAID_ROSTER_UPDATE` setzen ein Kennzeichen, das im naechsten Frame einmal abgearbeitet wird, statt Plaketten und Raster bei jedem Event einer Salve neu aufzubauen.
+- **Mana-Ticker.** Die Pruefungen an/Mana/voll laufen bei Mana-Events und Optionswechseln statt jeden Frame; der Funke wird nur neu verankert, wenn er sich mindestens einen halben Pixel bewegt hat; Groessen und Sichtbarkeit sind zwischengespeichert.
+- **Combatlog.** Heilmuster laufen nur bei Buff-Events, das Absorb-Muster nur bei Treffer-Events, die das Wort absorbed enthalten. Smart Damage liest Schadenszeilen nur, solange es an ist und ein Ziel vermessen wird oder ein eigener Cast wartet; die Live-Zielzeile wird nur bei offenem Optionsfenster aktualisiert.
+- Der Animationsframe der Raid-Testgeister ist ausserhalb des Raid-Tests ausgeblendet, statt jeden Frame leer zu laufen.
+- **Client-API-Kompatibilitaet.** `IsSpellInRange` und `IsUsableSpell` gibt es im 1.12-Client nicht (sie kamen mit 2.0). Alle Reichweiten- und Nutzbarkeitspruefungen laufen jetzt ueber Wrapper, die sie nutzen, wenn ein Client sie anbietet, und sonst auf 1.12-Mittel zurueckfallen: Zauberreichweite aus dem Tooltip gegen `UnitXP("distanceBetween")`, wo vorhanden, sonst `CheckInteractDistance` (28 m, jenseits davon unentschieden statt rot); Manapreis aus dem Tooltip gegen das eigene Mana. Weil Clients sich unterscheiden (2.0-Form `(id, "spell", unit)` gegenueber der Turtle-Form `(name, unit)`), probiert das Addon beide Signaturen beim Login einmal per `pcall` aus und nutzt die verstandene; eine Funktion, die weiter Fehler wirft, wird zugunsten des Rueckfalls abgeschaltet. `/fbp` meldet die erkannte Form. Ohne das brach der neue zentrale Button-Durchgang beim Login ab.
+
+**Behoben**
+
+- Der alte Button-Handler deklarierte `this`, `event` und `arg1` als Parameter und verdeckte damit die 1.12-Globals; Reichweitenfaerbung und Cooldown-Uhr auf den Buttons haben im Spiel nie gearbeitet. Jetzt tun sie es.
+
+
+## 1.4.3 (2026-09-05)
+
+### English
+
+**New**
+
+- **Languages.** Spanish, French and Italian added to all addon texts (English and German unchanged). The client locale picks the language automatically, the language button lists all five, missing keys fall back to English.
+- **Mana ticker** (module `FBHealBox_Ticker.lua`, on by default). A spark travels across your own mana strip every 2 seconds in step with the server's regeneration tick; after spending mana it turns orange and runs the five-second rule down, extended to the first tick after the five seconds. Works on the party plate and on your own raid cell, hidden while mana is full. Detection via `UNIT_MANA` only: grid from observed ticks, re-sync within a tolerance, foreign pulses (totems, Innervate) ignored, potions and runes filtered by size. Own options tab *Ticker*: master switch, five-second rule, tick tolerance, tick offset, spark width. `/fbp ticker` toggles, `/fbp` reports sync state.
+- **Smart Healing** (off by default). When on, a click casts the lowest rank of the assigned spell whose expected heal covers the target's missing health (minus incoming healing) plus a safety margin (default 20 %). Never above the assigned rank, direct heals only, always the assigned rank below 30 % health. Learned heal values are used where available. Downsides (no crits in the estimate, burst damage, deliberate overhealing) are explained in the tooltip. Options on the *Buttons* tab; `/fbp debug` logs each decision, `/fbp` shows the state.
+- **Cooldown sweep on buttons**, global cooldown excluded. Option *Cooldowns on buttons*.
+- **Red border for the attacked member**: the plate or raid cell of the unit your hostile target is targeting. Takes precedence over the buff-watch border. Option *Mark who is attacked*.
+- **HoT and shield timers on buttons**: each spell's button shows the remaining seconds of your own HoT (green) or shield (blue) on that unit; after Power Word: Shield the button shows Weakened Soul in red. Option *HoT and shield timers*.
+- **Smart Damage** (module `FBHealBox_Damage.lua`, off by default). Attack spells pressed on any action bar or key binding are cast in the lowest rank that still kills the target, never above the rank on the bar. Target health from the server (real values), MobHealth3, MobInfo-2, or the addon's own per-mob-type estimate learned from combat-log damage and percent drops (highest measurement kept). Minimum damage per rank from the tooltip, raised by observed full hits. Section on the *Extras* tab (shared with the ticker) with switch, safety margin, live health-source line and spell list; `/fbp damage`, decisions in `/fbp debug`.
+- **Buff icons in the health bar**: buffs with a duration that sit on your buttons (Fortitude, Divine Spirit, Fear Ward, Inner Fire) appear as small 8 px icons on the outer left side of the plate. The icon is a clock: it turns black and white clockwise from twelve o'clock as the time runs out (half left = right half grey). Exact on yourself, counted from your own cast on others, fully coloured when cast by someone else. Raid cells show them outside their left edge; the grid reserves the room. Line-of-sight badge moved to the plate's top-left corner. Units are scanned once after login and group changes so existing buffs appear immediately. `/fbp buffs` for diagnostics. Option *Buff icons in the health bar*.
+- Test-mode ghost Dorn demonstrates the red border and the timers.
+
+**Fixed**
+
+- Own buffs were only read at login and on group changes: Vanilla fires `PLAYER_AURAS_CHANGED` for the player instead of `UNIT_AURA`. The addon now listens to it and re-reads your remaining time on every change, and once a second in between (a refresh of a running buff fires no aura event at all), so recasting a buff on yourself resets its clock and cancelling it removes the icon. Refreshing a buff on someone else through a HealBox button is confirmed by the completed cast. Also fixes confirmation of your own HoTs and shields on yourself.
+- Raid cell names and percentages were hidden behind the health bar since the bar levels became relative; the texts now live on their own layer above the bars.
+- Buff icons stack two high left of the plate; elapsed clock quadrants are drawn dark on a layer above the icon so the split shows on every client. Raid cells use a 3 by 4 grid of 6 px icons (twelve slots); the new raid option *Show buffs* removes icons and strip together. `/fbp buffs` reports the grey count per icon.
+- Test modes extended: party ghost Brynn is dead, pet Bramble carries a disease, Dorn carries six and raid ghost 12 twelve buffs, raid ghost 27 a disease. Up to six buff icons per plate.
+- Plate names could sit too low on some rows (the name box grew to two lines internally). Name, paw icon and debuff icon are now vertically centred with a fixed one-line height.
+
+- Tooltip parser took durations ("for 30 min", "again for 15 sec") for direct heal amounts, so buffs such as Power Word: Fortitude and the shield reported a tiny "heal" and Smart Healing downranked them. Durations are ignored now, and Smart Healing only touches spells whose tooltip describes a heal and that carry no absorb.
+
+**Changed**
+
+- Option tab buttons are 100 px wide (was 110) so that four tabs fit in the window; class icon shrunk so it no longer overlaps the tabs. Checkbox labels have a fixed width and end with an ellipsis when a translation is long; the tooltip carries the full text. The fourth tab is called *Extras* and holds the ticker and Smart Damage sections.
+- Tooltip parser: only `hr`/`hour` count as hours; `Holy` no longer looks like a time unit.
+- New core hooks `Loaded`, `Aggro`, `SpellTimers`, `Cooldowns` for modules.
+
+### Deutsch
+
+**Neu**
+
+- **Sprachen.** Spanisch, Franzoesisch und Italienisch fuer alle Addon-Texte hinzugefuegt (Englisch und Deutsch unveraendert). Die Client-Sprache waehlt automatisch, der Sprachknopf listet alle fuenf, fehlende Schluessel fallen auf Englisch zurueck.
+- **Mana-Ticker** (Modul `FBHealBox_Ticker.lua`, standardmaessig an). Ein Funke wandert alle 2 Sekunden im Takt des Regenerationsticks ueber deinen eigenen Manastreifen; nach Manaverbrauch wird er orange und laeuft die Fuenf-Sekunden-Regel herunter, verlaengert bis zum ersten Tick nach den fuenf Sekunden. Auf der Gruppenplakette und der eigenen Raid-Zelle, bei vollem Mana ausgeblendet. Erkennung nur ueber `UNIT_MANA`: Raster aus beobachteten Ticks, Neusynchronisation innerhalb einer Toleranz, fremde Pulse (Totems, Anregen) ignoriert, Traenke und Runen nach Groesse gefiltert. Eigener Options-Reiter *Ticker*: Hauptschalter, Fuenf-Sekunden-Regel, Tick-Toleranz, Tick-Vorlauf, Funkenbreite. `/fbp ticker` schaltet um, `/fbp` meldet den Synchronzustand.
+- **Smart Healing** (standardmaessig aus). Eingeschaltet wirkt ein Klick den niedrigsten Rang des belegten Zaubers, dessen erwartete Heilung das fehlende Leben des Ziels (abzueglich eingehender Heilung) plus Sicherheitsaufschlag (Standard 20 %) deckt. Nie ueber dem belegten Rang, nur Direktheilungen, unter 30 % Leben immer der belegte Rang. Gelernte Heilwerte werden genutzt, wo vorhanden. Nachteile (keine Crits in der Schaetzung, Schadensspitzen, gewolltes Ueberheilen) erklaert der Tooltip. Optionen im Reiter *Buttons*; `/fbp debug` protokolliert jede Entscheidung, `/fbp` zeigt den Zustand.
+- **Cooldown-Uhr auf den Buttons**, globaler Cooldown ausgenommen. Option *Cooldowns auf den Buttons*.
+- **Roter Rahmen fuer den Angegriffenen**: Plakette oder Raid-Zelle der Einheit, die dein feindliches Ziel im Ziel hat. Hat Vorrang vor dem Buff-Wache-Rahmen. Option *Angegriffenen markieren*.
+- **HoT- und Schild-Timer auf den Buttons**: Der Button jedes Zaubers zeigt die Restsekunden deines eigenen HoTs (gruen) oder Schilds (blau) auf dieser Einheit; nach Machtwort: Schild zeigt der Button rot die Geschwaechte Seele. Option *HoT- und Schild-Timer*.
+- **Smart Damage** (Modul `FBHealBox_Damage.lua`, standardmaessig aus). Angriffszauber auf jeder Aktionsleiste oder Taste werden im niedrigsten Rang gewirkt, der das Ziel noch toetet, nie ueber dem Rang auf der Leiste. Ziel-Leben vom Server (echte Werte), MobHealth3, MobInfo-2 oder aus der eigenen Schaetzung je Mobtyp, gelernt aus Combatlog-Schaden und Prozentabfall (hoechste Messung zaehlt). Mindestschaden je Rang aus dem Tooltip, angehoben durch beobachtete Volltreffer. Abschnitt im Reiter *Extras* (gemeinsam mit dem Ticker) mit Schalter, Sicherheitsaufschlag, Live-Zeile zur Lebensquelle und Zauberliste; `/fbp damage`, Entscheidungen in `/fbp debug`.
+- **Buff-Icons im Lebensbalken**: Buffs mit Laufzeit, die auf deinen Buttons liegen (Seelenstaerke, Goettlicher Willen, Furchtzauberschutz, Inneres Feuer), erscheinen als kleine 8-px-Icons aussen links neben der Plakette. Das Icon ist eine Uhr: Es wird im Uhrzeigersinn ab zwoelf Uhr schwarz-weiss, je weiter die Zeit ablaeuft (halbe Zeit = rechte Haelfte grau). Exakt bei dir selbst, ab deinem eigenen Cast bei anderen, ganz farbig bei fremdem Cast. Raid-Zellen zeigen sie aussen an ihrer linken Kante; das Raster haelt den Platz frei. Sichtlinien-Abzeichen in die linke obere Plattenecke verlegt. Nach Login und Gruppenwechsel werden alle Einheiten einmal gescannt, damit vorhandene Buffs sofort erscheinen. `/fbp buffs` zur Diagnose. Option *Buff-Icons im Lebensbalken*.
+- Testmodus-Geist Dorn zeigt roten Rahmen und Timer.
+
+**Behoben**
+
+- Eigene Buffs wurden nur beim Login und bei Gruppenwechseln gelesen: Vanilla feuert fuer den Spieler `PLAYER_AURAS_CHANGED` statt `UNIT_AURA`. Das Addon hoert jetzt darauf und liest die eigene Restzeit bei jeder Aenderung neu, und dazwischen einmal je Sekunde (ein Refresh eines laufenden Buffs feuert gar kein Aura-Event), sodass ein Neucast auf dich selbst die Uhr zuruecksetzt und ein Wegklicken das Icon entfernt. Ein Refresh auf jemand anderen ueber einen HealBox-Button gilt mit dem abgeschlossenen Cast als bestaetigt. Behebt auch die Bestaetigung eigener HoTs und Schilde auf dir selbst.
+- Namen und Prozente der Raid-Zellen lagen seit den relativen Balken-Ebenen hinter dem Lebensbalken; die Texte liegen jetzt auf einer eigenen Ebene ueber den Balken.
+- Buff-Icons stapeln sich zu zweit links neben der Plakette; abgelaufene Uhr-Quadranten werden dunkel auf einer Ebene ueber dem Icon gezeichnet, damit die Teilung auf jedem Client sichtbar ist. Raid-Zellen nutzen ein 3-mal-4-Raster aus 6-px-Icons (zwoelf Plaetze); die neue Raid-Option *Buffs anzeigen* entfernt Icons und Streifen gemeinsam. `/fbp buffs` nennt je Icon die Zahl grauer Quadranten.
+- Testmodi erweitert: Partygeist Brynn ist tot, Pet Bramble traegt eine Krankheit, Dorn traegt sechs und Raid-Geist 12 zwoelf Buffs, Raid-Geist 27 eine Krankheit. Bis zu sechs Buff-Icons je Plakette.
+- Plakettennamen sassen in manchen Zeilen zu tief (die Namensbox wuchs intern auf zwei Zeilen). Name, Pfoten-Icon und Debuff-Icon sind jetzt mit fester Einzeilenhoehe vertikal zentriert.
+
+- Der Tooltip-Leser hielt Zeitangaben ("for 30 min", "again for 15 sec") fuer Heilbetraege, wodurch Buffs wie Machtwort: Seelenstaerke und der Schild eine winzige "Heilung" meldeten und Smart Healing sie abgerangt hat. Zeitangaben werden jetzt uebersprungen, und Smart Healing fasst nur Zauber an, deren Tooltip eine Heilung beschreibt und die keinen Absorb haben.
+
+**Geaendert**
+
+- Reiterknoepfe der Optionen sind 100 px breit (vorher 110), damit vier Reiter ins Fenster passen; Klassen-Icon verkleinert, damit es die Reiter nicht mehr ueberlagert. Schalterbeschriftungen haben eine feste Breite und enden bei langen Uebersetzungen mit Auslassungspunkten; der Tooltip traegt den vollen Text. Der vierte Reiter heisst *Extras* und enthaelt Ticker und Smart Damage.
+- Tooltip-Leser: Nur `hr`/`hour` zaehlen als Stunden; `Holy` sieht nicht mehr wie eine Zeiteinheit aus.
+- Neue Kern-Hooks `Loaded`, `Aggro`, `SpellTimers`, `Cooldowns` fuer Module.
+
 ## 1.4.2 (2026-09-05)
 
 ### English
@@ -13,7 +390,7 @@
 - Raid test with 20 or 40 ghosts covering every visual state. `/fbp raid`, `/fbp raidtest 20|40|off`, raid line in `/fbp`.
 - Grid position and scale are saved separately from the party plates. Party plates are hidden while the grid is up (switchable).
 
-**New: drag and drop.** Spells can be dragged from the spellbook onto any heal button, raid mini button or options field. Right mouse button fills the right-click side when that option is on. Spells outside the class list are accepted.
+**New: drag and drop.** Spells can be dragged from the spellbook onto any heal button, raid mini button or options field. Right mouse button, or Shift held while dropping, fills the right-click side when that option is on. Spells outside the class list are accepted.
 
 **Fixed**
 
@@ -37,7 +414,7 @@
 - Raid-Test mit 20 oder 40 Geistern, die jeden Anzeigezustand abdecken. `/fbp raid`, `/fbp raidtest 20|40|off`, Raid-Zeile in `/fbp`.
 - Position und Skalierung des Rasters werden getrennt von den Plaketten gespeichert. Die Gruppenplaketten sind ausgeblendet, solange das Raster steht (abschaltbar).
 
-**Neu: Drag & Drop.** Zauber lassen sich aus dem Zauberbuch auf jeden Heil-Button, Raid-Mini-Button oder jedes Optionsfeld ziehen. Die rechte Maustaste fuellt die Rechtsklick-Seite, wenn die Option an ist. Zauber ausserhalb der Klassenliste werden angenommen.
+**Neu: Drag & Drop.** Zauber lassen sich aus dem Zauberbuch auf jeden Heil-Button, Raid-Mini-Button oder jedes Optionsfeld ziehen. Die rechte Maustaste oder gehaltene Shift-Taste beim Ablegen fuellt die Rechtsklick-Seite, wenn die Option an ist. Zauber ausserhalb der Klassenliste werden angenommen.
 
 **Behoben**
 

FBHealBox.toc

@@ -1,12 +1,14 @@
 ## Interface: 11200
-## Title: Heal Box Vanilla |cFFFFFF00v1.4.2|r
-## Notes: Party, pet and self heal display with quick-cast buttons for healers. Ported to client 1.12.1 (optional SuperWoW). Up to 10 buttons per row, mana bar inside the health bar, class colours, buff watch, range fading, adjustable spacing, test mode with ghost players, optional raid mode for 20 and 40 players. Heal prediction for direct heals, HoT ticks and absorb shields, self-correcting from the combat log. HealComm sync with Puppeteer, pfUI and others. German/English. Original by Dourd, ported to Vanilla and extended 09/2026 by Mquadrat.
-## Notes-deDE: Party-, Begleiter- und Selbst-Heilanzeige mit Schnellzugriff-Buttons fuer Heiler. Portiert fuer Client 1.12.1 (optional SuperWoW). Bis zu 10 Buttons pro Reihe, Manabalken im Lebensbalken, Klassenfarben, Buff-Wache, Reichweiten-Fading, einstellbare Abstaende, Testmodus mit Geisterspielern, optionaler Raidmodus fuer 20 und 40 Spieler. Heal-Prediction fuer Direktheilung, HoT-Ticks und Absorb-Schilde, selbstkorrigierend ueber den Combatlog. HealComm-Sync mit Puppeteer, pfUI und Co. Deutsch/Englisch. Original von Dourd, Vanilla-Portierung und Erweiterung 09/2026 von Mquadrat.
+## Title: Heal Box Vanilla |cFFFFFF00v1.4.6.1|r
+## Notes: Heal/raid frame addon like Healium, with quick-cast buttons, heal prediction, mana ticker and more.
+## Notes-deDE: Heal/Raidframe Addon aehnlich Healium, mit Schnellzugriff Buttons, Heal Prediction und Mana Ticker und mehr.
 ## Author: Dourd (Argent Dawn EU) | Vanilla-Port & Erweiterung 09/2026: Mquadrat
-## Version: 1.4.2
+## Version: 1.4.6.1
 ## SavedVariablesPerCharacter: HealBox
 ## OptionalDeps: SuperWoW
 
 FBHealBox.lua
 FBHealBox_Raid.lua
+FBHealBox_Ticker.lua
+FBHealBox_Damage.lua
 FBHealBox.xml

FBHealBox_Damage.lua

@@ -0,0 +1,634 @@
+-- ==========================================================================
+-- Heal Box Vanilla: Smart Damage (Modul, ab v1.4.3)
+--
+-- Rangwahl fuer Angriffszauber auf jeder Aktionsleiste. Bongos, Blizzard-
+-- Leisten und Tastenkuerzel rufen UseAction(slot) auf; ein Vor-Hook erkennt
+-- den Zauber im Slot per Tooltip-Scan und wirkt, wenn ein kleinerer Rang
+-- den Gegner sicher toetet, diesen Rang per CastSpellByName. Sonst laeuft
+-- der Aufruf unveraendert weiter. Nie ueber dem Rang auf der Leiste.
+--
+-- Leben des Gegners, vier Quellen mit Vorrang:
+--   1) Server sendet echte Werte (UnitHealthMax ~= 100)
+--   2) MobHealth3            MobHealth3:GetUnitHealth(unit)
+--   3) MobInfo-2             MobHealth_GetTargetCurHP()/MaxHP()
+--   4) eigene Schaetzung     Lebenspunkte je Prozent aus beobachtetem Schaden
+--      (eigener, Gruppe, Begleiter) und dem Prozentabfall des Ziels, erst ab
+--      FBDMG_MIN_DROP Prozent Abfall, Maximum ueber alle Messungen (Fehler
+--      nur nach oben, also in die sichere Richtung), gemerkt je Name:Stufe.
+--
+-- Schaden je Rang: Mindestschaden aus dem Tooltip ("86 to 98 Holy damage"),
+-- nachgelernt aus eigenen Treffern ohne Teilwiderstand. Entscheidung:
+-- Mindestschaden >= Ziel-Leben (bei Prozent: Obergrenze) x (1 + Aufschlag).
+-- ==========================================================================
+
+if (FBHealBox_DamageLoaded) then return; end
+FBHealBox_DamageLoaded = true;
+
+FBDMG_MIN_DROP     = 3;      -- Prozent Abfall, ab dem eine Messung zaehlt
+FBDMG_LASTCAST_SEC = 4;      -- Sek., wie lange ein eigener Cast fuers Lernen gilt
+
+FBDamageDefaults = {
+    Enabled = 0,             -- Smart Damage an/aus (bewusst aus)
+    Margin  = 20,            -- Sicherheitsaufschlag in Prozent
+};
+
+-- Angriffszauber je Klasse (englische Zaubernamen wie im ganzen Addon).
+-- Kanalisierte, reine DoTs und Flaechenzauber bleiben draussen.
+FBDamageSpells = {
+    Priest  = { "Smite", "Holy Fire", "Mind Blast" },
+    Druid   = { "Wrath", "Starfire", "Moonfire" },
+    Shaman  = { "Lightning Bolt", "Chain Lightning", "Earth Shock", "Flame Shock", "Frost Shock" },
+    Paladin = { "Holy Shock", "Hammer of Wrath", "Exorcism", "Holy Wrath" },
+    Mage    = { "Fireball", "Frostbolt", "Fire Blast", "Scorch", "Pyroblast" },
+    Warlock = { "Shadow Bolt", "Searing Pain", "Immolate", "Soul Fire", "Conflagrate" },
+    Hunter  = { "Arcane Shot", "Aimed Shot" },
+};
+
+-- ==========================================================================
+-- [ Texte ]
+-- ==========================================================================
+
+FBLocale["enUS"].DMG_HEADER      = "Smart Damage";
+FBLocale["enUS"].DMG_ENABLED     = "Smart Damage";
+FBLocale["enUS"].DMG_ENABLED_TIP = "What it does: when you press an attack spell on any action bar (Bongos, Blizzard bars, key bindings) and a lower rank of that spell would still kill the target, that rank is cast instead. Saves mana on nearly dead targets. Rules: never above the rank on the bar, minimum damage of the rank must cover the target's remaining health plus the safety margin. Needs the target's real health: from the server, from MobHealth3 or MobInfo-2, or from the addon's own estimate learned while fighting a mob type. Downsides: estimates can be wrong, partial resists lower the damage, and on unknown mobs nothing happens until enough has been learned. Off by default.";
+FBLocale["enUS"].DMG_MARGIN      = "Safety margin: |cFFFFFFFF%s %%";
+FBLocale["enUS"].DMG_SRC         = "Target health source: |cFFFFFFFF%s";
+FBLocale["enUS"].DMG_SRC_REAL    = "server sends real values";
+FBLocale["enUS"].DMG_SRC_MH3     = "MobHealth3";
+FBLocale["enUS"].DMG_SRC_MI2     = "MobInfo-2";
+FBLocale["enUS"].DMG_SRC_EST     = "own estimate (%d mob types learned)";
+FBLocale["enUS"].DMG_SRC_NONE    = "no target";
+FBLocale["enUS"].DMG_SRC_UNKNOWN = "percent only, nothing learned yet";
+FBLocale["enUS"].DMG_SPELLS      = "Spells: |cFFFFFFFF%s";
+FBLocale["enUS"].DMG_INFO        = "The target line above updates with your current target. Learning happens automatically: every fight against a mob type improves the estimate for that type.";
+FBLocale["enUS"].DMG_STATUS      = "Smart Damage: %s, margin %d %%, %s";
+FBLocale["enUS"].DBG_DMG         = "Smart Damage: %s -> %s (target %d HP via %s, min damage %d)";
+FBLocale["enUS"].DBG_DMG_KEEP    = "Smart Damage: %s kept (target %d HP via %s)";
+FBLocale["enUS"].DMG_LOADED      = "Smart Damage module loaded: section in tab |cFFFFFFFFExtras|r, /fbp damage";
+FBLocale["enUS"].DMG_ON          = "Smart Damage |cFF00FF00on|r.";
+FBLocale["enUS"].DMG_OFF         = "Smart Damage |cFFFF0000off|r.";
+
+FBLocale["deDE"].DMG_HEADER      = "Smart Damage";
+FBLocale["deDE"].DMG_ENABLED     = "Smart Damage";
+FBLocale["deDE"].DMG_ENABLED_TIP = "Was es tut: Drueckst du einen Angriffszauber auf einer beliebigen Aktionsleiste (Bongos, Blizzard-Leisten, Tastenkuerzel) und ein niedrigerer Rang wuerde das Ziel noch toeten, wird stattdessen dieser Rang gewirkt. Spart Mana bei fast toten Zielen. Regeln: nie ueber dem Rang auf der Leiste, der Mindestschaden des Rangs muss das Restleben des Ziels plus Sicherheitsaufschlag decken. Braucht das echte Leben des Ziels: vom Server, von MobHealth3 oder MobInfo-2, oder aus der eigenen Schaetzung, die das Addon im Kampf gegen einen Mobtyp lernt. Nachteile: Schaetzungen koennen danebenliegen, Teilwiderstaende senken den Schaden, und bei unbekannten Mobs passiert nichts, bis genug gelernt ist. Standardmaessig aus.";
+FBLocale["deDE"].DMG_MARGIN      = "Sicherheitsaufschlag: |cFFFFFFFF%s %%";
+FBLocale["deDE"].DMG_SRC         = "Lebensquelle des Ziels: |cFFFFFFFF%s";
+FBLocale["deDE"].DMG_SRC_REAL    = "Server sendet echte Werte";
+FBLocale["deDE"].DMG_SRC_MH3     = "MobHealth3";
+FBLocale["deDE"].DMG_SRC_MI2     = "MobInfo-2";
+FBLocale["deDE"].DMG_SRC_EST     = "eigene Schaetzung (%d Mobtypen gelernt)";
+FBLocale["deDE"].DMG_SRC_NONE    = "kein Ziel";
+FBLocale["deDE"].DMG_SRC_UNKNOWN = "nur Prozent, noch nichts gelernt";
+FBLocale["deDE"].DMG_SPELLS      = "Zauber: |cFFFFFFFF%s";
+FBLocale["deDE"].DMG_INFO        = "Die Zielzeile oben folgt deinem aktuellen Ziel. Gelernt wird von selbst: Jeder Kampf gegen einen Mobtyp verbessert die Schaetzung fuer diesen Typ.";
+FBLocale["deDE"].DMG_STATUS      = "Smart Damage: %s, Aufschlag %d %%, %s";
+FBLocale["deDE"].DBG_DMG         = "Smart Damage: %s -> %s (Ziel %d LP ueber %s, Mindestschaden %d)";
+FBLocale["deDE"].DBG_DMG_KEEP    = "Smart Damage: %s bleibt (Ziel %d LP ueber %s)";
+FBLocale["deDE"].DMG_LOADED      = "Smart-Damage-Modul geladen: Abschnitt im Reiter |cFFFFFFFFExtras|r, /fbp damage";
+FBLocale["deDE"].DMG_ON          = "Smart Damage |cFF00FF00an|r.";
+FBLocale["deDE"].DMG_OFF         = "Smart Damage |cFFFF0000aus|r.";
+
+-- Weitere Sprachen (Spanisch, Franzoesisch, Italienisch)
+
+FBLocale["esES"].DMG_HEADER        = "Smart Damage";
+FBLocale["esES"].DMG_ENABLED       = "Smart Damage";
+FBLocale["esES"].DMG_ENABLED_TIP   = "Qué hace: cuando pulsas un hechizo de ataque en cualquier barra de acción (Bongos, barras de Blizzard, atajos de teclado) y un rango inferior de ese hechizo aún mataría al objetivo, se lanza ese rango en su lugar. Ahorra maná con objetivos casi muertos. Reglas: nunca por encima del rango de la barra, el daño mínimo del rango debe cubrir la vida restante del objetivo más el margen de seguridad. Necesita la vida real del objetivo: del servidor, de MobHealth3 o MobInfo-2, o de la estimación propia del addon aprendida al combatir un tipo de enemigo. Desventajas: las estimaciones pueden fallar, las resistencias parciales reducen el daño y con enemigos desconocidos no ocurre nada hasta haber aprendido lo suficiente. Desactivado por defecto.";
+FBLocale["esES"].DMG_MARGIN        = "Margen de seguridad: |cFFFFFFFF%s %%";
+FBLocale["esES"].DMG_SRC           = "Fuente de vida del objetivo: |cFFFFFFFF%s";
+FBLocale["esES"].DMG_SRC_REAL      = "el servidor envía valores reales";
+FBLocale["esES"].DMG_SRC_MH3       = "MobHealth3";
+FBLocale["esES"].DMG_SRC_MI2       = "MobInfo-2";
+FBLocale["esES"].DMG_SRC_EST       = "estimación propia (%d tipos de enemigo aprendidos)";
+FBLocale["esES"].DMG_SRC_NONE      = "sin objetivo";
+FBLocale["esES"].DMG_SRC_UNKNOWN   = "solo porcentaje, aún nada aprendido";
+FBLocale["esES"].DMG_SPELLS        = "Hechizos: |cFFFFFFFF%s";
+FBLocale["esES"].DMG_INFO          = "La línea del objetivo se actualiza con tu objetivo actual. El aprendizaje es automático: cada combate contra un tipo de enemigo mejora la estimación de ese tipo.";
+FBLocale["esES"].DMG_STATUS        = "Smart Damage: %s, margen %d %%, %s";
+FBLocale["esES"].DBG_DMG           = "Smart Damage: %s -> %s (objetivo %d PV vía %s, daño mínimo %d)";
+FBLocale["esES"].DBG_DMG_KEEP      = "Smart Damage: %s mantenido (objetivo %d PV vía %s)";
+FBLocale["esES"].DMG_LOADED        = "Módulo Smart Damage cargado: sección en la pestaña |cFFFFFFFFExtras|r, /fbp damage";
+FBLocale["esES"].DMG_ON            = "Smart Damage |cFF00FF00activado|r.";
+FBLocale["esES"].DMG_OFF           = "Smart Damage |cFFFF0000desactivado|r.";
+
+FBLocale["frFR"].DMG_HEADER        = "Smart Damage";
+FBLocale["frFR"].DMG_ENABLED       = "Smart Damage";
+FBLocale["frFR"].DMG_ENABLED_TIP   = "Ce que ça fait : quand vous appuyez sur un sort d'attaque sur n'importe quelle barre d'action (Bongos, barres Blizzard, raccourcis) et qu'un rang inférieur de ce sort tuerait encore la cible, c'est ce rang qui est lancé. Économise du mana sur les cibles presque mortes. Règles : jamais au-dessus du rang de la barre, les dégâts minimaux du rang doivent couvrir la vie restante de la cible plus la marge de sécurité. Nécessite la vie réelle de la cible : du serveur, de MobHealth3 ou MobInfo-2, ou de l'estimation propre de l'addon apprise en combattant un type de monstre. Inconvénients : les estimations peuvent se tromper, les résistances partielles réduisent les dégâts, et sur les monstres inconnus rien ne se passe tant que l'apprentissage est insuffisant. Désactivé par défaut.";
+FBLocale["frFR"].DMG_MARGIN        = "Marge de sécurité : |cFFFFFFFF%s %%";
+FBLocale["frFR"].DMG_SRC           = "Source de vie de la cible : |cFFFFFFFF%s";
+FBLocale["frFR"].DMG_SRC_REAL      = "le serveur envoie des valeurs réelles";
+FBLocale["frFR"].DMG_SRC_MH3       = "MobHealth3";
+FBLocale["frFR"].DMG_SRC_MI2       = "MobInfo-2";
+FBLocale["frFR"].DMG_SRC_EST       = "estimation propre (%d types de monstres appris)";
+FBLocale["frFR"].DMG_SRC_NONE      = "aucune cible";
+FBLocale["frFR"].DMG_SRC_UNKNOWN   = "pourcentage seulement, rien appris pour le moment";
+FBLocale["frFR"].DMG_SPELLS        = "Sorts : |cFFFFFFFF%s";
+FBLocale["frFR"].DMG_INFO          = "La ligne de cible ci-dessus se met à jour avec votre cible actuelle. L'apprentissage est automatique : chaque combat contre un type de monstre améliore l'estimation pour ce type.";
+FBLocale["frFR"].DMG_STATUS        = "Smart Damage : %s, marge %d %%, %s";
+FBLocale["frFR"].DBG_DMG           = "Smart Damage : %s -> %s (cible %d PV via %s, dégâts min %d)";
+FBLocale["frFR"].DBG_DMG_KEEP      = "Smart Damage : %s conservé (cible %d PV via %s)";
+FBLocale["frFR"].DMG_LOADED        = "Module Smart Damage chargé : section dans l'onglet |cFFFFFFFFExtras|r, /fbp damage";
+FBLocale["frFR"].DMG_ON            = "Smart Damage |cFF00FF00activé|r.";
+FBLocale["frFR"].DMG_OFF           = "Smart Damage |cFFFF0000désactivé|r.";
+
+FBLocale["itIT"].DMG_HEADER        = "Smart Damage";
+FBLocale["itIT"].DMG_ENABLED       = "Smart Damage";
+FBLocale["itIT"].DMG_ENABLED_TIP   = "Cosa fa: quando premi un incantesimo d'attacco su una qualsiasi barra delle azioni (Bongos, barre Blizzard, scorciatoie) e un rango inferiore di quell'incantesimo ucciderebbe comunque il bersaglio, viene lanciato quel rango. Risparmia mana sui bersagli quasi morti. Regole: mai sopra il rango sulla barra, il danno minimo del rango deve coprire la salute rimanente del bersaglio più il margine di sicurezza. Richiede la salute reale del bersaglio: dal server, da MobHealth3 o MobInfo-2, o dalla stima dell'addon appresa combattendo un tipo di mostro. Svantaggi: le stime possono sbagliare, le resistenze parziali riducono il danno e sui mostri sconosciuti non succede nulla finché non si è appreso abbastanza. Disattivato per impostazione predefinita.";
+FBLocale["itIT"].DMG_MARGIN        = "Margine di sicurezza: |cFFFFFFFF%s %%";
+FBLocale["itIT"].DMG_SRC           = "Fonte della salute del bersaglio: |cFFFFFFFF%s";
+FBLocale["itIT"].DMG_SRC_REAL      = "il server invia valori reali";
+FBLocale["itIT"].DMG_SRC_MH3       = "MobHealth3";
+FBLocale["itIT"].DMG_SRC_MI2       = "MobInfo-2";
+FBLocale["itIT"].DMG_SRC_EST       = "stima propria (%d tipi di mostro appresi)";
+FBLocale["itIT"].DMG_SRC_NONE      = "nessun bersaglio";
+FBLocale["itIT"].DMG_SRC_UNKNOWN   = "solo percentuale, ancora nulla appreso";
+FBLocale["itIT"].DMG_SPELLS        = "Incantesimi: |cFFFFFFFF%s";
+FBLocale["itIT"].DMG_INFO          = "La riga del bersaglio qui sopra si aggiorna con il tuo bersaglio attuale. L'apprendimento è automatico: ogni combattimento contro un tipo di mostro migliora la stima per quel tipo.";
+FBLocale["itIT"].DMG_STATUS        = "Smart Damage: %s, margine %d %%, %s";
+FBLocale["itIT"].DBG_DMG           = "Smart Damage: %s -> %s (bersaglio %d PS via %s, danno minimo %d)";
+FBLocale["itIT"].DBG_DMG_KEEP      = "Smart Damage: %s mantenuto (bersaglio %d PS via %s)";
+FBLocale["itIT"].DMG_LOADED        = "Modulo Smart Damage caricato: sezione nella scheda |cFFFFFFFFExtra|r, /fbp damage";
+FBLocale["itIT"].DMG_ON            = "Smart Damage |cFF00FF00attivo|r.";
+FBLocale["itIT"].DMG_OFF           = "Smart Damage |cFFFF0000disattivato|r.";
+
+-- ==========================================================================
+-- [ Zustand ]
+-- ==========================================================================
+
+FBDmgSpellRanks = {};   -- [Name] = { { rank, id, min, max }, ... } aufsteigend
+FBDmgSlotCache  = {};   -- [slot] = { name, rank } oder false (kein Zauber)
+FBDmgAnchorPct  = nil;  -- Prozent des Ziels beim letzten Messpunkt
+FBDmgAccum      = 0;    -- Schaden auf das Ziel seit dem Messpunkt
+FBDmgTargetName = nil;
+FBDmgLastCast   = nil;  -- { spell, rank, t } fuer das Lernen aus dem Combatlog
+
+function FBDmg_Cfg()
+    if (not HealBox.Damage) then FBDmg_ApplyDefaults(); end
+    return HealBox.Damage;
+end
+
+function FBDmg_ApplyDefaults()
+    if (not HealBox.Damage) then HealBox.Damage = {}; end
+    for k, v in pairs(FBDamageDefaults) do
+        if (HealBox.Damage[k] == nil) then HealBox.Damage[k] = v; end
+    end
+    if (not HealBox.MobHP) then HealBox.MobHP = {}; end          -- [Name:Stufe] = { ppp, n }
+    if (not HealBox.DmgMemory) then HealBox.DmgMemory = {}; end  -- [Zauber|Rang] = gelernter Mindestschaden
+    return true;
+end
+
+-- ==========================================================================
+-- [ Zauberbuch: Raenge und Schaden ]
+-- ==========================================================================
+
+function FBDmg_ScanSpells()
+    FBDmgSpellRanks = {};
+    local wanted = {};
+    for _, n in ipairs(FBDamageSpells[FBClass] or {}) do wanted[n] = true; end
+    local i = 1;
+    while true do
+        local name, rank = GetSpellName(i, BOOKTYPE_SPELL);
+        if (not name) then break; end
+        if (wanted[name]) then
+            local txt = FBPredict_TooltipText(i) or "";
+            local lo, hi = FBPredict_FindAmountRange(txt);
+            if (not lo) then
+                lo = FBPredict_FindAmountSingle(txt);
+                hi = lo;
+            end
+            local isDamage = (string.find(txt, "[Dd]amage") or string.find(txt, "[Ss]chaden")) ~= nil;
+            if (lo and isDamage) then
+                if (not FBDmgSpellRanks[name]) then FBDmgSpellRanks[name] = {}; end
+                table.insert(FBDmgSpellRanks[name], { rank = rank or "", id = i, min = lo, max = hi });
+            end
+        end
+        i = i + 1;
+    end
+    FBDmgSlotCache = {};
+end
+
+-- Mindestschaden eines Rangs: gelernt (Treffer ohne Teilwiderstand), sonst Tooltip
+function FBDmg_MinDamage(spell, entry)
+    local learned = HealBox.DmgMemory and HealBox.DmgMemory[spell.."|"..entry.rank];
+    if (learned and learned > entry.min) then return learned; end
+    return entry.min;
+end
+
+-- ==========================================================================
+-- [ Leben des Ziels ]
+-- ==========================================================================
+
+function FBDmg_MobKey(unit)
+    local name = UnitName(unit);
+    if (not name) then return nil; end
+    local lvl = UnitLevel and UnitLevel(unit) or 0;
+    return name..":"..tostring(lvl or 0);
+end
+
+-- Sendet der Server echte Werte fuer diese Einheit?
+function FBDmg_HasRealValues(unit)
+    local max = UnitHealthMax(unit);
+    return (max and max ~= 100 and max > 0);
+end
+
+-- Liefert cur, max, source oder nil. cur ist bei Schaetzung die Obergrenze.
+function FBDmg_TargetHP(unit)
+    unit = unit or "target";
+    if (not UnitExists(unit)) then return nil; end
+    if (FBDmg_HasRealValues(unit)) then
+        return UnitHealth(unit), UnitHealthMax(unit), "real";
+    end
+    -- MobHealth3
+    if (MobHealth3 and MobHealth3.GetUnitHealth) then
+        local ok, cur, max, found = pcall(MobHealth3.GetUnitHealth, MobHealth3, unit);
+        if (ok and found and cur and max and max > 100) then return cur, max, "mh3"; end
+    end
+    -- MobInfo-2 (nur fuer das aktuelle Ziel)
+    if (unit == "target" and MobHealth_GetTargetCurHP and MobHealth_GetTargetMaxHP) then
+        local ok, cur = pcall(MobHealth_GetTargetCurHP);
+        local ok2, max = pcall(MobHealth_GetTargetMaxHP);
+        if (ok and ok2 and cur and max and max > 100) then return cur, max, "mi2"; end
+    end
+    -- eigene Schaetzung: Prozent-Obergrenze x Lebenspunkte je Prozent
+    local key = FBDmg_MobKey(unit);
+    local est = key and HealBox.MobHP and HealBox.MobHP[key];
+    if (est and est.ppp and est.ppp > 0) then
+        local pct = UnitHealth(unit) or 0;
+        return math.ceil((pct + 1) * est.ppp), math.ceil(100 * est.ppp), "est";
+    end
+    return nil;
+end
+
+-- [ Lernen: Lebenspunkte je Prozent ] ---------------------------------------
+
+function FBDmg_ResetTarget()
+    FBDmgTargetName = nil;
+    FBDmgAnchorPct  = nil;
+    FBDmgAccum      = 0;
+    if (UnitExists("target") and UnitCanAttack and UnitCanAttack("player", "target") and not FBDmg_HasRealValues("target")) then
+        FBDmgTargetName = UnitName("target");
+        FBDmgAnchorPct  = UnitHealth("target");
+    end
+    FBDmg_UpdateSourceText();
+end
+
+-- Schaden auf das Ziel vermerken (aus dem Combatlog)
+function FBDmg_NoteDamage(victim, amount)
+    if (not FBDmgTargetName) or (victim ~= FBDmgTargetName) then return; end
+    FBDmgAccum = FBDmgAccum + (amount or 0);
+end
+
+-- UNIT_HEALTH des Ziels: Prozent gefallen -> Messung
+function FBDmg_OnTargetHealth()
+    if (not FBDmgTargetName) or (not FBDmgAnchorPct) then return; end
+    if (FBDmg_HasRealValues("target")) then return; end
+    local pct = UnitHealth("target") or 0;
+    local drop = FBDmgAnchorPct - pct;
+    if (drop >= FBDMG_MIN_DROP and FBDmgAccum > 0) then
+        local ppp = FBDmgAccum / drop;
+        local key = FBDmg_MobKey("target");
+        if (key) then
+            if (not HealBox.MobHP) then HealBox.MobHP = {}; end
+            local e = HealBox.MobHP[key];
+            if (not e) then
+                HealBox.MobHP[key] = { ppp = ppp, n = 1 };
+            else
+                -- Maximum: Fehler nur nach oben (fremder, nicht gezaehlter Schaden
+                -- wuerde die Schaetzung sonst nach unten ziehen)
+                if (ppp > e.ppp) then e.ppp = ppp; end
+                e.n = (e.n or 0) + 1;
+            end
+        end
+        FBDmgAnchorPct = pct;
+        FBDmgAccum = 0;
+        FBDmg_UpdateSourceText();
+    elseif (pct > FBDmgAnchorPct) then
+        -- Ziel wurde geheilt: neu ansetzen
+        FBDmgAnchorPct = pct;
+        FBDmgAccum = 0;
+    end
+end
+
+-- [ Combatlog ] --------------------------------------------------------------
+
+-- Schadenszeilen: Opfer und Betrag herausziehen (englischer Client, wie das
+-- ganze Addon). "(N resisted)" markiert Teilwiderstand.
+function FBDmg_ParseLine(msg)
+    if (not msg) then return nil; end
+    local _, _, spell, victim, amount;
+    -- "Your Smite hits Kobold for 95." / "crits"
+    _, _, spell, victim, amount = string.find(msg, "^Your (.-) hits (.-) for (%d+)");
+    if (not spell) then _, _, spell, victim, amount = string.find(msg, "^Your (.-) crits (.-) for (%d+)"); end
+    if (spell) then return victim, tonumber(amount), spell, "self"; end
+    -- "You hit Kobold for 20." / "You crit"
+    _, _, victim, amount = string.find(msg, "^You hit (.-) for (%d+)");
+    if (not victim) then _, _, victim, amount = string.find(msg, "^You crit (.-) for (%d+)"); end
+    if (victim) then return victim, tonumber(amount), nil, "self"; end
+    -- "Kobold suffers 50 Shadow damage from your Shadow Word: Pain."
+    _, _, victim, amount = string.find(msg, "^(.-) suffers (%d+) .- damage from your");
+    if (victim) then return victim, tonumber(amount), nil, "self"; end
+    -- "Bob's Fireball hits Kobold for 200." / crits  (Gruppe, Begleiter)
+    _, _, victim, amount = string.find(msg, "^.-'s .- hits (.-) for (%d+)");
+    if (not victim) then _, _, victim, amount = string.find(msg, "^.-'s .- crits (.-) for (%d+)"); end
+    if (victim) then return victim, tonumber(amount), nil, "other"; end
+    -- "Bob hits Kobold for 50." / crits  (Nahkampf Gruppe, Begleiter)
+    _, _, victim, amount = string.find(msg, "^.- hits (.-) for (%d+)");
+    if (not victim) then _, _, victim, amount = string.find(msg, "^.- crits (.-) for (%d+)"); end
+    if (victim) then return victim, tonumber(amount), nil, "other"; end
+    return nil;
+end
+
+function FBDmg_OnCombatLog(msg)
+    -- Nur arbeiten, wenn Smart Damage an ist und es etwas zu lernen gibt
+    -- (Prozentziel wird vermessen oder ein eigener Cast wartet auf Treffer).
+    if (FBDmg_Cfg().Enabled ~= 1) then return; end
+    if (not FBDmgTargetName) and (not FBDmgLastCast) then return; end
+    local victim, amount, spell, who = FBDmg_ParseLine(msg);
+    if (not victim) then return; end
+    FBDmg_NoteDamage(victim, amount);
+    -- Mindestschaden lernen: eigener Zauber, kein Crit, kein Teilwiderstand
+    if (who == "self" and spell and FBDmgLastCast and FBDmgLastCast.spell == spell
+        and (GetTime() - FBDmgLastCast.t) <= FBDMG_LASTCAST_SEC
+        and not string.find(msg, "crits") and not string.find(msg, "resisted")) then
+        local key = spell.."|"..(FBDmgLastCast.rank or "");
+        if (not HealBox.DmgMemory) then HealBox.DmgMemory = {}; end
+        local old = HealBox.DmgMemory[key];
+        if (not old) or (amount < old) then
+            -- kleinster beobachteter Volltreffer = sicherer Mindestschaden
+            HealBox.DmgMemory[key] = amount;
+        end
+    end
+end
+
+-- ==========================================================================
+-- [ Rangwahl beim Klick ]
+-- ==========================================================================
+
+-- Zauber in einem Aktionsslot: name, rank oder nil (Makro, Gegenstand)
+function FBDmg_SlotSpell(slot)
+    local c = FBDmgSlotCache[slot];
+    if (c ~= nil) then
+        if (c == false) then return nil; end
+        return c.name, c.rank;
+    end
+    if (not FBPredictTip) or (not FBPredictTip.SetAction) then return nil; end
+    FBPredictTip:SetOwner(UIParent, "ANCHOR_NONE");
+    FBPredictTip:ClearLines();
+    FBPredictTip:SetAction(slot);
+    local l = getglobal("FBHealBoxScanTipTextLeft1");
+    local r = getglobal("FBHealBoxScanTipTextRight1");
+    local name = l and l:GetText();
+    local rank = r and r:GetText();
+    if (name and FBDmgSpellRanks[name]) then
+        FBDmgSlotCache[slot] = { name = name, rank = rank or "" };
+        return name, rank or "";
+    end
+    FBDmgSlotCache[slot] = false;
+    return nil;
+end
+
+-- Liefert den zu wirkenden Cast-String, wenn abgerangt wird, sonst nil
+function FBDmg_Choose(spell, rank)
+    local cfg = FBDmg_Cfg();
+    local ranks = FBDmgSpellRanks[spell];
+    if (not ranks) or (table.getn(ranks) < 2) then return nil; end
+    if (not UnitExists("target")) or (UnitCanAttack and not UnitCanAttack("player", "target")) then return nil; end
+    if (UnitIsDead and UnitIsDead("target")) then return nil; end
+    local cur, max, source = FBDmg_TargetHP("target");
+    if (not cur) or (cur <= 0) then return nil; end
+    local need = cur * (1 + (cfg.Margin or 20) / 100);
+
+    local assignedIdx = nil;
+    for i, e in ipairs(ranks) do
+        if (e.rank == rank) then assignedIdx = i; end
+    end
+    if (not assignedIdx) then assignedIdx = table.getn(ranks); end
+
+    for i = 1, assignedIdx do
+        local e = ranks[i];
+        if (FBDmg_MinDamage(spell, e) >= need) then
+            if (i == assignedIdx) then
+                if (FBPredictDebug) then
+                    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FFFF[FBP]|r "..format(FBT("DBG_DMG_KEEP"), spell.."("..rank..")", cur, source));
+                end
+                return nil;
+            end
+            local chosen = spell;
+            if (e.rank ~= "") then chosen = spell.."("..e.rank..")"; end
+            if (FBPredictDebug) then
+                DEFAULT_CHAT_FRAME:AddMessage("|cFF00FFFF[FBP]|r "..format(FBT("DBG_DMG"), spell.."("..rank..")", chosen, cur, source, FBDmg_MinDamage(spell, e)));
+            end
+            return chosen, e.rank;
+        end
+    end
+    return nil;
+end
+
+-- Vor-Hook auf UseAction. true, wenn das Modul selbst gecastet hat.
+function FBDmg_TryDownrank(slot, checkCursor, onSelf)
+    -- Klassensperre des Kerns (Krieger/Schurke/Jaeger ohne /fbp forceload):
+    -- die Aktionsleiste bleibt unberuehrt
+    if (FBAddonSuppressed) then return false; end
+    if (FBDmg_Cfg().Enabled ~= 1) or onSelf then return false; end
+    if ((CursorHasSpell and CursorHasSpell()) or (CursorHasItem and CursorHasItem())) then return false; end
+    local name, rank = FBDmg_SlotSpell(slot);
+    if (not name) then return false; end
+    local chosen, chosenRank = FBDmg_Choose(name, rank);
+    FBDmgLastCast = { spell = name, rank = (chosenRank or rank), t = GetTime() };
+    if (not chosen) then return false; end
+    CastSpellByName(chosen);
+    return true;
+end
+
+function FBDmg_HookUseAction()
+    if (FBHealBox_UseActionHooked) or (not UseAction) then return; end
+    FBHealBox_UseActionHooked = true;
+    local origUseAction = UseAction;
+    UseAction = function(slot, checkCursor, onSelf)
+        if (FBDmg_TryDownrank(slot, checkCursor, onSelf)) then return; end
+        origUseAction(slot, checkCursor, onSelf);
+    end
+end
+
+-- ==========================================================================
+-- [ Events ]
+-- ==========================================================================
+
+FBDmgFrame = CreateFrame("Frame", "FBHealBoxDamageFrame", UIParent);
+FBDmgFrame:RegisterEvent("PLAYER_ENTERING_WORLD");
+FBDmgFrame:RegisterEvent("SPELLS_CHANGED");
+FBDmgFrame:RegisterEvent("ACTIONBAR_SLOT_CHANGED");
+FBDmgFrame:RegisterEvent("PLAYER_TARGET_CHANGED");
+FBDmgFrame:RegisterEvent("UNIT_HEALTH");
+for _, ev in ipairs({
+    "CHAT_MSG_SPELL_SELF_DAMAGE", "CHAT_MSG_COMBAT_SELF_HITS",
+    "CHAT_MSG_SPELL_PERIODIC_CREATURE_DAMAGE", "CHAT_MSG_SPELL_PERIODIC_HOSTILEPLAYER_DAMAGE",
+    "CHAT_MSG_SPELL_PARTY_DAMAGE", "CHAT_MSG_COMBAT_PARTY_HITS",
+    "CHAT_MSG_SPELL_PET_DAMAGE", "CHAT_MSG_COMBAT_PET_HITS",
+}) do FBDmgFrame:RegisterEvent(ev); end
+
+FBDmgFrame:SetScript("OnEvent", function()
+    if (FBAddonSuppressed) then return; end
+    if (event == "PLAYER_ENTERING_WORLD" or event == "SPELLS_CHANGED") then
+        FBDmg_ScanSpells();
+        FBDmg_UpdateSpellText();
+        FBDmg_ResetTarget();
+    elseif (event == "ACTIONBAR_SLOT_CHANGED") then
+        if (arg1) then FBDmgSlotCache[arg1] = nil; else FBDmgSlotCache = {}; end
+    elseif (event == "PLAYER_TARGET_CHANGED") then
+        FBDmg_ResetTarget();
+    elseif (event == "UNIT_HEALTH") then
+        if (arg1 == "target") then FBDmg_OnTargetHealth(); FBDmg_UpdateSourceText(); end
+    else
+        FBDmg_OnCombatLog(arg1);
+    end
+end);
+
+-- ==========================================================================
+-- [ Optionen: Abschnitt im Reiter "Extras" ]
+-- ==========================================================================
+
+function FBDmg_SourceText()
+    if (not UnitExists("target")) then return FBT("DMG_SRC_NONE"); end
+    local cur, max, source = FBDmg_TargetHP("target");
+    if (source == "real") then return FBT("DMG_SRC_REAL"); end
+    if (source == "mh3") then return FBT("DMG_SRC_MH3"); end
+    if (source == "mi2") then return FBT("DMG_SRC_MI2"); end
+    if (source == "est") then
+        local n = 0;
+        for _ in pairs(HealBox.MobHP or {}) do n = n + 1; end
+        return format(FBT("DMG_SRC_EST"), n);
+    end
+    return FBT("DMG_SRC_UNKNOWN");
+end
+
+function FBDmg_UpdateSourceText()
+    -- nur, wenn das Optionsfenster offen ist (sonst je UNIT_HEALTH des Ziels umsonst)
+    if (FBDmgSourceText and panel and panel:IsVisible()) then
+        FBDmgSourceText:SetText(format(FBT("DMG_SRC"), FBDmg_SourceText()));
+    end
+end
+
+function FBDmg_UpdateSpellText()
+    if (not FBDmgSpellText) then return; end
+    local list = {};
+    for _, n in ipairs(FBDamageSpells[FBClass] or {}) do
+        if (FBDmgSpellRanks[n]) then table.insert(list, n.." ("..table.getn(FBDmgSpellRanks[n])..")"); end
+    end
+    local shown = "-";
+    if (table.getn(list) > 0) then shown = table.concat(list, ", "); end
+    FBDmgSpellText:SetText(format(FBT("DMG_SPELLS"), shown));
+end
+
+function FBDmg_UpdateMarginText()
+    if (FBDmgMarginSlider and FBDmgMarginSlider.Text) then
+        FBDmgMarginSlider.Text:SetText(format(FBT("DMG_MARGIN"), math.floor(FBDmgMarginSlider:GetValue() + 0.5)));
+    end
+end
+
+function FBDmg_BuildOptions()
+    local tab = FBHealBox_FindOptionsTab("TAB_TICKER");
+    if (not tab) then return; end
+    local y = FBOPT_CONTENT_Y - 232;   -- unter dem Ticker-Abschnitt
+
+    FBDmgHeader = tab:CreateFontString(nil, "OVERLAY", "GameFontNormal");
+    FBDmgHeader:SetPoint("TOPLEFT", tab, "TOPLEFT", 35, y);
+    FBDmgHeader:SetText(FBT("DMG_HEADER"));
+
+    FBDmgEnabledCheck = FBHealBox_CreateCheck("FBHealBoxDmgEnabledCheck", tab, 34, y - 20, "DMG_ENABLED", "DMG_ENABLED_TIP", function()
+        FBDmg_Cfg().Enabled = FBDmgEnabledCheck:GetChecked() and 1 or 0;
+    end);
+    FBDmgEnabledCheck:SetChecked(nil);
+
+    FBDmgMarginSlider = CreateFrame("Slider", "FBDmgMarginSlider", tab, "OptionsSliderTemplate");
+    FBDmgMarginSlider:SetWidth(170);
+    FBDmgMarginSlider:SetHeight(16);
+    FBDmgMarginSlider:SetPoint("TOPLEFT", 268, y - 40);
+    FBDmgMarginSlider:SetMinMaxValues(0, 50);
+    FBDmgMarginSlider:SetValueStep(5);
+    FBDmgMarginSlider:SetValue(FBDmg_Cfg().Margin or 20);
+    FBDmgMarginSlider.Text = FBDmgMarginSlider:CreateFontString(nil, "BACKGROUND", "GameFontNormal");
+    FBDmgMarginSlider.Text:SetPoint("CENTER", 0, 15);
+    getglobal("FBDmgMarginSliderLow"):SetText("0");
+    getglobal("FBDmgMarginSliderHigh"):SetText("50");
+    FBDmgMarginSlider:SetScript("OnValueChanged", function()
+        FBDmg_Cfg().Margin = math.floor(FBDmgMarginSlider:GetValue() + 0.5);
+        FBDmg_UpdateMarginText();
+    end);
+    FBDmg_UpdateMarginText();
+
+    FBDmgSourceText = tab:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall");
+    FBDmgSourceText:SetPoint("TOPLEFT", tab, "TOPLEFT", 40, y - 80);
+    FBDmgSourceText:SetWidth(390);
+    FBDmgSourceText:SetJustifyH("LEFT");
+    FBDmgSpellText = tab:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall");
+    FBDmgSpellText:SetPoint("TOPLEFT", tab, "TOPLEFT", 40, y - 96);
+    FBDmgSpellText:SetWidth(390);
+    FBDmgSpellText:SetJustifyH("LEFT");
+    FBDmgInfoText = tab:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall");
+    FBDmgInfoText:SetPoint("TOPLEFT", tab, "TOPLEFT", 35, y - 120);
+    FBDmgInfoText:SetWidth(395);
+    FBDmgInfoText:SetJustifyH("LEFT");
+    FBDmgInfoText:SetText(FBT("DMG_INFO"));
+
+    FBDmg_UpdateSourceText();
+    FBDmg_UpdateSpellText();
+    FBDmg_SyncOptions();
+    -- beim Oeffnen des Fensters die Zielzeile auffrischen (Vor-Hook auf OnShow)
+    local prevShow = panel:GetScript("OnShow");
+    panel:SetScript("OnShow", function()
+        if (prevShow) then prevShow(); end
+        FBDmg_UpdateSourceText();
+    end);
+end
+
+function FBDmg_SyncOptions()
+    local cfg = FBDmg_Cfg();
+    if (FBDmgEnabledCheck) then FBDmgEnabledCheck:SetChecked(cfg.Enabled == 1); end
+    if (FBDmgMarginSlider) then FBDmgMarginSlider:SetValue(cfg.Margin or 20); end
+    return true;
+end
+
+function FBDmg_ApplyLocale()
+    if (FBDmgHeader) then FBDmgHeader:SetText(FBT("DMG_HEADER")); end
+    if (FBDmgEnabledCheck) then FBDmgEnabledCheck.Text:SetText(FBT("DMG_ENABLED")); FBDmgEnabledCheck.tooltipText = FBT("DMG_ENABLED_TIP"); end
+    if (FBDmgInfoText) then FBDmgInfoText:SetText(FBT("DMG_INFO")); end
+    FBDmg_UpdateMarginText();
+    FBDmg_UpdateSourceText();
+    FBDmg_UpdateSpellText();
+    return true;
+end
+
+-- ==========================================================================
+-- [ Anbindung an den Kern ]
+-- ==========================================================================
+
+FBHealBox_RegisterHook("Loaded", function()
+    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT("DMG_LOADED"));
+    return true;
+end);
+FBHealBox_RegisterHook("Defaults", function() return FBDmg_ApplyDefaults(); end);
+FBHealBox_RegisterHook("SyncOptions", function() return FBDmg_SyncOptions(); end);
+FBHealBox_RegisterHook("ApplyLocale", function() return FBDmg_ApplyLocale(); end);
+FBHealBox_RegisterHook("Status", function()
+    local cfg = FBDmg_Cfg();
+    local state = FBT("FBP_STATE_OFF");
+    if (cfg.Enabled == 1) then state = FBT("FBP_STATE_ON"); end
+    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FFFF[FBP]|r "..format(FBT("DMG_STATUS"), state, cfg.Margin or 20, FBDmg_SourceText()));
+    return true;
+end);
+FBHealBox_RegisterHook("Slash", function(msg)
+    if (msg == "damage" or msg == "dmg") then
+        local cfg = FBDmg_Cfg();
+        if (cfg.Enabled == 1) then cfg.Enabled = 0; else cfg.Enabled = 1; end
+        FBDmg_SyncOptions();
+        local key = "DMG_OFF";
+        if (cfg.Enabled == 1) then key = "DMG_ON"; end
+        DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT(key));
+        return true;
+    end
+    return false;
+end);
+
+FBDmg_ApplyDefaults();
+FBDmg_BuildOptions();
+FBDmg_HookUseAction();

FBHealBox_Raid.lua

@@ -28,11 +28,16 @@ FBRAID_MAX        = 40;
 FBRAID_GROUPS     = 8;
 FBRAID_PER_GROUP  = 5;
 FBRAID_MAX_BUTTONS = 4;
-FBRAID_TICK       = 0.5;     -- Sek.: Reichweite und Sichtlinie
+FBRAID_TICK       = 0.5;     -- Sek.: voller Durchlauf Reichweite und Sichtlinie
+FBRAID_TICK_SLICES = 4;      -- in so viele Haeppchen zerlegt (je 2 Gruppen)
 FBRAID_MANA_H     = 3;       -- px Manastreifen in der Zelle
 FBRAID_LOS_SIZE   = 10;      -- px Sichtlinien-Auge in der Zelle
 FBRAID_HEADER_H   = 12;      -- px Gruppenkopf
 FBRAID_TITLE_H    = 14;      -- px Titelleiste (Griff zum Verschieben)
+FBRAID_BUFFICON_SIZE = 6;    -- px Buff-Icons aussen links an der Zelle
+FBRAID_BUFFICON_ROWS = 3;    -- Stapelhoehe (3 x 4 = 12 Plaetze)
+FBRAID_BUFFICON_COLS = 4;    -- so viele Spalten bekommen Platz zwischen den Gruppen
+FBRAID_BUFFICON_MAX  = 12;
 
 -- Vorgaben aller Raid-Einstellungen. Leben in HealBox.Raid.
 FBRaidDefaults = {
@@ -52,6 +57,7 @@ FBRaidDefaults = {
     HPText       = "percent",-- none | percent | deficit
     HideEmpty    = 1,        -- leere Gruppen ausblenden
     ShowTitle    = 1,        -- Titelleiste anzeigen
+    BuffIcons    = 1,        -- Buff-Icons links an den Zellen (aus: kein Platz reserviert)
     PosX = nil, PosY = nil,  -- Position der linken oberen Ecke (Bildschirmpixel)
 };
 
@@ -74,6 +80,8 @@ FBLocale["enUS"].RAID_HIDEEMPTY    = "Hide empty groups";
 FBLocale["enUS"].RAID_HIDEEMPTY_TIP = "Groups without members take no space. A 20-player raid then fills a single row.";
 FBLocale["enUS"].RAID_SHOWTITLE    = "Title bar";
 FBLocale["enUS"].RAID_SHOWTITLE_TIP = "A thin title bar above the grid that can be dragged. Without it, hold Shift and drag any cell.";
+FBLocale["enUS"].RAID_BUFFICONS    = "Show buffs";
+FBLocale["enUS"].RAID_BUFFICONS_TIP = "Buff icons with clock on the left of each cell, as on the party plates. Off: no icons and no room reserved for them, the groups move closer together.";
 FBLocale["enUS"].RAID_HPTEXT       = "HP text";
 FBLocale["enUS"].RAID_HPTEXT_TIP   = "What the right side of a cell shows: nothing, the health percentage, or the missing health (deficit).";
 FBLocale["enUS"].RAID_HP_NONE      = "none";
@@ -114,6 +122,8 @@ FBLocale["deDE"].RAID_HIDEEMPTY    = "Leere Gruppen ausblenden";
 FBLocale["deDE"].RAID_HIDEEMPTY_TIP = "Gruppen ohne Mitglieder brauchen keinen Platz. Ein 20er-Raid fuellt dann eine einzige Zeile.";
 FBLocale["deDE"].RAID_SHOWTITLE    = "Titelleiste";
 FBLocale["deDE"].RAID_SHOWTITLE_TIP = "Eine schmale Titelleiste ueber dem Raster, an der man ziehen kann. Ohne sie: Shift halten und eine beliebige Zelle ziehen.";
+FBLocale["deDE"].RAID_BUFFICONS    = "Buffs anzeigen";
+FBLocale["deDE"].RAID_BUFFICONS_TIP = "Buff-Icons mit Uhr links an jeder Zelle, wie auf den Gruppenplaketten. Aus: keine Icons und kein reservierter Platz, die Gruppen ruecken enger zusammen.";
 FBLocale["deDE"].RAID_HPTEXT       = "HP-Text";
 FBLocale["deDE"].RAID_HPTEXT_TIP   = "Was die rechte Seite einer Zelle zeigt: nichts, die Lebensprozente oder die fehlenden Lebenspunkte (Defizit).";
 FBLocale["deDE"].RAID_HP_NONE      = "keiner";
@@ -137,6 +147,134 @@ FBLocale["deDE"].RAID_INFO         = "Die Mini-Buttons nutzen die Zauber von But
 FBLocale["deDE"].RAID_MOVE_TIP     = "Ziehen verschiebt das Raid-Raster.";
 FBLocale["deDE"].FBP_RAID          = "Raidmodus: %s, %d Mitglieder in %d Gruppen";
 FBLocale["deDE"].FBP_RAID_CMDS     = "Raid: /fbp raid (an/aus), /fbp raidtest 20|40|off";
+
+-- Weitere Sprachen (Spanisch, Franzoesisch, Italienisch)
+
+FBLocale["esES"].TAB_RAID          = "Modo banda";
+FBLocale["esES"].RAID_TITLE        = "Banda";
+FBLocale["esES"].RAID_ENABLED      = "Modo banda";
+FBLocale["esES"].RAID_ENABLED_TIP  = "Interruptor principal de la rejilla de banda compacta: una celda por miembro, agrupadas por grupo de banda, con minibotones de curación. La rejilla aparece sola cuando tu banda tiene al menos el número de jugadores fijado abajo; las bandas más pequeñas conservan la vista de grupo.";
+FBLocale["esES"].RAID_MINPLAYERS   = "Vista de banda a partir de |cFFFFFFFF%s|r jugadores";
+FBLocale["esES"].RAID_HIDEPARTY    = "Ocultar placas de grupo";
+FBLocale["esES"].RAID_HIDEPARTY_TIP = "Mientras se muestra la rejilla de banda, las cinco placas de grupo se ocultan. Desactívalo para conservar ambas.";
+FBLocale["esES"].RAID_HEADERS      = "Cabeceras de grupo";
+FBLocale["esES"].RAID_HEADERS_TIP  = "Un pequeño número de grupo sobre cada bloque.";
+FBLocale["esES"].RAID_MANABAR      = "Franja de maná";
+FBLocale["esES"].RAID_MANABAR_TIP  = "Una franja de maná de 3 px en la parte inferior de cada celda, solo para usuarios de maná.";
+FBLocale["esES"].RAID_HIDEEMPTY    = "Ocultar grupos vacíos";
+FBLocale["esES"].RAID_HIDEEMPTY_TIP = "Los grupos sin miembros no ocupan espacio. Una banda de 20 llena entonces una sola fila.";
+FBLocale["esES"].RAID_SHOWTITLE    = "Barra de título";
+FBLocale["esES"].RAID_SHOWTITLE_TIP = "Una fina barra de título sobre la rejilla que se puede arrastrar. Sin ella, mantén Mayús y arrastra cualquier celda.";
+FBLocale["esES"].RAID_BUFFICONS    = "Mostrar beneficios";
+FBLocale["esES"].RAID_BUFFICONS_TIP = "Iconos de beneficios con reloj a la izquierda de cada celda, como en las placas de grupo. Desactivado: sin iconos ni espacio reservado, los grupos se juntan más.";
+FBLocale["esES"].RAID_HPTEXT       = "Texto de vida";
+FBLocale["esES"].RAID_HPTEXT_TIP   = "Qué muestra el lado derecho de una celda: nada, el porcentaje de vida o la vida que falta (déficit).";
+FBLocale["esES"].RAID_HP_NONE      = "nada";
+FBLocale["esES"].RAID_HP_PERCENT   = "porcentaje";
+FBLocale["esES"].RAID_HP_DEFICIT   = "déficit";
+FBLocale["esES"].RAID_GROUPSPERROW = "Grupos por fila: |cFFFFFFFF%s";
+FBLocale["esES"].RAID_SCALE        = "Escala de banda: |cFFFFFFFF%s";
+FBLocale["esES"].RAID_CELLW        = "Ancho de celda: |cFFFFFFFF%s px";
+FBLocale["esES"].RAID_CELLH        = "Alto de celda: |cFFFFFFFF%s px";
+FBLocale["esES"].RAID_BUTTONS      = "Botones por unidad: |cFFFFFFFF%s";
+FBLocale["esES"].RAID_BTNSIZE      = "Tamaño de botón: |cFFFFFFFF%s px";
+FBLocale["esES"].RAID_CELLGAP      = "Separación de celdas: |cFFFFFFFF%s px";
+FBLocale["esES"].RAID_GROUPGAP     = "Separación de grupos: |cFFFFFFFF%s px";
+FBLocale["esES"].RAID_TEST         = "Prueba de banda";
+FBLocale["esES"].RAID_TEST_TIP     = "Rellena la rejilla de banda con 20 o 40 jugadores fantasma para organizarla sin banda. No se guarda.";
+FBLocale["esES"].RAID_TEST_OFF     = "desactivada";
+FBLocale["esES"].RAID_TEST_20      = "20 jugadores";
+FBLocale["esES"].RAID_TEST_40      = "40 jugadores";
+FBLocale["esES"].RAID_TEST_CLICK   = "Prueba de banda: sin lanzamiento sobre un jugador fantasma.";
+FBLocale["esES"].RAID_INFO         = "Los minibotones usan los hechizos de los botones 1 a N de la pestaña Botones, incluidos los del clic derecho.";
+FBLocale["esES"].RAID_MOVE_TIP     = "Arrastra para mover la rejilla de banda.";
+FBLocale["esES"].FBP_RAID          = "Modo banda: %s, %d miembros en %d grupos";
+FBLocale["esES"].FBP_RAID_CMDS     = "Banda: /fbp raid (alternar), /fbp raidtest 20|40|off";
+FBLocale["esES"].RAID_LOADED       = "Módulo de modo banda cargado: pestaña |cFFFFFFFFModo banda|r en las opciones, /fbp raid, /fbp raidtest 20|40";
+
+FBLocale["frFR"].TAB_RAID          = "Mode raid";
+FBLocale["frFR"].RAID_TITLE        = "Raid";
+FBLocale["frFR"].RAID_ENABLED      = "Mode raid";
+FBLocale["frFR"].RAID_ENABLED_TIP  = "Interrupteur principal de la grille de raid compacte : une cellule par membre, regroupées par groupe de raid, avec des mini-boutons de soins. La grille apparaît d'elle-même dès que votre raid compte au moins le nombre de joueurs réglé ci-dessous ; les raids plus petits gardent l'affichage de groupe.";
+FBLocale["frFR"].RAID_MINPLAYERS   = "Vue raid à partir de |cFFFFFFFF%s|r joueurs";
+FBLocale["frFR"].RAID_HIDEPARTY    = "Masquer les plaques de groupe";
+FBLocale["frFR"].RAID_HIDEPARTY_TIP = "Tant que la grille de raid est affichée, les cinq plaques de groupe sont masquées. Désactivez pour garder les deux.";
+FBLocale["frFR"].RAID_HEADERS      = "En-têtes de groupe";
+FBLocale["frFR"].RAID_HEADERS_TIP  = "Un petit numéro de groupe au-dessus de chaque bloc.";
+FBLocale["frFR"].RAID_MANABAR      = "Bande de mana";
+FBLocale["frFR"].RAID_MANABAR_TIP  = "Une bande de mana de 3 px en bas de chaque cellule, uniquement pour les utilisateurs de mana.";
+FBLocale["frFR"].RAID_HIDEEMPTY    = "Masquer les groupes vides";
+FBLocale["frFR"].RAID_HIDEEMPTY_TIP = "Les groupes sans membres ne prennent pas de place. Un raid de 20 tient alors sur une seule ligne.";
+FBLocale["frFR"].RAID_SHOWTITLE    = "Barre de titre";
+FBLocale["frFR"].RAID_SHOWTITLE_TIP = "Une fine barre de titre au-dessus de la grille, que l'on peut faire glisser. Sans elle, maintenez Maj et faites glisser n'importe quelle cellule.";
+FBLocale["frFR"].RAID_BUFFICONS    = "Afficher les buffs";
+FBLocale["frFR"].RAID_BUFFICONS_TIP = "Icônes de buffs avec horloge à gauche de chaque cellule, comme sur les plaques de groupe. Désactivé : pas d'icônes ni d'espace réservé, les groupes se rapprochent.";
+FBLocale["frFR"].RAID_HPTEXT       = "Texte de vie";
+FBLocale["frFR"].RAID_HPTEXT_TIP   = "Ce qu'affiche le côté droit d'une cellule : rien, le pourcentage de vie ou la vie manquante (déficit).";
+FBLocale["frFR"].RAID_HP_NONE      = "rien";
+FBLocale["frFR"].RAID_HP_PERCENT   = "pourcentage";
+FBLocale["frFR"].RAID_HP_DEFICIT   = "déficit";
+FBLocale["frFR"].RAID_GROUPSPERROW = "Groupes par ligne : |cFFFFFFFF%s";
+FBLocale["frFR"].RAID_SCALE        = "Échelle du raid : |cFFFFFFFF%s";
+FBLocale["frFR"].RAID_CELLW        = "Largeur de cellule : |cFFFFFFFF%s px";
+FBLocale["frFR"].RAID_CELLH        = "Hauteur de cellule : |cFFFFFFFF%s px";
+FBLocale["frFR"].RAID_BUTTONS      = "Boutons par unité : |cFFFFFFFF%s";
+FBLocale["frFR"].RAID_BTNSIZE      = "Taille des boutons : |cFFFFFFFF%s px";
+FBLocale["frFR"].RAID_CELLGAP      = "Espacement des cellules : |cFFFFFFFF%s px";
+FBLocale["frFR"].RAID_GROUPGAP     = "Espacement des groupes : |cFFFFFFFF%s px";
+FBLocale["frFR"].RAID_TEST         = "Test de raid";
+FBLocale["frFR"].RAID_TEST_TIP     = "Remplit la grille de raid avec 20 ou 40 joueurs fantômes pour la disposer sans raid. Non sauvegardé.";
+FBLocale["frFR"].RAID_TEST_OFF     = "désactivé";
+FBLocale["frFR"].RAID_TEST_20      = "20 joueurs";
+FBLocale["frFR"].RAID_TEST_40      = "40 joueurs";
+FBLocale["frFR"].RAID_TEST_CLICK   = "Test de raid : aucun lancement sur un joueur fantôme.";
+FBLocale["frFR"].RAID_INFO         = "Les mini-boutons utilisent les sorts des boutons 1 à N de l'onglet Boutons, sorts du clic droit compris.";
+FBLocale["frFR"].RAID_MOVE_TIP     = "Faites glisser pour déplacer la grille de raid.";
+FBLocale["frFR"].FBP_RAID          = "Mode raid : %s, %d membres dans %d groupes";
+FBLocale["frFR"].FBP_RAID_CMDS     = "Raid : /fbp raid (basculer), /fbp raidtest 20|40|off";
+FBLocale["frFR"].RAID_LOADED       = "Module mode raid chargé : onglet |cFFFFFFFFMode raid|r dans les options, /fbp raid, /fbp raidtest 20|40";
+
+FBLocale["itIT"].TAB_RAID          = "Incursione";
+FBLocale["itIT"].RAID_TITLE        = "Incursione";
+FBLocale["itIT"].RAID_ENABLED      = "Modalità incursione";
+FBLocale["itIT"].RAID_ENABLED_TIP  = "Interruttore principale della griglia compatta d'incursione: una cella per membro, raggruppate per gruppo, con mini pulsanti di cura. La griglia compare da sola quando l'incursione ha almeno il numero di giocatori impostato sotto; le incursioni più piccole mantengono la vista di gruppo.";
+FBLocale["itIT"].RAID_MINPLAYERS   = "Vista incursione da |cFFFFFFFF%s|r giocatori";
+FBLocale["itIT"].RAID_HIDEPARTY    = "Nascondi targhette di gruppo";
+FBLocale["itIT"].RAID_HIDEPARTY_TIP = "Finché la griglia d'incursione è visibile, le cinque targhette di gruppo sono nascoste. Disattiva per tenerle entrambe.";
+FBLocale["itIT"].RAID_HEADERS      = "Intestazioni di gruppo";
+FBLocale["itIT"].RAID_HEADERS_TIP  = "Un piccolo numero di gruppo sopra ogni blocco.";
+FBLocale["itIT"].RAID_MANABAR      = "Striscia del mana";
+FBLocale["itIT"].RAID_MANABAR_TIP  = "Una striscia del mana di 3 px in fondo a ogni cella, solo per chi usa mana.";
+FBLocale["itIT"].RAID_HIDEEMPTY    = "Nascondi gruppi vuoti";
+FBLocale["itIT"].RAID_HIDEEMPTY_TIP = "I gruppi senza membri non occupano spazio. Un'incursione da 20 riempie allora una sola riga.";
+FBLocale["itIT"].RAID_SHOWTITLE    = "Barra del titolo";
+FBLocale["itIT"].RAID_SHOWTITLE_TIP = "Una sottile barra del titolo sopra la griglia che si può trascinare. Senza, tieni premuto Maiusc e trascina una cella qualsiasi.";
+FBLocale["itIT"].RAID_BUFFICONS    = "Mostra benefici";
+FBLocale["itIT"].RAID_BUFFICONS_TIP = "Icone dei benefici con orologio a sinistra di ogni cella, come sulle targhette di gruppo. Disattivato: niente icone né spazio riservato, i gruppi si avvicinano.";
+FBLocale["itIT"].RAID_HPTEXT       = "Testo salute";
+FBLocale["itIT"].RAID_HPTEXT_TIP   = "Cosa mostra il lato destro di una cella: niente, la percentuale di salute o la salute mancante (deficit).";
+FBLocale["itIT"].RAID_HP_NONE      = "niente";
+FBLocale["itIT"].RAID_HP_PERCENT   = "percentuale";
+FBLocale["itIT"].RAID_HP_DEFICIT   = "deficit";
+FBLocale["itIT"].RAID_GROUPSPERROW = "Gruppi per riga: |cFFFFFFFF%s";
+FBLocale["itIT"].RAID_SCALE        = "Scala dell'incursione: |cFFFFFFFF%s";
+FBLocale["itIT"].RAID_CELLW        = "Larghezza cella: |cFFFFFFFF%s px";
+FBLocale["itIT"].RAID_CELLH        = "Altezza cella: |cFFFFFFFF%s px";
+FBLocale["itIT"].RAID_BUTTONS      = "Pulsanti per unità: |cFFFFFFFF%s";
+FBLocale["itIT"].RAID_BTNSIZE      = "Dimensione pulsanti: |cFFFFFFFF%s px";
+FBLocale["itIT"].RAID_CELLGAP      = "Spaziatura celle: |cFFFFFFFF%s px";
+FBLocale["itIT"].RAID_GROUPGAP     = "Spaziatura gruppi: |cFFFFFFFF%s px";
+FBLocale["itIT"].RAID_TEST         = "Test incursione";
+FBLocale["itIT"].RAID_TEST_TIP     = "Riempie la griglia d'incursione con 20 o 40 giocatori fantasma per sistemarla senza incursione. Non viene salvato.";
+FBLocale["itIT"].RAID_TEST_OFF     = "disattivato";
+FBLocale["itIT"].RAID_TEST_20      = "20 giocatori";
+FBLocale["itIT"].RAID_TEST_40      = "40 giocatori";
+FBLocale["itIT"].RAID_TEST_CLICK   = "Test incursione: nessun lancio su un giocatore fantasma.";
+FBLocale["itIT"].RAID_INFO         = "I mini pulsanti usano gli incantesimi dei pulsanti da 1 a N della scheda Pulsanti, compresi quelli del clic destro.";
+FBLocale["itIT"].RAID_MOVE_TIP     = "Trascina per spostare la griglia d'incursione.";
+FBLocale["itIT"].FBP_RAID          = "Modalità incursione: %s, %d membri in %d gruppi";
+FBLocale["itIT"].FBP_RAID_CMDS     = "Incursione: /fbp raid (attiva/disattiva), /fbp raidtest 20|40|off";
+FBLocale["itIT"].RAID_LOADED       = "Modulo modalità incursione caricato: scheda |cFFFFFFFFModalità incursione|r nelle opzioni, /fbp raid, /fbp raidtest 20|40";
 FBLocale["deDE"].RAID_LOADED       = "Raidmodus-Modul geladen: Reiter |cFFFFFFFFRaidmodus|r in den Optionen, /fbp raid, /fbp raidtest 20|40";
 
 -- ==========================================================================
@@ -152,6 +290,7 @@ FBRaidTestMode = 0;      -- 0 | 20 | 40
 FBRaidTestGhosts = {};   -- [i] = Geist-Datensatz (Testmodus)
 FBRaidTickAccum = 0;
 FBRaidDragging  = false;
+FBRaidAppliedScale = nil;   -- zuletzt gesetzte Skalierung (FBRaid_LayoutAll)
 
 function FBRaid_Cfg()
     if (not HealBox.Raid) then FBRaid_ApplyDefaults(); end
@@ -206,11 +345,38 @@ function FBRaid_BuildTestGhosts(count)
         if (i == 13) then g.state = "offline"; end
         if (i == 18) then g.state = "ghost"; end
         if (i == 4 or i == 22) then g.debuff = true; end
+        if (i == 27) then g.debuffType = "Disease"; end
         if (i == 9 or i == 31) then g.outOfRange = true; end
         if (i == 11) then g.los = true; end
         if (i == 2 or i == 26) then g.buffMissing = true; end
         if (i == 15) then g.shield = 500; end
         if (i == 16 or i == 33) then g.inc = 800; end
+        if (i == 16) then g.aggro = true; g.hotLeft = 7; end
+        if (i == 15) then g.shieldLeft = 18; end
+        -- Buff-Icons: jeder dritte Geist traegt Seelenstaerke mit anderer Restzeit,
+        -- einer davon dazu Goettlichen Willen, einer einen fremden Buff ohne Zeit
+        if (math.mod(i, 3) == 0) then
+            local left = math.mod(i * 7, 18) * 100;   -- 0..1700 s von 1800
+            if (left < 60) then left = 60; end
+            g.buffs = { { tex = "Interface\\Icons\\Spell_Holy_WordFortitude", left = left, dur = 1800 } };
+            if (i == 6) then table.insert(g.buffs, { tex = "Interface\\Icons\\Spell_Holy_DivineSpirit", left = 1500, dur = 1800 }); end
+            if (i == 9) then g.buffs[1].left = nil; end
+            if (i == 12) then
+                -- zwoelf Buffs auf einem Geist (3 x 4), um die Darstellung zu pruefen
+                g.buffs = { { tex = "Interface\\Icons\\Spell_Holy_WordFortitude", left = 540, dur = 1800 },
+                            { tex = "Interface\\Icons\\Spell_Holy_DivineSpirit", left = 1500, dur = 1800 },
+                            { tex = "Interface\\Icons\\Spell_Shadow_AntiShadow", left = 300, dur = 600 },
+                            { tex = "Interface\\Icons\\Spell_Holy_Excorcism", left = 45, dur = 180 },
+                            { tex = "Interface\\Icons\\Spell_Nature_Regeneration", dur = 1800 },
+                            { tex = "Interface\\Icons\\Spell_Magic_MageArmor", left = 1750, dur = 1800 },
+                            { tex = "Interface\\Icons\\Spell_Holy_SealOfWisdom", left = 200, dur = 300 },
+                            { tex = "Interface\\Icons\\Spell_Holy_FistOfJustice", left = 100, dur = 300 },
+                            { tex = "Interface\\Icons\\Spell_Nature_Thorns", left = 500, dur = 600 },
+                            { tex = "Interface\\Icons\\Spell_Holy_InnerFire", left = 1200, dur = 600 },
+                            { tex = "Interface\\Icons\\Spell_Holy_SealOfSalvation", left = 900, dur = 1800 },
+                            { tex = "Interface\\Icons\\Spell_Fire_FireArmor", dur = 1800 } };
+            end
+        end
         FBRaidTestGhosts[i] = g;
     end
 end
@@ -273,8 +439,14 @@ end
 function FBRaid_Mana(cell)
     local g = cell.ghost;
     if (g) then
-        if (not g.hasMana) then return 0, 0, false; end
-        return math.floor(g.mpMax * g.mp), g.mpMax, true;
+        if (not g.hasMana) then
+            -- Wut, Energie und Fokus nur, wenn der Kern sie zeigen soll
+            if (HealBox.PowerBar == 1) and (g.power) and (g.mpMax) then
+                return math.floor(g.mpMax * (g.mp or 0)), g.mpMax, true, g.power;
+            end
+            return 0, 0, false, nil;
+        end
+        return math.floor(g.mpMax * g.mp), g.mpMax, true, 0;
     end
     return FBUnitMana(cell.unit);
 end
@@ -287,6 +459,10 @@ end
 function FBRaid_Dispel(cell)
     local g = cell.ghost;
     if (g) then
+        if (g.debuffType) then
+            if (FBDispelColors[g.debuffType]) then return g.debuffType; end
+            return nil;
+        end
         if (g.debuff) then
             for _, dtype in ipairs({ "Magic", "Poison", "Disease", "Curse" }) do
                 if (FBDispelColors[dtype]) then return dtype; end
@@ -449,17 +625,24 @@ function FBRaid_CreateCell(g, pos)
     c.ManaBar.bg:SetTexture(0, 0, 0, FBMANA_BG_ALPHA);
     c.ManaBar:Hide();
 
-    -- Texte
-    c.NameText = c:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall");
+    -- Texte liegen auf einer eigenen Ebene ueber den Balken (die Balken sind
+    -- Kind-Frames mit hoeherer Ebene und wuerden Texte der Zelle verdecken)
+    c.Overlay = CreateFrame("Frame", nil, c);
+    c.Overlay:SetAllPoints(c);
+    c.Overlay:SetFrameStrata("MEDIUM");
+    c.Overlay:SetFrameLevel(base + 6);
+    c.NameText = c.Overlay:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall");
     c.NameText:SetPoint("LEFT", c, "LEFT", 4, 0);
+    c.NameText:SetHeight(FBNAME_HEIGHT);
     c.NameText:SetJustifyH("LEFT");
-    c.HPText = c:CreateFontString(nil, "OVERLAY", "NumberFontNormalSmall");
+    c.NameText:SetJustifyV("MIDDLE");
+    c.HPText = c.Overlay:CreateFontString(nil, "OVERLAY", "NumberFontNormalSmall");
     c.HPText:SetPoint("RIGHT", c, "RIGHT", -3, 0);
     c.HPText:SetJustifyH("RIGHT");
     c.HPText:SetTextColor(1, 1, 1, 1);
 
     -- Sichtlinie: kleines Auge oben links
-    c.LOSIcon = c:CreateTexture(nil, "OVERLAY");
+    c.LOSIcon = c.Overlay:CreateTexture(nil, "OVERLAY");
     c.LOSIcon:SetWidth(FBRAID_LOS_SIZE);
     c.LOSIcon:SetHeight(FBRAID_LOS_SIZE);
     c.LOSIcon:SetPoint("TOPLEFT", c, "TOPLEFT", -3, 3);
@@ -481,15 +664,23 @@ function FBRaid_CreateCell(g, pos)
         b:SetScript("OnClick", function()
             if (FBDragSpell) then
                 local side = "L";
-                if (arg1 == "RightButton") then side = "R"; end
-                if (FBHealBox_DropSpell(i, side)) then return; end
+                if (arg1 == "RightButton" or IsShiftKeyDown()) then side = "R"; end
+                -- Nicht die Schleifenvariable i verwenden: Lua 5.0 (Client
+                -- 1.12) teilt sie zwischen allen hier erzeugten Closures, alle
+                -- vier Buttons saehen ihren Endwert und legten den Zauber
+                -- auf Button 4. b ist dagegen je Durchlauf eine neue lokale
+                -- Variable.
+                if (FBHealBox_DropSpell(b.btnIndex, side)) then return; end
             end
             if (FBRaidTestMode > 0) then
                 DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT("RAID_TEST_CLICK"));
                 return;
             end
             local castString = b.spellName;
-            if (arg1 == "RightButton") then castString = b.spellNameR; end
+            if (arg1 == "RightButton") then
+                if (HealBox.RightClick ~= 1) then return; end
+                castString = b.spellNameR;
+            end
             FBHealBox_CastOn(b, castString);
         end);
         b:Hide();
@@ -547,6 +738,7 @@ end
 -- ==========================================================================
 
 function FBRaid_UpdateRoster()
+    FBRaidRosterDirty = false;
     local cfg = FBRaid_Cfg();
     FBRaidUnitCell = {};
     FBRaidMembers = 0;
@@ -559,6 +751,8 @@ function FBRaid_UpdateRoster()
             if (FBRaidCells[g] and FBRaidCells[g][pos]) then
                 local c = FBRaidCells[g][pos];
                 c.unit = nil; c.name = nil; c.ghost = nil; c.index = nil;
+                c.dispelKnown = nil; c.lastText = nil; c.lastPct = nil; c.lastDef = nil; c.lastMax = nil; c.colorKey = nil; c.manaShown = nil; c.lastMpMax = nil; c.powerType = nil;
+                c.vHp = nil; c.vShield = nil; c.vInc = nil; c.vMp = nil;
                 c:Hide();
             end
         end
@@ -602,9 +796,9 @@ end
 -- [ Layout ]
 -- ==========================================================================
 
--- Breite einer Zelle samt ihrer Buttons
+-- Breite einer Zelle samt Buff-Streifen links und Buttons rechts
 function FBRaid_RowWidth(cfg)
-    local w = cfg.CellW;
+    local w = FBRaid_BuffStrip(cfg) + cfg.CellW;
     if (cfg.Buttons > 0) then w = w + cfg.Buttons * (cfg.ButtonSize + 1); end
     return w;
 end
@@ -639,7 +833,16 @@ function FBRaid_LayoutAll()
     local titleH = 0;
     if (cfg.ShowTitle == 1) then titleH = FBRAID_TITLE_H + 2; FBRaidFrame.Title:Show(); else FBRaidFrame.Title:Hide(); end
 
-    FBRaidFrame:SetScale(cfg.Scale or 1);
+    -- SetScale wertet die Ankerversaetze im neuen Massstab aus. Ohne erneutes
+    -- Verankern wanderte das Raster beim Ziehen am Regler und sprang erst
+    -- beim naechsten Rosterwechsel zurueck. Nur bei echter Aenderung, und
+    -- nie waehrend das Raster gerade gezogen wird.
+    local scale = cfg.Scale or 1;
+    if (FBRaidAppliedScale ~= scale) then
+        FBRaidAppliedScale = scale;
+        FBRaidFrame:SetScale(scale);
+        if (not FBRaidDragging) then FBRaid_RestorePosition(); end
+    end
 
     local perRow = cfg.GroupsPerRow;
     if (perRow < 1) then perRow = 1; end
@@ -665,12 +868,13 @@ function FBRaid_LayoutAll()
                 col * (rowW + cfg.GroupGap),
                 -(titleH + row * (blockH + cfg.GroupGap)));
             if (cfg.Headers == 1) then f.header:Show(); else f.header:Hide(); end
-            -- Zellen im Block
+            -- Zellen im Block, links davon der Streifen fuer die Buff-Icons
+            local strip = FBRaid_BuffStrip(cfg);
             for pos = 1, FBRAID_PER_GROUP do
                 local c = FBRaid_GetCell(g, pos);
                 FBRaid_ApplyCellSize(c, cfg);
                 c:ClearAllPoints();
-                c:SetPoint("TOPLEFT", f, "TOPLEFT", 0, -(headH + (pos - 1) * (cfg.CellH + cfg.CellGap)));
+                c:SetPoint("TOPLEFT", f, "TOPLEFT", strip, -(headH + (pos - 1) * (cfg.CellH + cfg.CellGap)));
             end
             f:Show();
             col = col + 1;
@@ -718,7 +922,35 @@ end
 -- [ Zelleninhalt ]
 -- ==========================================================================
 
-function FBRaid_UpdateCell(c)
+-- Zellenfarbe / Maxima / Text nur bei Aenderung setzen
+function FBRaid_SetColor(c, key, r, g, b, a)
+    if (c.colorKey == key) then return; end
+    c.colorKey = key;
+    c.HealthBar:SetStatusBarColor(r, g, b, a);
+end
+
+function FBRaid_SetValues(c, hp, shieldTop, incTop)
+    if (c.vHp ~= hp) then c.vHp = hp; c.HealthBar:SetValue(hp); end
+    if (c.vShield ~= shieldTop) then c.vShield = shieldTop; c.ShieldBar:SetValue(shieldTop); end
+    if (c.vInc ~= incTop) then c.vInc = incTop; c.IncHealBar:SetValue(incTop); end
+end
+
+function FBRaid_SetMax(c, hpMax)
+    if (c.lastMax == hpMax) then return; end
+    c.lastMax = hpMax;
+    c.HealthBar:SetMinMaxValues(0, hpMax);
+    c.ShieldBar:SetMinMaxValues(0, hpMax);
+    c.IncHealBar:SetMinMaxValues(0, hpMax);
+end
+
+function FBRaid_SetText(c, text)
+    if (c.lastText == text) then return; end
+    c.lastText = text;
+    if (text == false) then c.HPText:Hide(); else c.HPText:SetText(text); c.HPText:Show(); end
+end
+
+-- auraChanged: true bei UNIT_AURA, nur dann wird der Debuff neu gesucht
+function FBRaid_UpdateCell(c, auraChanged)
     if (not c) or (not c.unit) or (not c:IsShown()) then return; end
     local cfg = FBRaid_Cfg();
     local hp, hpMax = FBRaid_Health(c);
@@ -729,64 +961,81 @@ function FBRaid_UpdateCell(c)
         local key = "STATE_DEAD";
         if (state == "ghost") then key = "STATE_GHOST"; end
         if (state == "offline") then key = "STATE_OFFLINE"; end
-        c.HPText:SetText(FBT(key));
-        c.HPText:Show();
-        c.HealthBar:SetMinMaxValues(0, hpMax); c.HealthBar:SetValue(0);
-        c.HealthBar:SetStatusBarColor(0.5, 0.5, 0.5, 1);
-        c.ShieldBar:SetMinMaxValues(0, hpMax); c.ShieldBar:SetValue(0);
-        c.IncHealBar:SetMinMaxValues(0, hpMax); c.IncHealBar:SetValue(0);
-        c.ManaBar:Hide();
+        FBRaid_SetText(c, FBT(key));
+        c.lastPct = nil; c.lastDef = nil;   -- Zahlenspeicher gilt nicht mehr
+        FBRaid_SetMax(c, hpMax);
+        FBRaid_SetValues(c, 0, 0, 0);
+        FBRaid_SetColor(c, "state", 0.5, 0.5, 0.5, 1);
+        if (c.manaShown ~= false) then c.manaShown = false; c.ManaBar:Hide(); end
         return;
     end
 
     -- Leben und Schichten
-    c.HealthBar:SetMinMaxValues(0, hpMax);
-    c.HealthBar:SetValue(hp);
+    FBRaid_SetMax(c, hpMax);
     local inc, shield = FBRaid_Incoming(c);
-    local shieldTop = math.min(hpMax, hp + shield);
-    c.ShieldBar:SetMinMaxValues(0, hpMax);
-    c.ShieldBar:SetValue(shieldTop);
-    c.IncHealBar:SetMinMaxValues(0, hpMax);
-    c.IncHealBar:SetValue(math.min(hpMax, shieldTop + inc));
+    local shieldTop = hp + shield;
+    if (shieldTop > hpMax) then shieldTop = hpMax; end
+    local incTop = shieldTop + inc;
+    if (incTop > hpMax) then incTop = hpMax; end
+    FBRaid_SetValues(c, hp, shieldTop, incTop);
 
-    -- HP-Text
+    -- HP-Text. Verglichen wird die Zahl, nicht der fertige Text: sonst baut
+    -- jedes UNIT_HEALTH einen String, der meist sofort wieder verworfen wird.
     if (cfg.HPText == "percent") then
-        c.HPText:SetText(format("%d%%", math.floor(hp / hpMax * 100)));
-        c.HPText:Show();
+        local pct = math.floor(hp / hpMax * 100);
+        if (c.lastPct ~= pct) then
+            c.lastPct = pct; c.lastDef = nil;
+            FBRaid_SetText(c, pct.."%");
+        end
     elseif (cfg.HPText == "deficit") then
         local def = hpMax - hp;
-        if (def > 0) then c.HPText:SetText("-"..def); else c.HPText:SetText(""); end
-        c.HPText:Show();
+        if (c.lastDef ~= def) then
+            c.lastDef = def; c.lastPct = nil;
+            if (def > 0) then FBRaid_SetText(c, "-"..def); else FBRaid_SetText(c, ""); end
+        end
     else
-        c.HPText:Hide();
+        c.lastPct = nil; c.lastDef = nil;
+        FBRaid_SetText(c, false);
     end
 
     -- Mana
-    local mp, mpMax, hasMana = FBRaid_Mana(c);
+    local mp, mpMax, hasMana, ptype = FBRaid_Mana(c);
     if (cfg.ManaBar == 1 and hasMana and mpMax > 0) then
-        c.ManaBar:SetMinMaxValues(0, mpMax);
-        c.ManaBar:SetValue(mp);
-        c.ManaBar:Show();
-    else
-        c.ManaBar:Hide();
+        FBHealBox_SetPowerColor(c.ManaBar, c, ptype);
+        if (c.lastMpMax ~= mpMax) then c.lastMpMax = mpMax; c.ManaBar:SetMinMaxValues(0, mpMax); end
+        if (c.vMp ~= mp) then c.vMp = mp; c.ManaBar:SetValue(mp); end
+        if (c.manaShown ~= true) then c.manaShown = true; c.ManaBar:Show(); end
+    elseif (c.manaShown ~= false) then
+        c.manaShown = false; c.ManaBar:Hide();
     end
 
-    -- Farbe: Dispel schlaegt HP-Stand
+    -- Farbe: Dispel schlaegt HP-Stand (Debuff nur bei Aura-Aenderung neu suchen)
+    if (auraChanged or (not c.dispelKnown) or c.ghost) then
+        c.dispelType = FBRaid_Dispel(c);
+        c.dispelKnown = true;
+    end
     local frac = hp / hpMax;
-    local dtype = FBRaid_Dispel(c);
+    local dtype = c.dispelType;
     if (dtype and FBDispelColors[dtype]) then
         local col = FBDispelColors[dtype];
-        c.HealthBar:SetStatusBarColor(col[1], col[2], col[3], col[4]);
+        FBRaid_SetColor(c, dtype, col[1], col[2], col[3], col[4]);
     elseif (frac > LowHP) then
-        c.HealthBar:SetStatusBarColor(0, 1, 0, 1);
+        FBRaid_SetColor(c, "green", 0, 1, 0, 1);
     elseif (frac > VeryLowHP) then
-        c.HealthBar:SetStatusBarColor(1, 0.9, 0, 1);
+        FBRaid_SetColor(c, "yellow", 1, 0.9, 0, 1);
     else
-        c.HealthBar:SetStatusBarColor(1, 0, 0, 1);
+        FBRaid_SetColor(c, "red", 1, 0, 0, 1);
     end
 end
 
--- Rahmen: Buff-Wache (orange) oder normal
+-- Rahmen: Angegriffener (rot) vor Buff-Wache (orange) vor normal
+function FBRaid_ApplyBorder(c)
+    local col = FBBUFF_NORMAL_COLOR;
+    if (c.buffMissing) then col = FBBUFF_MISSING_COLOR; end
+    if (c.underAttack) then col = FBAGGRO_COLOR; end
+    c:SetBackdropBorderColor(col[1], col[2], col[3], col[4]);
+end
+
 function FBRaid_UpdateBuffBorder(c)
     if (not c) or (not c.unit) then return; end
     local missing = false;
@@ -795,9 +1044,127 @@ function FBRaid_UpdateBuffBorder(c)
     end
     if (c.buffMissing ~= missing) then
         c.buffMissing = missing;
-        local col = FBBUFF_NORMAL_COLOR;
-        if (missing) then col = FBBUFF_MISSING_COLOR; end
-        c:SetBackdropBorderColor(col[1], col[2], col[3], col[4]);
+        FBRaid_ApplyBorder(c);
+    end
+end
+
+-- Wer wird angegriffen (Hook "Aggro" des Kerns, tt = "targettarget" oder nil)
+function FBRaid_CheckAggro(tt)
+    if (not FBRaid_IsActive()) then return false; end
+    local any = false;
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c and c.unit) then
+                    local flag = false;
+                    if (HealBox.AggroMark == 1 and c:IsShown()) then
+                        if (c.ghost) then flag = (c.ghost.aggro == true);
+                        elseif (tt) then flag = FBHealBox_UnitIsAggroFast(c.unit, c.name, tt); end
+                    end
+                    if (c.underAttack ~= flag) then
+                        c.underAttack = flag;
+                        FBRaid_ApplyBorder(c);
+                    end
+                    if (flag) then any = true; end
+                end
+            end
+        end
+    end
+    return any;
+end
+
+-- Platz links neben jeder Zelle fuer die Buff-Icons (aussen links)
+function FBRaid_BuffStrip(cfg)
+    if (HealBox.BuffIcons ~= 1) or (cfg.BuffIcons ~= 1) then return 0; end
+    return -FBBUFFICON_XOFF + FBRAID_BUFFICON_COLS * (FBRAID_BUFFICON_SIZE + FBBUFFICON_GAP);
+end
+
+-- Buff-Icons mit Uhr aussen links an den Zellen (Hook "BuffIcons")
+function FBRaid_UpdateBuffIcons()
+    if (not FBRaid_IsActive()) then return; end
+    local on = (FBRaid_Cfg().BuffIcons == 1);
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c) then
+                    if (on and c.unit and c:IsShown()) then
+                        FBHealBox_UpdateBuffIcons(c, c.name, c.ghost, FBRAID_BUFFICON_SIZE, FBRAID_BUFFICON_ROWS, FBRAID_BUFFICON_MAX);
+                    else
+                        FBHealBox_UpdateBuffIcons(c, nil, nil, FBRAID_BUFFICON_SIZE, FBRAID_BUFFICON_ROWS, FBRAID_BUFFICON_MAX);
+                    end
+                end
+            end
+        end
+    end
+end
+
+-- HoT-/Schild-Timer auf den Mini-Buttons (Hook "SpellTimers")
+function FBRaid_UpdateSpellTimers(now)
+    local on = (HealBox.SpellTimers == 1) and FBRaid_IsActive();
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c) then
+                    local shown = on and c.unit and c:IsShown() and (c.ghost or FBHoTs[c.name] or FBShields[c.name]
+                        or (FBWeakenedSoul and FBWeakenedSoul[c.name]));
+                    -- Nichts anzuzeigen und nichts mehr wegzuraeumen: Zelle
+                    -- ueberspringen. Vorher lief die Buttonschleife auch dann
+                    -- durch, im Vierzigerraid 160 Leeraufrufe fuenfmal je
+                    -- Sekunde. Der Kern macht es bei den Plaketten genauso.
+                    if (shown or c.timersShown) then
+                        c.timersShown = (shown and true) or false;
+                        for i = 1, FBRAID_MAX_BUTTONS do
+                            local b = c.buttons[i];
+                            if (shown and b:IsShown()) then
+                                local text, color = FBHealBox_SpellTimerFor(b.spellBase, c.name, now, c.ghost, i);
+                                if (not text and b.spellBaseR) then
+                                    text, color = FBHealBox_SpellTimerFor(b.spellBaseR, c.name, now, nil, i);
+                                end
+                                FBHealBox_SetButtonTimer(b, text, color);
+                            else
+                                FBHealBox_SetButtonTimer(b, nil);
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+
+function FBRaid_UpdateCooldowns()
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c) then
+                    for i = 1, FBRAID_MAX_BUTTONS do
+                        local b = c.buttons[i];
+                        b.cdKey = nil;
+                        FBHealBox_UpdateButtonState(b, "SPELL_UPDATE_COOLDOWN");
+                    end
+                end
+            end
+        end
+    end
+end
+
+-- Button-Zustaende der sichtbaren Zellen (Hook "ButtonStates")
+function FBRaid_UpdateButtonStates(event)
+    if (not FBRaid_IsActive()) then return; end
+    local nBtn = FBRaid_Cfg().Buttons or 0;
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c and c.unit and c:IsShown()) then
+                    for i = 1, nBtn do FBHealBox_UpdateButtonState(c.buttons[i], event); end
+                end
+            end
+        end
     end
 end
 
@@ -845,11 +1212,9 @@ function FBRaid_SyncButtons()
                         if (rightOn) then
                             b.spellNameR = FBDropDownButtonR[i];
                             b.idR = FBActiveSpellIDsR[i];
-                            b:RegisterForClicks("LeftButtonUp", "RightButtonUp");
                         else
                             b.spellNameR = nil;
                             b.idR = nil;
-                            b:RegisterForClicks("LeftButtonUp");
                         end
                         if (b.subIcon) then
                             if (b.spellNameR and FBDropDownButtonIconR[i]) then
@@ -859,6 +1224,10 @@ function FBRaid_SyncButtons()
                                 b.subIcon:Hide();
                             end
                         end
+                        b.cdKey = nil;
+                        b.colorState = nil;
+                        if (b.spellName) then b.spellBase = FBPredict_SplitCast(b.spellName); else b.spellBase = nil; end
+                        if (b.spellNameR) then b.spellBaseR = FBPredict_SplitCast(b.spellNameR); else b.spellBaseR = nil; end
                     end
                 end
             end
@@ -867,10 +1236,30 @@ function FBRaid_SyncButtons()
 end
 
 -- Reichweite, Sichtlinie und Geister-Atmung im Takt
+-- Reichweite und Sichtlinie kosten je Zelle einen Aufruf ins Spiel hinein.
+-- Bei acht Gruppen waeren das in einem Rutsch bis zu 80 Abfragen in einem
+-- einzigen Frame. Deshalb wandert der Durchlauf in Haeppchen: je Tick nur
+-- ein Teil der Gruppen, nach FBRAID_TICK_SLICES Ticks sind alle einmal dran.
+-- Die Taktdauer ist entsprechend kuerzer, der volle Durchlauf dauert also
+-- weiterhin FBRAID_TICK Sekunden. force = true macht alles auf einmal.
+FBRaidTickSlice = 0;
+
+-- Der Durchlauf laeuft geschuetzt, aber nur einmal je Tick statt einmal je
+-- Zelle: im Vierzigerraid ein pcall alle 0,125 Sekunden statt achtzig je
+-- Sekunde. Wirft eine Abfrage doch, gehen die Direktaufrufe zurueck in den
+-- geschuetzten Einzelaufruf und der Rueckfallweg greift wieder.
 function FBRaid_Tick(force)
     if (not FBRaid_IsActive()) then return; end
+    local slice = FBRaidTickSlice;
+    FBRaidTickSlice = math.mod(FBRaidTickSlice + 1, FBRAID_TICK_SLICES);
+    if (not pcall(FBRaid_TickSweep, slice, force)) then
+        if (FBHealBox_ApiFailed) then FBHealBox_ApiFailed(); end
+    end
+end
+
+function FBRaid_TickSweep(slice, force)
     for g = 1, FBRAID_GROUPS do
-        if (FBRaidCells[g]) then
+        if (FBRaidCells[g]) and (force or (math.mod(g - 1, FBRAID_TICK_SLICES) == slice)) then
             for pos = 1, FBRAID_PER_GROUP do
                 local c = FBRaidCells[g][pos];
                 if (c and c.unit and c:IsShown()) then
@@ -907,23 +1296,32 @@ FBRaidEventFrame:RegisterEvent("UNIT_MAXMANA");
 FBRaidEventFrame:RegisterEvent("UNIT_DISPLAYPOWER");
 FBRaidEventFrame:RegisterEvent("UNIT_AURA");
 
+FBRaidRosterDirty = false;
+
 FBRaidEventFrame:SetScript("OnEvent", function()
+    if (FBAddonSuppressed) then return; end
     if (event == "RAID_ROSTER_UPDATE" or event == "PARTY_MEMBERS_CHANGED" or event == "PLAYER_ENTERING_WORLD") then
-        FBRaid_UpdateRoster();
-        FBRaid_SyncButtons();
-        FBRaid_RefreshBuffBorders();
+        -- Salven (mehrere Roster-Events je Frame beim Zonen) auf einen
+        -- Durchlauf im naechsten Frame zusammenfassen
+        FBRaidRosterDirty = true;
         return;
     end
     if (FBRaidTestMode > 0) then return; end
     local c = FBRaidUnitCell[arg1];
     if (not c) then return; end
-    FBRaid_UpdateCell(c);
+    FBRaid_UpdateCell(c, (event == "UNIT_AURA"));
     if (event == "UNIT_AURA") then FBRaid_UpdateBuffBorder(c); end
 end);
 
 FBRaidEventFrame:SetScript("OnUpdate", function()
+    if (FBAddonSuppressed) then return; end
+    if (FBRaidRosterDirty) then
+        FBRaidRosterDirty = false;
+        FBRaid_UpdateRoster();
+        FBRaid_RefreshBuffBorders();
+    end
     FBRaidTickAccum = FBRaidTickAccum + (arg1 or 0);
-    if (FBRaidTickAccum < FBRAID_TICK) then return; end
+    if (FBRaidTickAccum < (FBRAID_TICK / FBRAID_TICK_SLICES)) then return; end
     FBRaidTickAccum = 0;
     FBRaid_Tick(false);
 end);
@@ -932,8 +1330,9 @@ end);
 -- fuer den Raid-Test haengen wir uns an denselben Takt und fordern ihn an.
 FBRaidGhostAccum = 0;
 FBRaidEventFrame.ghostTicker = CreateFrame("Frame", nil, UIParent);
+FBRaidEventFrame.ghostTicker:Hide();   -- laeuft nur im Raid-Test (siehe FBRaid_SetTest)
 FBRaidEventFrame.ghostTicker:SetScript("OnUpdate", function()
-    if (FBRaidTestMode == 0) then return; end
+    if (FBAddonSuppressed) then return; end
     FBRaidGhostAccum = FBRaidGhostAccum + (arg1 or 0);
     if (FBRaidGhostAccum < 0.2) then return; end
     FBRaidGhostAccum = 0;
@@ -951,6 +1350,8 @@ function FBRaid_SetTest(mode)
     mode = tonumber(mode) or 0;
     if (mode ~= 20 and mode ~= 40) then mode = 0; end
     FBRaidTestMode = mode;
+    -- Geister-Atmung nur im Test rechnen lassen
+    if (mode > 0) then FBRaidEventFrame.ghostTicker:Show(); else FBRaidEventFrame.ghostTicker:Hide(); end
     if (mode > 0) then
         FBRaid_BuildTestGhosts(mode);
         if (HealBox.Active ~= 1) then HealBox.Active = 1; end
@@ -1052,9 +1453,14 @@ function FBRaid_BuildOptions()
         FBRaid_Cfg().ShowTitle = FBRaidTitleCheck:GetChecked() and 1 or 0;
         FBRaid_LayoutAll();
     end);
+    FBRaidBuffIconsCheck = FBHealBox_CreateCheck("FBHealBoxRaidBuffIconsCheck", tab, 40, y - 90, "RAID_BUFFICONS", "RAID_BUFFICONS_TIP", function()
+        FBRaid_Cfg().BuffIcons = FBRaidBuffIconsCheck:GetChecked() and 1 or 0;
+        FBRaid_LayoutAll();
+        FBRaid_UpdateBuffIcons();
+    end);
 
     -- HP-Text: Auswahlknopf mit Kaskadenmenue
-    FBRaidHPTextBtn = FBHealBox_CreatePickButton("FBHealBoxRaidHPTextBtn", tab, 35, y - 96, 180, 26, 18);
+    FBRaidHPTextBtn = FBHealBox_CreatePickButton("FBHealBoxRaidHPTextBtn", tab, 35, y - 126, 180, 26, 18);
     FBRaidHPTextBtn.icon:SetTexture("Interface\\Icons\\INV_Misc_Note_01");
     FBRaidHPTextBtn:SetScript("OnEnter", function()
         GameTooltip:SetOwner(this, "ANCHOR_RIGHT");
@@ -1084,7 +1490,7 @@ function FBRaid_BuildOptions()
     end);
 
     -- Raid-Test: aus / 20 / 40
-    FBRaidTestBtn = FBHealBox_CreatePickButton("FBHealBoxRaidTestBtn", tab, 245, y - 96, 180, 26, 18);
+    FBRaidTestBtn = FBHealBox_CreatePickButton("FBHealBoxRaidTestBtn", tab, 245, y - 126, 180, 26, 18);
     FBRaidTestBtn.icon:SetTexture("Interface\\Icons\\Spell_Shadow_Twilight");
     FBRaidTestBtn:SetScript("OnEnter", function()
         GameTooltip:SetOwner(this, "ANCHOR_RIGHT");
@@ -1111,7 +1517,7 @@ function FBRaid_BuildOptions()
     end);
 
     -- Schieberegler (Beschriftung sitzt ueber dem Regler)
-    local sy = y - 150;
+    local sy = y - 180;
     FBRaid_CreateSlider("FBRaidGroupsPerRowSlider", tab, 75, sy, "RAID_GROUPSPERROW", "GroupsPerRow", 1, 8, 1, false, FBRaid_LayoutAll);
     FBRaid_CreateSlider("FBRaidScaleSlider", tab, 260, sy, "RAID_SCALE", "Scale", 0.5, 1.5, 0.1, true, FBRaid_LayoutAll);
     FBRaid_CreateSlider("FBRaidCellWSlider", tab, 75, sy - 50, "RAID_CELLW", "CellW", 50, 120, 1, false, FBRaid_LayoutAll);
@@ -1141,6 +1547,7 @@ function FBRaid_SyncOptions()
     if (FBRaidManaCheck) then FBRaidManaCheck:SetChecked(cfg.ManaBar == 1); end
     if (FBRaidHideEmptyCheck) then FBRaidHideEmptyCheck:SetChecked(cfg.HideEmpty == 1); end
     if (FBRaidTitleCheck) then FBRaidTitleCheck:SetChecked(cfg.ShowTitle == 1); end
+    if (FBRaidBuffIconsCheck) then FBRaidBuffIconsCheck:SetChecked(cfg.BuffIcons == 1); end
     for key, s in pairs(FBRaidSliders) do
         if (cfg[key] ~= nil) then s:SetValue(cfg[key]); end
     end
@@ -1156,6 +1563,7 @@ function FBRaid_ApplyLocale()
     if (FBRaidManaCheck) then FBRaidManaCheck.Text:SetText(FBT("RAID_MANABAR")); FBRaidManaCheck.tooltipText = FBT("RAID_MANABAR_TIP"); end
     if (FBRaidHideEmptyCheck) then FBRaidHideEmptyCheck.Text:SetText(FBT("RAID_HIDEEMPTY")); FBRaidHideEmptyCheck.tooltipText = FBT("RAID_HIDEEMPTY_TIP"); end
     if (FBRaidTitleCheck) then FBRaidTitleCheck.Text:SetText(FBT("RAID_SHOWTITLE")); FBRaidTitleCheck.tooltipText = FBT("RAID_SHOWTITLE_TIP"); end
+    if (FBRaidBuffIconsCheck) then FBRaidBuffIconsCheck.Text:SetText(FBT("RAID_BUFFICONS")); FBRaidBuffIconsCheck.tooltipText = FBT("RAID_BUFFICONS_TIP"); end
     if (FBRaidInfoText) then FBRaidInfoText:SetText(FBT("RAID_INFO")); end
     for _, s in pairs(FBRaidSliders) do FBRaid_SliderText(s); end
     FBRaid_UpdateHPTextLabel();
@@ -1172,6 +1580,11 @@ FBHealBox_RegisterHook("Loaded", function()
     DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT("RAID_LOADED"));
     return true;
 end);
+-- Klassensperre des Kerns: Raidfenster mit stilllegen
+FBHealBox_RegisterHook("Suppress", function()
+    if (FBRaidFrame) then FBRaidFrame:Hide(); end
+    return true;
+end);
 FBHealBox_RegisterHook("Defaults", function() return FBRaid_ApplyDefaults(); end);
 FBHealBox_RegisterHook("SyncOptions", function() return FBRaid_SyncOptions(); end);
 FBHealBox_RegisterHook("ApplyLocale", function() return FBRaid_ApplyLocale(); end);
@@ -1189,6 +1602,22 @@ FBHealBox_RegisterHook("ActiveToggle", function()
     FBRaid_UpdateVisibility();
     return true;
 end);
+-- Nur die Zellen anfassen, deren Einheit sich geaendert hat. Der Kern
+-- schickt die Namensliste mit; eine Zelle, die nicht drinsteht, kostet
+-- einen Tabellenzugriff statt einer vollen Aktualisierung.
+FBHealBox_RegisterHook("RefreshNames", function(names)
+    if (not FBRaid_IsActive()) or (not names) then return true; end
+    for g = 1, FBRAID_GROUPS do
+        if (FBRaidCells[g]) then
+            for pos = 1, FBRAID_PER_GROUP do
+                local c = FBRaidCells[g][pos];
+                if (c and c.unit and c.name and names[c.name]) then FBRaid_UpdateCell(c); end
+            end
+        end
+    end
+    return true;
+end);
+
 FBHealBox_RegisterHook("RefreshAllBars", function()
     FBRaid_RefreshAll();
     return true;
@@ -1197,6 +1626,11 @@ FBHealBox_RegisterHook("ButtonsChanged", function()
     FBRaid_SyncButtons();
     return true;
 end);
+FBHealBox_RegisterHook("Aggro", function(tt) return FBRaid_CheckAggro(tt); end);
+FBHealBox_RegisterHook("SpellTimers", function(now) FBRaid_UpdateSpellTimers(now); return true; end);
+FBHealBox_RegisterHook("Cooldowns", function() FBRaid_UpdateCooldowns(); return true; end);
+FBHealBox_RegisterHook("ButtonStates", function(ev) FBRaid_UpdateButtonStates(ev); return true; end);
+FBHealBox_RegisterHook("BuffIcons", function() FBRaid_UpdateBuffIcons(); return true; end);
 FBHealBox_RegisterHook("Status", function()
     local cfg = FBRaid_Cfg();
     local state = FBT("FBP_STATE_OFF");

FBHealBox_Ticker.lua

@@ -0,0 +1,597 @@
+-- ==========================================================================
+-- Heal Box Vanilla: Mana-Ticker (Modul, ab v1.4.3)
+--
+-- Ein Funke wandert ueber den Manastreifen der eigenen Plakette (und der
+-- eigenen Raid-Zelle) und zeigt den 2-Sekunden-Regenerationstick des
+-- Servers. Nach jedem Manaverbrauch laeuft er orange ueber die
+-- 5-Sekunden-Regel, verlaengert bis zum ersten Tick nach deren Ablauf,
+-- denn erst dort setzt die Regeneration wieder ein.
+--
+-- Erkennung ohne Combatlog und ohne SuperWoW:
+--   * UNIT_MANA fuer "player": Mana gestiegen = Tick-Kandidat,
+--     Mana gesunken = Zauber hat gekostet, Regel startet.
+--   * Das Tickraster ist serverseitig fest (2 s). Der letzte erkannte Tick
+--     wird gemerkt, weitere werden extrapoliert (auch bei vollem Mana),
+--     jeder passende echte Tick synchronisiert neu.
+--   * Kandidaten ausserhalb der Toleranz um den erwarteten Zeitpunkt
+--     (Manaquelle-Totem, Innervate-Pulse) werden verworfen; erst nach
+--     mehreren Fehlschlaegen in Folge wird ein neues Raster angenommen.
+--     Grosse Spruenge (Traenke, Runen) zaehlen nie als Tick.
+--
+-- Bei vollem Mana ist der Funke aus (nichts zu regenerieren).
+-- Haengt sich wie der Raidmodus nur ueber die Hook-Schnittstelle ein.
+-- ==========================================================================
+
+if (FBHealBox_TickerLoaded) then return; end
+FBHealBox_TickerLoaded = true;
+
+FBTICK_PERIOD      = 2.0;    -- Sek. zwischen zwei Regenerationsticks
+FBTICK_FSR         = 5.0;    -- Sek. Fuenf-Sekunden-Regel
+FBTICK_RESYNC_MISS = 3;      -- so viele Kandidaten ausserhalb der Toleranz -> neues Raster
+FBTICK_POTION_FACT = 4;      -- Zuwachs groesser als das Vielfache der Tickgroesse = Trank
+FBTICK_POTION_MIN  = 300;    -- ... und mindestens so viel Mana
+
+FBTICK_COLOR_TICK  = { 1.00, 1.00, 1.00, 0.95 };   -- Funke im Tickzyklus
+FBTICK_COLOR_FSR   = { 1.00, 0.55, 0.10, 1.00 };   -- Funke waehrend der Regel
+
+FBTickerDefaults = {
+    Enabled   = 1,      -- Ticker an/aus
+    FSR       = 1,      -- 5-Sekunden-Regel anzeigen
+    Tolerance = 0.3,    -- Sek. Toleranz um den erwarteten Tick
+    Offset    = 0.0,    -- Sek. Vorlauf (Latenzausgleich): Funke laeuft frueher los
+    SparkW    = 2,      -- px Funkenbreite
+};
+
+-- ==========================================================================
+-- [ Texte ]
+-- ==========================================================================
+
+FBLocale["enUS"].TAB_TICKER        = "Extras";
+FBLocale["enUS"].TICK_HEADER       = "Mana ticker";
+FBLocale["enUS"].TICK_ENABLED      = "Mana ticker";
+FBLocale["enUS"].TICK_ENABLED_TIP  = "A spark travels across your own mana bar every 2 seconds, in step with the server's mana regeneration tick. Cast right after the spark reaches the end and you lose no regeneration. Needs the mana bar to be on.";
+FBLocale["enUS"].TICK_FSR          = "Five-second rule";
+FBLocale["enUS"].TICK_FSR_TIP      = "After you spend mana the spark turns orange and runs over the five seconds (plus the wait for the next tick) until spirit regeneration resumes.";
+FBLocale["enUS"].TICK_TOLERANCE    = "Tick tolerance: |cFFFFFFFF%s s";
+FBLocale["enUS"].TICK_OFFSET       = "Tick offset: |cFFFFFFFF%s s";
+FBLocale["enUS"].TICK_SPARKW       = "Spark width: |cFFFFFFFF%s px";
+FBLocale["enUS"].TICK_INFO         = "White spark: time until the next regeneration tick. Orange spark: five-second rule running, regeneration resumes when it reaches the end. Raise the tolerance if ticks are missed (totems, Innervate); use the offset if the spark arrives late compared to your mana jumps.";
+FBLocale["enUS"].TICK_STATUS       = "Ticker: %s, next tick in %.1f s%s";
+FBLocale["enUS"].TICK_SYNCED       = "synced";
+FBLocale["enUS"].TICK_UNSYNCED     = "waiting for first tick";
+FBLocale["enUS"].TICK_STATUS_FSR   = ", five-second rule %.1f s";
+FBLocale["enUS"].TICK_LOADED       = "Mana ticker module loaded: tab |cFFFFFFFFTicker|r in the options, /fbp ticker";
+FBLocale["enUS"].TICK_ON           = "Mana ticker |cFF00FF00on|r.";
+FBLocale["enUS"].TICK_OFF          = "Mana ticker |cFFFF0000off|r.";
+
+FBLocale["deDE"].TAB_TICKER        = "Extras";
+FBLocale["deDE"].TICK_HEADER       = "Mana-Ticker";
+FBLocale["deDE"].TICK_ENABLED      = "Mana-Ticker";
+FBLocale["deDE"].TICK_ENABLED_TIP  = "Ein Funke wandert alle 2 Sekunden ueber deinen eigenen Manastreifen, im Takt des Regenerationsticks des Servers. Wer direkt nach dem Funken am Ende castet, verliert keine Regeneration. Braucht den eingeschalteten Manabalken.";
+FBLocale["deDE"].TICK_FSR          = "Fuenf-Sekunden-Regel";
+FBLocale["deDE"].TICK_FSR_TIP      = "Nach jedem Manaverbrauch wird der Funke orange und laeuft ueber die fuenf Sekunden (plus Wartezeit bis zum naechsten Tick), bis die Willenskraft-Regeneration wieder einsetzt.";
+FBLocale["deDE"].TICK_TOLERANCE    = "Tick-Toleranz: |cFFFFFFFF%s s";
+FBLocale["deDE"].TICK_OFFSET       = "Tick-Vorlauf: |cFFFFFFFF%s s";
+
+-- Weitere Sprachen (Spanisch, Franzoesisch, Italienisch)
+
+FBLocale["esES"].TAB_TICKER        = "Extras";
+FBLocale["esES"].TICK_HEADER       = "Ticker de maná";
+FBLocale["esES"].TICK_ENABLED      = "Ticker de maná";
+FBLocale["esES"].TICK_ENABLED_TIP  = "Una chispa recorre tu propia barra de maná cada 2 segundos, al compás del pulso de regeneración de maná del servidor. Lanza justo después de que la chispa llegue al final y no perderás regeneración. Requiere la barra de maná activada.";
+FBLocale["esES"].TICK_FSR          = "Regla de los cinco segundos";
+FBLocale["esES"].TICK_FSR_TIP      = "Tras gastar maná, la chispa se vuelve naranja y recorre los cinco segundos (más la espera hasta el siguiente pulso) hasta que la regeneración por espíritu se reanuda.";
+FBLocale["esES"].TICK_TOLERANCE    = "Tolerancia del pulso: |cFFFFFFFF%s s";
+FBLocale["esES"].TICK_OFFSET       = "Desfase del pulso: |cFFFFFFFF%s s";
+FBLocale["esES"].TICK_SPARKW       = "Ancho de la chispa: |cFFFFFFFF%s px";
+FBLocale["esES"].TICK_INFO         = "Chispa blanca: tiempo hasta el siguiente pulso de regeneración. Chispa naranja: regla de los cinco segundos en curso, la regeneración se reanuda cuando llega al final. Sube la tolerancia si se pierden pulsos (tótems, Estimular); usa el desfase si la chispa llega tarde respecto a tus saltos de maná.";
+FBLocale["esES"].TICK_STATUS       = "Ticker: %s, siguiente pulso en %.1f s%s";
+FBLocale["esES"].TICK_SYNCED       = "sincronizado";
+FBLocale["esES"].TICK_UNSYNCED     = "esperando el primer pulso";
+FBLocale["esES"].TICK_STATUS_FSR   = ", regla de los cinco segundos %.1f s";
+FBLocale["esES"].TICK_LOADED       = "Módulo de ticker de maná cargado: pestaña |cFFFFFFFFExtras|r en las opciones, /fbp ticker";
+FBLocale["esES"].TICK_ON           = "Ticker de maná |cFF00FF00activado|r.";
+FBLocale["esES"].TICK_OFF          = "Ticker de maná |cFFFF0000desactivado|r.";
+
+FBLocale["frFR"].TAB_TICKER        = "Extras";
+FBLocale["frFR"].TICK_HEADER       = "Ticker de mana";
+FBLocale["frFR"].TICK_ENABLED      = "Ticker de mana";
+FBLocale["frFR"].TICK_ENABLED_TIP  = "Une étincelle parcourt votre propre barre de mana toutes les 2 secondes, au rythme du tick de régénération de mana du serveur. Lancez juste après que l'étincelle atteint la fin et vous ne perdez aucune régénération. Nécessite la barre de mana activée.";
+FBLocale["frFR"].TICK_FSR          = "Règle des cinq secondes";
+FBLocale["frFR"].TICK_FSR_TIP      = "Après une dépense de mana, l'étincelle devient orange et parcourt les cinq secondes (plus l'attente du prochain tick) jusqu'à la reprise de la régénération par l'esprit.";
+FBLocale["frFR"].TICK_TOLERANCE    = "Tolérance du tick : |cFFFFFFFF%s s";
+FBLocale["frFR"].TICK_OFFSET       = "Décalage du tick : |cFFFFFFFF%s s";
+FBLocale["frFR"].TICK_SPARKW       = "Largeur de l'étincelle : |cFFFFFFFF%s px";
+FBLocale["frFR"].TICK_INFO         = "Étincelle blanche : temps jusqu'au prochain tick de régénération. Étincelle orange : règle des cinq secondes en cours, la régénération reprend quand elle atteint la fin. Augmentez la tolérance si des ticks sont manqués (totems, Innervation) ; utilisez le décalage si l'étincelle arrive en retard par rapport à vos sauts de mana.";
+FBLocale["frFR"].TICK_STATUS       = "Ticker : %s, prochain tick dans %.1f s%s";
+FBLocale["frFR"].TICK_SYNCED       = "synchronisé";
+FBLocale["frFR"].TICK_UNSYNCED     = "en attente du premier tick";
+FBLocale["frFR"].TICK_STATUS_FSR   = ", règle des cinq secondes %.1f s";
+FBLocale["frFR"].TICK_LOADED       = "Module ticker de mana chargé : onglet |cFFFFFFFFExtras|r dans les options, /fbp ticker";
+FBLocale["frFR"].TICK_ON           = "Ticker de mana |cFF00FF00activé|r.";
+FBLocale["frFR"].TICK_OFF          = "Ticker de mana |cFFFF0000désactivé|r.";
+
+FBLocale["itIT"].TAB_TICKER        = "Extra";
+FBLocale["itIT"].TICK_HEADER       = "Ticker del mana";
+FBLocale["itIT"].TICK_ENABLED      = "Ticker del mana";
+FBLocale["itIT"].TICK_ENABLED_TIP  = "Una scintilla attraversa la tua barra del mana ogni 2 secondi, a tempo con il tick di rigenerazione del mana del server. Lancia subito dopo che la scintilla arriva in fondo e non perdi rigenerazione. Richiede la barra del mana attiva.";
+FBLocale["itIT"].TICK_FSR          = "Regola dei cinque secondi";
+FBLocale["itIT"].TICK_FSR_TIP      = "Dopo aver speso mana la scintilla diventa arancione e percorre i cinque secondi (più l'attesa del tick successivo) finché la rigenerazione da spirito riprende.";
+FBLocale["itIT"].TICK_TOLERANCE    = "Tolleranza del tick: |cFFFFFFFF%s s";
+FBLocale["itIT"].TICK_OFFSET       = "Anticipo del tick: |cFFFFFFFF%s s";
+FBLocale["itIT"].TICK_SPARKW       = "Larghezza scintilla: |cFFFFFFFF%s px";
+FBLocale["itIT"].TICK_INFO         = "Scintilla bianca: tempo al prossimo tick di rigenerazione. Scintilla arancione: regola dei cinque secondi in corso, la rigenerazione riprende quando arriva in fondo. Alza la tolleranza se i tick vengono persi (totem, Innervazione); usa l'anticipo se la scintilla arriva in ritardo rispetto ai tuoi salti di mana.";
+FBLocale["itIT"].TICK_STATUS       = "Ticker: %s, prossimo tick tra %.1f s%s";
+FBLocale["itIT"].TICK_SYNCED       = "sincronizzato";
+FBLocale["itIT"].TICK_UNSYNCED     = "in attesa del primo tick";
+FBLocale["itIT"].TICK_STATUS_FSR   = ", regola dei cinque secondi %.1f s";
+FBLocale["itIT"].TICK_LOADED       = "Modulo ticker del mana caricato: scheda |cFFFFFFFFExtra|r nelle opzioni, /fbp ticker";
+FBLocale["itIT"].TICK_ON           = "Ticker del mana |cFF00FF00attivo|r.";
+FBLocale["itIT"].TICK_OFF          = "Ticker del mana |cFFFF0000disattivato|r.";
+FBLocale["deDE"].TICK_SPARKW       = "Funkenbreite: |cFFFFFFFF%s px";
+FBLocale["deDE"].TICK_INFO         = "Weisser Funke: Zeit bis zum naechsten Regenerationstick. Oranger Funke: Fuenf-Sekunden-Regel laeuft, am Ende setzt die Regeneration wieder ein. Toleranz erhoehen, wenn Ticks verpasst werden (Totems, Anregen); Vorlauf nutzen, wenn der Funke spaeter ankommt als deine Manaspruenge.";
+FBLocale["deDE"].TICK_STATUS       = "Ticker: %s, naechster Tick in %.1f s%s";
+FBLocale["deDE"].TICK_SYNCED       = "synchron";
+FBLocale["deDE"].TICK_UNSYNCED     = "wartet auf ersten Tick";
+FBLocale["deDE"].TICK_STATUS_FSR   = ", Fuenf-Sekunden-Regel %.1f s";
+FBLocale["deDE"].TICK_LOADED       = "Mana-Ticker-Modul geladen: Reiter |cFFFFFFFFTicker|r in den Optionen, /fbp ticker";
+FBLocale["deDE"].TICK_ON           = "Mana-Ticker |cFF00FF00an|r.";
+FBLocale["deDE"].TICK_OFF          = "Mana-Ticker |cFFFF0000aus|r.";
+
+-- ==========================================================================
+-- [ Zustand ]
+-- ==========================================================================
+
+FBTicker = {
+    lastTick  = nil,    -- GetTime() des letzten akzeptierten Ticks (Rasterpunkt)
+    lastMana  = nil,    -- zuletzt gesehener Manawert
+    tickSize  = nil,    -- gelernte typische Tickgroesse (fuer den Trankfilter)
+    misses    = 0,      -- Kandidaten in Folge ausserhalb der Toleranz
+    fsrStart  = nil,    -- Beginn der Fuenf-Sekunden-Regel
+    fsrUntil  = nil,    -- ihr Ende (5 s nach Beginn)
+    sparks    = {},     -- Funken auf den Manabalken (Plakette, Raid-Zelle)
+};
+
+function FBTicker_Cfg()
+    if (not HealBox.Ticker) then FBTicker_ApplyDefaults(); end
+    return HealBox.Ticker;
+end
+
+function FBTicker_ApplyDefaults()
+    if (not HealBox.Ticker) then HealBox.Ticker = {}; end
+    for k, v in pairs(FBTickerDefaults) do
+        if (HealBox.Ticker[k] == nil) then HealBox.Ticker[k] = v; end
+    end
+    return true;
+end
+
+-- Volles Mana? (dann gibt es nichts zu regenerieren, Funke aus)
+function FBTicker_ManaFull()
+    local mp, mpMax = UnitMana("player"), UnitManaMax("player");
+    if (not mp) or (not mpMax) or (mpMax <= 0) then return true; end
+    return (mp >= mpMax);
+end
+
+-- Nutzt der Spieler gerade Mana? (Druiden in Gestalt: nein)
+function FBTicker_PlayerHasMana()
+    if (UnitPowerType and UnitPowerType("player") ~= 0) then return false; end
+    local max = UnitManaMax("player");
+    return (max and max > 0);
+end
+
+-- ==========================================================================
+-- [ Erkennung ]
+-- ==========================================================================
+
+-- Naechster Rasterpunkt ab Zeitpunkt t (t selbst, wenn t genau auf dem Raster liegt)
+function FBTicker_NextTickAfter(t)
+    local last = FBTicker.lastTick;
+    if (not last) then return nil; end
+    if (t <= last) then return last; end
+    local k = math.ceil((t - last) / FBTICK_PERIOD - 0.0001);
+    return last + k * FBTICK_PERIOD;
+end
+
+-- Abstand von t zum naechstgelegenen Rasterpunkt
+function FBTicker_GridDistance(t)
+    local last = FBTicker.lastTick;
+    if (not last) then return nil; end
+    local phase = math.mod(t - last, FBTICK_PERIOD);
+    if (phase < 0) then phase = phase + FBTICK_PERIOD; end
+    if (phase > FBTICK_PERIOD / 2) then phase = FBTICK_PERIOD - phase; end
+    return phase;
+end
+
+function FBTicker_OnManaChanged()
+    local cfg = FBTicker_Cfg();
+    local now = GetTime();
+    local mana = UnitMana("player") or 0;
+    local prev = FBTicker.lastMana;
+    FBTicker.lastMana = mana;
+    if (prev == nil) then return; end
+    local delta = mana - prev;
+
+    if (delta < 0) then
+        -- Mana ausgegeben: Fuenf-Sekunden-Regel beginnt jetzt
+        FBTicker.fsrStart = now;
+        FBTicker.fsrUntil = now + FBTICK_FSR;
+        return;
+    end
+    if (delta == 0) then return; end
+
+    -- Zuwachs: Trank oder Rune? (grosser Sprung im Vergleich zur Tickgroesse)
+    if (FBTicker.tickSize and delta >= FBTICK_POTION_MIN and delta > FBTicker.tickSize * FBTICK_POTION_FACT) then
+        return;
+    end
+
+    if (not FBTicker.lastTick) then
+        FBTicker.lastTick = now;
+        FBTicker.misses = 0;
+    else
+        local dist = FBTicker_GridDistance(now);
+        if (dist <= (cfg.Tolerance or 0.3)) then
+            FBTicker.lastTick = now;           -- passt ins Raster: neu synchronisieren
+            FBTicker.misses = 0;
+        else
+            FBTicker.misses = FBTicker.misses + 1;
+            if (FBTicker.misses >= FBTICK_RESYNC_MISS) then
+                FBTicker.lastTick = now;       -- Raster hat sich verschoben
+                FBTicker.misses = 0;
+            end
+            return;                            -- fremder Puls, Tickgroesse nicht lernen
+        end
+    end
+
+    -- Tickgroesse lernen (gleitend), nur ausserhalb der Regel (volle Ticks)
+    local inFSR = (FBTicker.fsrUntil and now < FBTicker.fsrUntil);
+    if (not inFSR) then
+        if (not FBTicker.tickSize) then
+            FBTicker.tickSize = delta;
+        else
+            FBTicker.tickSize = FBTicker.tickSize * 0.7 + delta * 0.3;
+        end
+    end
+end
+
+-- Zeitpunkt, an dem die Regeneration nach der Regel wieder einsetzt:
+-- erster Rasterpunkt nach fsrUntil (ohne Raster: fsrUntil selbst)
+function FBTicker_FSREnd()
+    if (not FBTicker.fsrUntil) then return nil; end
+    local grid = FBTicker_NextTickAfter(FBTicker.fsrUntil);
+    if (grid) then return grid; end
+    return FBTicker.fsrUntil;
+end
+
+-- Anteil 0..1 und Modus ("tick" | "fsr" | nil) fuer den Funken zur Zeit now
+function FBTicker_Progress(now)
+    local cfg = FBTicker_Cfg();
+    local t = now + (cfg.Offset or 0);
+
+    if (cfg.FSR == 1 and FBTicker.fsrStart) then
+        local fsrEnd = FBTicker_FSREnd();
+        if (fsrEnd and t < fsrEnd) then
+            local total = fsrEnd - FBTicker.fsrStart;
+            if (total <= 0) then total = FBTICK_FSR; end
+            local frac = (t - FBTicker.fsrStart) / total;
+            if (frac < 0) then frac = 0; end
+            if (frac > 1) then frac = 1; end
+            return frac, "fsr";
+        end
+        -- Regel vorbei
+        FBTicker.fsrStart = nil;
+        FBTicker.fsrUntil = nil;
+    end
+
+    if (not FBTicker.lastTick) then return nil, nil; end
+    local phase = math.mod(t - FBTicker.lastTick, FBTICK_PERIOD);
+    if (phase < 0) then phase = phase + FBTICK_PERIOD; end
+    return phase / FBTICK_PERIOD, "tick";
+end
+
+function FBTicker_Reset()
+    FBTicker.lastTick = nil;
+    FBTicker.lastMana = UnitMana("player");
+    FBTicker.tickSize = nil;
+    FBTicker.misses = 0;
+    FBTicker.fsrStart = nil;
+    FBTicker.fsrUntil = nil;
+end
+
+-- ==========================================================================
+-- [ Funken ]
+-- ==========================================================================
+
+-- Funke auf einem Manabalken anlegen (einmal je Balken)
+function FBTicker_SparkFor(bar)
+    if (not bar) then return nil; end
+    if (bar.fbSpark) then return bar.fbSpark; end
+    local s = bar:CreateTexture(nil, "OVERLAY");
+    s:SetTexture(1, 1, 1, 1);
+    s:SetWidth(2);
+    s:SetHeight(4);
+    s:SetPoint("LEFT", bar, "LEFT", 0, 0);
+    s:Hide();
+    bar.fbSpark = s;
+    return s;
+end
+
+-- Balken einsammeln: eigene Plakette und, falls vorhanden, eigene Raid-Zelle
+function FBTicker_CollectBars()
+    -- alte Funken verstecken, Zwischenspeicher neu
+    FBTicker_HideAll();
+    FBTicker.sparks = {};
+    if (FBHealBox1 and FBHealBox1.ManaBar) then
+        table.insert(FBTicker.sparks, { bar = FBHealBox1.ManaBar, spark = FBTicker_SparkFor(FBHealBox1.ManaBar) });
+    end
+    if (FBRaidUnitCell and FBRaidTestMode == 0) then
+        local me = UnitName("player");
+        for unit, cell in pairs(FBRaidUnitCell) do
+            if (cell.name == me and cell.ManaBar) then
+                table.insert(FBTicker.sparks, { bar = cell.ManaBar, spark = FBTicker_SparkFor(cell.ManaBar) });
+            end
+        end
+    end
+end
+
+function FBTicker_HideAll()
+    for _, e in ipairs(FBTicker.sparks) do
+        if (e.spark and e.shown ~= false) then e.shown = false; e.spark:Hide(); end
+    end
+end
+
+-- Torwaechter fuer das Zeichnen: wird nur bei Events und Optionswechseln
+-- neu bewertet (Mana-Events, Gestaltwechsel, Schalter), nicht jeden Frame.
+FBTicker.gate = false;
+function FBTicker_UpdateGate()
+    local cfg = FBTicker_Cfg();
+    FBTicker.gate = (cfg.Enabled == 1) and (HealBox.Active == 1)
+        and FBTicker_PlayerHasMana() and (not FBTicker_ManaFull());
+    if (not FBTicker.gate) then FBTicker_HideAll(); end
+end
+
+function FBTicker_Draw()
+    if (not FBTicker.gate) then return; end
+    local now = GetTime();
+    local frac, mode = FBTicker_Progress(now);
+    if (not frac) then
+        FBTicker_HideAll();
+        return;
+    end
+    local col = FBTICK_COLOR_TICK;
+    if (mode == "fsr") then col = FBTICK_COLOR_FSR; end
+    local w = FBTicker_Cfg().SparkW or 2;
+
+    for _, e in ipairs(FBTicker.sparks) do
+        local bar, s = e.bar, e.spark;
+        if (s and bar) then
+            if (bar:IsShown()) then
+                -- Breite und Hoehe aendern sich nur beim Umbauen der Anzeige.
+                -- Sie werden deshalb viermal je Sekunde nachgelesen und
+                -- dazwischen gemerkt; so kostet das Zeichnen je Frame fast
+                -- nichts mehr und darf wieder in jedem Frame laufen.
+                if (not e.geomT) or ((now - e.geomT) >= FBTICK_GEOM_STEP) then
+                    e.geomT = now;
+                    e.bw = bar:GetWidth() or 0;
+                    e.bh = bar:GetHeight() or 0;
+                end
+                local bw = e.bw or 0;
+                local bh = e.bh or 0;
+                if (bw > w and bh > 0) then
+                    if (e.w ~= w or e.h ~= bh) then
+                        e.w = w; e.h = bh;
+                        s:SetWidth(w);
+                        s:SetHeight(bh);
+                    end
+                    if (e.mode ~= mode) then
+                        e.mode = mode;
+                        s:SetTexture(col[1], col[2], col[3], col[4]);
+                    end
+                    -- Anker setzen, sobald sich die Position ueberhaupt
+                    -- geaendert hat. Eine Schwelle von einem halben Pixel
+                    -- klingt sparsam, der Funke wandert aber nur rund 20 px
+                    -- je Sekunde: bei 60 Bildern kam er damit nur in jedem
+                    -- zweiten Frame voran, und je nach Rundung mal nach einem,
+                    -- mal nach zwei Frames. Genau das sah ruckelig aus. Die
+                    -- Feinrundung auf ganze Bildpunkte macht ohnehin die
+                    -- Oberflaeche selbst.
+                    local x = frac * (bw - w);
+                    if (not e.x) or (math.abs(x - e.x) >= 0.05) then
+                        e.x = x;
+                        s:ClearAllPoints();
+                        s:SetPoint("LEFT", bar, "LEFT", x, 0);
+                    end
+                    if (not e.shown) then e.shown = true; s:Show(); end
+                else
+                    if (e.shown) then e.shown = false; s:Hide(); end
+                end
+            elseif (e.shown) then
+                e.shown = false; s:Hide();
+            end
+        end
+    end
+end
+
+-- ==========================================================================
+-- [ Events ]
+-- ==========================================================================
+
+FBTickerFrame = CreateFrame("Frame", "FBHealBoxTickerFrame", UIParent);
+FBTickerFrame:RegisterEvent("UNIT_MANA");
+FBTickerFrame:RegisterEvent("UNIT_MAXMANA");
+FBTickerFrame:RegisterEvent("UNIT_DISPLAYPOWER");
+FBTickerFrame:RegisterEvent("PLAYER_ENTERING_WORLD");
+FBTickerFrame:SetScript("OnEvent", function()
+    if (FBAddonSuppressed) then return; end
+    if (event == "PLAYER_ENTERING_WORLD") then
+        FBTicker_Reset();
+        FBTicker_CollectBars();
+        FBTicker_UpdateGate();
+        return;
+    end
+    if (arg1 ~= "player") then return; end
+    if (event == "UNIT_MANA") then
+        FBTicker_OnManaChanged();
+    elseif (event == "UNIT_DISPLAYPOWER") then
+        FBTicker_Reset();
+    else
+        FBTicker.lastMana = UnitMana("player");
+    end
+    FBTicker_UpdateGate();
+end);
+-- Gezeichnet wird in jedem Frame. Ein fester Takt spart zwar Durchlaeufe,
+-- macht die Bewegung aber sichtbar stufig: der Funke braucht fuer den Balken
+-- fuenf Sekunden, jede ausgelassene Position sieht man sofort. Teuer ist das
+-- Zeichnen nicht mehr, weil die Balkenmasse gemerkt werden und der Ausstieg
+-- ueber das Gate davor sitzt (voller Manabalken = gar kein Durchlauf).
+FBTICK_GEOM_STEP = 0.25;   -- Sek.: so oft werden Breite und Hoehe nachgelesen
+
+FBTickerFrame:SetScript("OnUpdate", function()
+    if (FBAddonSuppressed) then return; end
+    if (not FBTicker.gate) then return; end
+    FBTicker_Draw();
+end);
+
+-- ==========================================================================
+-- [ Options-Reiter "Ticker" ]
+-- ==========================================================================
+
+FBTickerSliders = {};
+
+function FBTicker_SliderText(s)
+    if (not s or not s.Text) then return; end
+    local v = s:GetValue();
+    local shown;
+    if (s.decimals) then shown = format("%.1f", v); else shown = tostring(math.floor(v + 0.5)); end
+    s.Text:SetText(format(FBT(s.labelKey), shown));
+end
+
+function FBTicker_CreateSlider(name, parent, x, y, labelKey, cfgKey, minV, maxV, step, decimals)
+    local s = CreateFrame("Slider", name, parent, "OptionsSliderTemplate");
+    s:SetWidth(128);
+    s:SetHeight(16);
+    s:SetPoint("TOPLEFT", x, y);
+    s:SetMinMaxValues(minV, maxV);
+    s:SetValueStep(step);
+    s.labelKey = labelKey;
+    s.cfgKey = cfgKey;
+    s.decimals = decimals;
+    s.Text = s:CreateFontString(nil, "BACKGROUND", "GameFontNormal");
+    s.Text:SetPoint("CENTER", 0, 15);
+    getglobal(name.."Low"):SetText(tostring(minV));
+    getglobal(name.."High"):SetText(tostring(maxV));
+    s:SetValue(FBTicker_Cfg()[cfgKey] or minV);
+    FBTicker_SliderText(s);
+    s:SetScript("OnValueChanged", function()
+        local v = s:GetValue();
+        if (s.decimals) then v = math.floor(v * 10 + 0.5) / 10; else v = math.floor(v + 0.5); end
+        FBTicker_Cfg()[s.cfgKey] = v;
+        FBTicker_SliderText(s);
+    end);
+    FBTickerSliders[cfgKey] = s;
+    return s;
+end
+
+function FBTicker_BuildOptions()
+    local tab = FBHealBox_AddOptionsTab("TAB_TICKER");
+    if (not tab) then return; end
+    -- Abschnittskopf: der Reiter "Extras" wird mit Smart Damage geteilt
+    FBTickerHeader = tab:CreateFontString(nil, "OVERLAY", "GameFontNormal");
+    FBTickerHeader:SetPoint("TOPLEFT", tab, "TOPLEFT", 35, FBOPT_CONTENT_Y);
+    FBTickerHeader:SetText(FBT("TICK_HEADER"));
+    local y = FBOPT_CONTENT_Y - 26;
+
+    FBTickerEnabledCheck = FBHealBox_CreateCheck("FBHealBoxTickerEnabledCheck", tab, 40, y, "TICK_ENABLED", "TICK_ENABLED_TIP", function()
+        FBTicker_Cfg().Enabled = FBTickerEnabledCheck:GetChecked() and 1 or 0;
+        FBTicker_UpdateGate();
+        FBTicker_Draw();
+    end);
+    FBTickerFSRCheck = FBHealBox_CreateCheck("FBHealBoxTickerFSRCheck", tab, 250, y, "TICK_FSR", "TICK_FSR_TIP", function()
+        FBTicker_Cfg().FSR = FBTickerFSRCheck:GetChecked() and 1 or 0;
+        FBTicker_Draw();
+    end);
+
+    local sy = y - 60;
+    FBTicker_CreateSlider("FBTickerToleranceSlider", tab, 75, sy, "TICK_TOLERANCE", "Tolerance", 0.1, 0.6, 0.1, true);
+    FBTicker_CreateSlider("FBTickerOffsetSlider", tab, 260, sy, "TICK_OFFSET", "Offset", 0.0, 0.5, 0.1, true);
+    FBTicker_CreateSlider("FBTickerSparkWSlider", tab, 75, sy - 46, "TICK_SPARKW", "SparkW", 1, 4, 1, false);
+
+    FBTickerInfoText = tab:CreateFontString(nil, "OVERLAY", "GameFontDisableSmall");
+    FBTickerInfoText:SetPoint("TOPLEFT", tab, "TOPLEFT", 35, sy - 84);
+    FBTickerInfoText:SetWidth(395);
+    FBTickerInfoText:SetJustifyH("LEFT");
+    FBTickerInfoText:SetText(FBT("TICK_INFO"));
+
+    FBTicker_SyncOptions();
+end
+
+function FBTicker_SyncOptions()
+    local cfg = FBTicker_Cfg();
+    if (FBTickerEnabledCheck) then FBTickerEnabledCheck:SetChecked(cfg.Enabled == 1); end
+    if (FBTickerFSRCheck) then FBTickerFSRCheck:SetChecked(cfg.FSR == 1); end
+    for key, s in pairs(FBTickerSliders) do
+        if (cfg[key] ~= nil) then s:SetValue(cfg[key]); end
+    end
+    return true;
+end
+
+function FBTicker_ApplyLocale()
+    if (FBTickerHeader) then FBTickerHeader:SetText(FBT("TICK_HEADER")); end
+    if (FBTickerEnabledCheck) then FBTickerEnabledCheck.Text:SetText(FBT("TICK_ENABLED")); FBTickerEnabledCheck.tooltipText = FBT("TICK_ENABLED_TIP"); end
+    if (FBTickerFSRCheck) then FBTickerFSRCheck.Text:SetText(FBT("TICK_FSR")); FBTickerFSRCheck.tooltipText = FBT("TICK_FSR_TIP"); end
+    if (FBTickerInfoText) then FBTickerInfoText:SetText(FBT("TICK_INFO")); end
+    for _, s in pairs(FBTickerSliders) do FBTicker_SliderText(s); end
+    return true;
+end
+
+-- ==========================================================================
+-- [ Anbindung an den Kern ]
+-- ==========================================================================
+
+FBHealBox_RegisterHook("Loaded", function()
+    DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT("TICK_LOADED"));
+    return true;
+end);
+-- Klassensperre des Kerns: Funken ausknipsen
+FBHealBox_RegisterHook("Suppress", function()
+    for _, e in ipairs(FBTicker.sparks) do
+        if (e.spark) then e.spark:Hide(); end
+    end
+    return true;
+end);
+FBHealBox_RegisterHook("Defaults", function() return FBTicker_ApplyDefaults(); end);
+FBHealBox_RegisterHook("SyncOptions", function() return FBTicker_SyncOptions(); end);
+FBHealBox_RegisterHook("ApplyLocale", function() return FBTicker_ApplyLocale(); end);
+FBHealBox_RegisterHook("UpdateNames", function() FBTicker_CollectBars(); FBTicker_UpdateGate(); return true; end);
+FBHealBox_RegisterHook("ActiveToggle", function() FBTicker_UpdateGate(); FBTicker_Draw(); return true; end);
+FBHealBox_RegisterHook("Status", function()
+    local state = FBT("TICK_UNSYNCED");
+    local nextIn = 0;
+    if (FBTicker.lastTick) then
+        state = FBT("TICK_SYNCED");
+        local nxt = FBTicker_NextTickAfter(GetTime());
+        if (nxt) then nextIn = nxt - GetTime(); end
+    end
+    local fsr = "";
+    local fsrEnd = FBTicker_FSREnd();
+    if (fsrEnd and fsrEnd > GetTime()) then fsr = format(FBT("TICK_STATUS_FSR"), fsrEnd - GetTime()); end
+    DEFAULT_CHAT_FRAME:AddMessage("|cFF00FFFF[FBP]|r "..format(FBT("TICK_STATUS"), state, nextIn, fsr));
+    return true;
+end);
+FBHealBox_RegisterHook("Slash", function(msg)
+    if (msg == "ticker") then
+        local cfg = FBTicker_Cfg();
+        if (cfg.Enabled == 1) then cfg.Enabled = 0; else cfg.Enabled = 1; end
+        FBTicker_SyncOptions();
+        FBTicker_UpdateGate();
+        FBTicker_Draw();
+        local key = "TICK_OFF";
+        if (cfg.Enabled == 1) then key = "TICK_ON"; end
+        DEFAULT_CHAT_FRAME:AddMessage("|cFFFFFF00"..FBADDON_NAME..":|r "..FBT(key));
+        return true;
+    end
+    return false;
+end);
+
+FBTicker_ApplyDefaults();
+FBTicker_BuildOptions();
+FBTicker_CollectBars();