Serie: Level Time bauen. Teil 1 (dieser Beitrag): Addon-Architektur · Teil 2: Lua mit Go testen · Teil 3: die Release-Pipeline · Teil 4: Goals und die öffentliche API · Produktseite: Level Time
Level Time ist ein World-of-Warcraft-Addon, das ich in Lua schreibe und mit etwas Go-Tooling pflege. Es ist öffentlich auf CurseForge und auf GitHub. Diese Serie erzÀhlt die Ingenieursgeschichte dahinter: wie das Addon aufgebaut ist, wie ich Lua aus Go heraus teste, wie ein Release entsteht und wie ein zweites Addon an das erste andockt.
Der erste Teil dreht sich um die Form des Ganzen. Ein Addon ist ein Programm, das im Prozess eines anderen lĂ€uft, in einer Sprachversion, die jemand anderes gewĂ€hlt hat, auf vier verschiedenen Spielclients, mit einer Persistenz, die nur aus âder Client schreibt deine globalen Tabellen in eine Dateiâ besteht. Wenn du noch nie eins geschrieben hast, ist dieser Beitrag eine FĂŒhrung. Wenn doch, findest du vielleicht trotzdem ein paar Muster zum Klauen.
Was Level Time macht und fĂŒr wen
Level Time erfasst Spielzeit, XP pro Stunde, Kills, Tode, Quests und Gold fĂŒr dein aktuelles Level, deine aktuelle Session und die Instanz, in der du bist. Dazu gibt es eine Historie ĂŒber jedes Level, jede Session und jeden Lauf aller deiner Charaktere. So lĂ€sst sich beantworten: âWie lange hat Level 34 gedauert, und war das schneller als bei meinem letzten Charakter?â

Das Layout âKachelnâ. Level Time hat insgesamt sieben Layouts.
Drei Gruppen sind die Hauptzielgruppe:
- Leveler, die wissen wollen, ob ihre Route wirklich effizient ist. FĂŒr sie sind XP/h, Zeit bis zum Level-Up und die Historien-Diagramme gedacht.
- Speedrunner, die LiveSplit-artige Splits pro Level, den Vergleich mit der persönlichen Bestzeit und einen Export nach LiveSplit wollen.
- Streamer, die Anzeigen brauchen, die im Stream gut aussehen: ein Layout nur mit Text ohne Hintergrund, einen Chroma-Key-Hintergrund fĂŒr OBS, verborgene Namen und eine Recap-Karte.
Alles ist konfigurierbar, die meisten Extras sind standardmĂ€Ăig aus, und das Addon lĂ€uft mit einem Download auf Retail, Classic Era, TBC Anniversary und WoW Forever. Es wird aktiv weiterentwickelt; ich beschreibe den Stand des Repositorys beim Schreiben, kein fertiges Produkt.
Wie ein WoW-Addon funktioniert
Wer Browser-Erweiterungen oder Spiele-Mods kennt, findet das Modell vertraut, nur mit ein paar ungewöhnlichen EinschrÀnkungen.
Die TOC-Datei
Ein Addon ist ein Ordner unter Interface/AddOns/. Zwingend nötig ist nur eine .toc-Datei, die wie der Ordner heiĂt. Sie ist ein einfaches Textmanifest, beschrieben in der TOC-Format-Referenz. Oben stehen Metadaten als ## SchlĂŒssel: Wert, danach die Liste der zu ladenden Dateien, in genau dieser Reihenfolge. Hier der Anfang der TOC von Level Time (gekĂŒrzt):
## Interface: 120105, 11509, 20506, 16001
## Title: Level Time
## Notes: Statistics per level and per session ...
## SavedVariables: LevelTimerDB, LevelTimerStatsDB, LevelTimerDebugLog
## SavedVariablesPerCharacter: LevelTimerCharDB
Locales\Core.lua
Locales\enUS.lua
Lib\Migrate.lua
Core\Database.lua
Lib\Lifecycle.lua
Core\LevelTimer.lua
Core\Client.lua
...
Tracking\Stats.lua
Es gibt kein Modulsystem, kein require, keinen Bundler. Die Ladereihenfolge in der TOC ist der AbhĂ€ngigkeitsgraph. Benutzt Datei B etwas aus Datei A, muss A davor stehen, und wer eine neue Datei nicht in die TOC eintrĂ€gt, bekommt sie stillschweigend nie geladen. Was das fĂŒr die Struktur bedeutet, kommt weiter unten.
Alles teilt sich einen Namensraum
Jede Datei wird mit zwei versteckten Argumenten ausgefĂŒhrt: dem Addon-Namen und einer Tabelle, die alle Dateien dieses Addons teilen. Diese Tabelle ist der vorgesehene Weg, Code zu teilen, ohne die globale Umgebung zu verschmutzen:
-- first line of nearly every file in the addon
local _, ns = ...
local Stats = {}
ns.Stats = Stats -- now every later file can use ns.Stats
Das ist das ganze Modulsystem. ns.Stats, ns.Journal, ns.Format und so weiter sind nur Tabellen an einer gemeinsamen Tabelle. Level Time macht diese Tabelle auĂerdem global als LevelTimerAPI verfĂŒgbar, womit das Schwester-Addon aus Teil 4 arbeitet.
Events statt Threads
Das Spiel fĂŒhrt deinen Lua-Code in einem Thread aus, innerhalb seiner eigenen Frame-Schleife. Es gibt keine Threads, kein sleep, kein blockierendes I/O. Alles Langlaufende friert die gesamte SpieloberflĂ€che ein, also ist die Arbeitseinheit ein kleiner Callback.
Ausgelöst werden Callbacks durch Events. Du erzeugst einen versteckten Frame (das UI-Primitiv, das Events empfangen kann), registrierst die Event-Namen, die dich interessieren, und setzt ein OnEvent-Skript. Die Event-Liste im Wiki ist dein Freund; PLAYER_XP_UPDATE, PLAYER_LEVEL_UP, PLAYER_DEAD und TIME_PLAYED_MSG sind die, von denen Level Time lebt.
FĂŒr periodische Arbeit gibt es das OnUpdate-Skript (Referenz), das in jedem gerenderten Frame mit der vergangenen Zeit feuert. Bei 144 FPS sind das 144 Aufrufe pro Sekunde, also gilt: In OnUpdate nichts tun, solange keine Drosselung sagt, dass es Zeit ist.
SavedVariables
Die Persistenz ist herrlich grob. Du deklarierst globale Variablennamen in der TOC; der Client lĂ€dt sie vor PLAYER_LOGIN aus einer Datei und schreibt sie beim Logout oder /reload zurĂŒck:
-- Variables listed in "## SavedVariables" are plain globals.
-- They are nil on the very first run, so always default them.
LevelTimerDB = LevelTimerDB or {}
Die Details stehen im Wiki: Variablen zwischen Spielsitzungen speichern. Zwei Folgen sind fĂŒr das Design wichtig:
- Die gesamte Tabelle wird serialisiert bei jedem Logout und geparst bei jedem Login. GröĂe ist Ladezeit.
- Es gibt kein Schema, keine Transaktion, keine Versionierung. Ănderst du das Datenlayout, schreibst du die Migration.
Beides hat Level Time geprÀgt, wie die Abschnitte zum Journalarchiv und zu den Migrationen zeigen.
Lua 5.1 und die Sandbox
Der Client bettet Lua 5.1 ein (Handbuch), mit eingeschrĂ€nkter Standardbibliothek und einer groĂen API obendrauf, dokumentiert auf warcraft.wiki.gg. Neuere Retail-Versionen verbergen auĂerdem manche Werte komplett vor Addons (âSecret Valuesâ), dazu mehr im Multi-Client-Abschnitt.
Das Modullayout
Das Repository ist nach Fachgebieten gegliedert, nicht nach technischen Schichten:
| Ordner | Aufgabe |
|---|---|
Locales/ | Texte in Englisch, Deutsch, Französisch und Spanisch |
Core/ | Datenbank, Client-Erkennung, Slash-Befehle, Profiler, Debug-Werkzeuge |
Lib/ | fachfreie Helfer: Formatierung, Serializer, Widgets, der Event-/Lifecycle-Kern |
Tracking/ | ZĂ€hler und Event-Erzeuger: Kills, Tode, Quests, Geld, XP, Beute, das Journal |
History/ | Levelhistorie, Analyse, Prognose, Ziele, persönliche Rekorde |
Speedrun/ | LĂ€ufe, Splits, Rekorde, LiveSplit-Export |
Assist/ | optionale Komfortfunktionen, Erinnerungen, Warnungen |
UI/ | Fenster, Stat-Zeilen, Hinweise, Optionen, Layouts |
Weil die TOC-Reihenfolge die AbhĂ€ngigkeitsreihenfolge ist, entscheiden die Ordner nicht darĂŒber, was wovon abhĂ€ngen darf; das tut die Disziplin. Meine Regel ist dieselbe wie in meinem Beitrag zu Bounded Contexts: Datenmodule wissen nichts von der UI, und UI-Module fragen Datenmodule nach Werten, nie umgekehrt.
Der Kern: ein Event-Frame, viele Listener
Die wichtigste Datei ist Lib/Lifecycle.lua. Statt dass jedes Modul einen eigenen Frame anlegt, gibt es einen Event-Frame und eine Registry davor. Module rufen ns.RegisterEvent(event, handler) auf, und beliebig viele Module können dasselbe Event abonnieren. Die Handler laufen in Registrierungsreihenfolge, also in TOC-Reihenfolge. Hier eine vereinfachte Version der Idee:
-- simplified from Lib/Lifecycle.lua
local eventFrame = CreateFrame("Frame")
local handlersByEvent = {}
function ns.RegisterEvent(event, handler)
if not handlersByEvent[event] then
-- pcall: a client that does not know this event throws, we return false instead
if not pcall(eventFrame.RegisterEvent, eventFrame, event) then
return false
end
handlersByEvent[event] = {}
end
table.insert(handlersByEvent[event], handler)
return true
end
eventFrame:SetScript("OnEvent", function(_, event, ...)
for _, handler in ipairs(handlersByEvent[event]) do
ns.SafeCall(handler, ...)
end
end)
Zwei Details machen daraus mehr als einen bequemen Wrapper.
Isolation. ns.SafeCall packt jeden Handler, jeden Login-Callback und jede wiederkehrende Aufgabe in xpcall. Ein Fehler in einem Modul landet im Fehler-Handler des Clients (BugSack, das Standard-Fehlerfenster), und der nĂ€chste Handler lĂ€uft trotzdem. Bei einem Addon mit einigen hundert ĂŒber die Zeit gewachsenen Dateien darf ein kaputtes Feature nicht den Level-Timer mitreiĂen.
PortabilitĂ€t. Kennt ein Client ein Event nicht, wirft RegisterEvent einen Fehler. Der Wrapper macht daraus den RĂŒckgabewert false, und das Feature, das das Event brauchte, bleibt einfach aus. Das ist der erste von mehreren Mechanismen des âleisen Abschaltensâ im Multi-Client-Abschnitt.
FĂŒr die anderen wiederkehrenden BedĂŒrfnisse gibt es Geschwister dieser Funktion: ns.RegisterUnitEvent (UNIT_AURA nur fĂŒr den Spieler statt fĂŒr jede Namensplakette und jedes Gruppenmitglied), ns.Every(seconds, fn, enabled) (eine wiederkehrende Aufgabe auf einem gemeinsamen OnUpdate-Frame; Aufgaben, deren Feature aus ist, kosten nichts), ns.OnLogin, ns.OnLogout und ein Level-Up in zwei Phasen. Module registrieren ns.RegisterApply(fn)-Callbacks, die ihren Zustand aus der Einstellungstabelle neu aufbauen, sobald sich eine Einstellung Ă€ndert; deshalb wirkt ein Sprachwechsel sofort.
Tracking: ZĂ€hler und ein Journal
Tracking/ macht aus rohen Events zwei Arten von Daten.
ZĂ€hler. Stats fĂŒhrt jeden ZĂ€hler in Bereichen (Scopes). Ein ZĂ€hler existiert einmal fĂŒr das aktuelle Level und einmal fĂŒr die aktuelle Session, und Stats.Increment zĂ€hlt immer in beiden. Der Instanz-Bereich funktioniert genauso fĂŒr den Dungeon, in dem du bist. Ein Erzeuger wie der Kill-ZĂ€hler kennt die Bereiche nicht:
-- simplified from Tracking/KillCounter.lua
local function countKill(name, xp)
local classification = Classification.Of(name)
Stats.Increment(Stats.PVE_KILLS)
Stats.Increment(Stats.XP_KILLS, xp or 0)
if Classification.IsElite(classification) then
Stats.Increment(Stats.ELITE_KILLS)
end
Journal.AddKill(name, classification, xp)
end
Die UI kann dann Stats.Get(scope, counter) fragen und per Tab zwischen âLevel 34â, âSessionâ und âInstanzâ wechseln, ohne dass sich ein Erzeuger Ă€ndert.
Das Journal. ZĂ€hler sagen, wie viele; das Journal sagt, was. Jeder Kill, Tod, jede Quest, jeder Beutegegenstand, Instanzlauf und Beinahe-Tod wird ein Eintrag mit Zeitstempel, Level und Zone. Die Tabellen und Diagramme des Historienfensters entstehen daraus.
Manche Erzeuger sind nicht trivial. Auf aktuellen Retail- und WoW-Forever-Clients ist der Kampflogtext fĂŒr XP-Gewinne manchmal ein Secret Value: das Addon kann ihn weiterreichen, aber nicht lesen. Der Kill-ZĂ€hler wartet dann kurz, ordnet die Kill-Meldung nahen XP-Ănderungen zu und verbucht einen Kill ohne Namen. Im Code ist das als Kompromiss dokumentiert: Die Summe stimmt, die Verteilung auf gleichzeitige Kills nicht.
Historie: SchnappschĂŒsse im richtigen Moment
History/ verarbeitet ZĂ€hler und Journal. Das wichtigste Muster ist das Level-Up in zwei Phasen. Direkt auf PLAYER_LEVEL_UP zu hören, lieĂe jedes Modul raten, ob seine Werte schon zurĂŒckgesetzt sind. Stattdessen liefert der Kern:
ns.OnLevelCompleted(fn(oldLevel)), solange die alten Werte noch intakt sind,- dann wird
ns.levelaktualisiert, - dann
ns.OnLevelStarted(fn(newLevel))fĂŒr RĂŒcksetzungen.
Das Historienmodul macht in Phase eins den Schnappschuss des beendeten Levels:
-- simplified from History/History.lua
ns.OnLevelCompleted(function(completedLevel)
ns.character.levelHistory[completedLevel] = {
level = completedLevel,
seconds = Stats.GetSeconds(Stats.LEVEL),
counters = Stats.Snapshot(Stats.LEVEL),
completedAt = time(),
totalPlayed = PlayedTime.GetTotalSeconds(),
}
end)
Alles andere (Analyse-Reihen, Prognose bis zum Max-Level, persönliche Rekorde, Speedrun-Splits) wird aus levelHistory, dem Journal und den ZÀhlern berechnet. Die Spielzeit pro Level stammt aus der /played-Antwort des Servers, weshalb ein mitten im Level installiertes Level Time trotzdem die richtige Zeit zeigt.
UI: Abfragen schlÀgt Schieben
Datenmodule bieten Getter an; Fenster lesen sie. Das Hauptfenster bekommt nie âWert X hat sich geĂ€ndertâ-Aufrufe. Stattdessen markiert jede Ănderung es als schmutzig (dirty), und ein gedrosseltes OnUpdate zeichnet neu:
-- simplified from UI/TimerWindow.lua
local UPDATE_INTERVAL = 0.25
local dirty, sinceUpdate = true, 0
Stats.OnIncrement(function() dirty = true end)
ns.RegisterEvent("PLAYER_XP_UPDATE", function() dirty = true end)
ns.SetUpdateScript(window, "TimerWindow", function(_, elapsed)
sinceUpdate = sinceUpdate + elapsed
if sinceUpdate < UPDATE_INTERVAL then return end
sinceUpdate = 0
if dirty or secondChanged() then
dirty = false
refresh()
end
end)
Vier PrĂŒfungen pro Sekunde, ein Neuzeichnen nur, wenn sich etwas geĂ€ndert hat oder eine Sekunde vergangen ist (der Spielzeit-ZĂ€hler), und Text wird nur gesetzt, wenn er sich unterscheidet. Eine Event-Flut bei einem groĂen Pull kostet jeweils einen Flag-Schreibzugriff, nicht jeweils einen Layout-Durchlauf.
Die sieben Layouts (Tabelle, Leiste, kompakt, nur Text, Uhr, XP-Balken, Kacheln) sind in einer kleinen Registry angemeldet (Layouts.Register(id, { Build, Render, Measure })). Build lÀuft nur bei geÀnderter Struktur, Render bei jedem Takt und meldet, ob sich ein Text geÀndert hat. Ein neues Layout ist eine Datei, und die Stat-Zeilen sind eine gemeinsame Liste (ns.STAT_LINES), aus der sowohl die Fensterzeilen als auch die Options-Schalter erzeugt werden.

Kompakt: Zeit, XP-Balken und bis zu drei Werte deiner Wahl.

Nur Text: ohne Hintergrund, mit Umrandung. Gemacht fĂŒr Stream-Overlays.

Die einzeilige Infoleiste. Manche Screenshots dieser Serie zeigen Fenster aus der Zeit vor dem neuesten Release.
Das Journalarchiv: ein Load-on-Demand-Addon
Hier das Problem, das das SavedVariables-Design erzeugt. Ein lange gespielter Charakter sammelt ein Journal aus Kills, Toden, Beute und Quests, das zehntausende EintrĂ€ge erreichen kann (der Code begrenzt Kills auf 250.000), und ohne Archiv sind alle davon Lua-Tabellen in LevelTimerStatsDB. Alles in einer SavedVariable wird beim Login geparst und beim Logout serialisiert, egal ob du je die Historie öffnest. FĂŒr ein Feature, das die meisten Spieler selten öffnen, ist das ein schlechter Tausch.
WoW hat dafĂŒr genau ein Feature: Load-on-Demand-Addons. Eine TOC mit ## LoadOnDemand: 1 wird beim Login nicht geladen. Ihre Dateien und ihre SavedVariables werden erst gelesen, wenn anderer Code LoadAddOn aufruft (C_AddOns.LoadAddOn). Der Client schreibt die Datei auĂerdem nur in Sitzungen zurĂŒck, in denen das Addon geladen war. Level Time liefert deshalb ein zweites, winziges Addon mit:
## Title: Level Time (Archive)
## Dependencies: LevelTimer
## LoadOnDemand: 1
## SavedVariables: LevelTimerArchiveDB
Archive.lua
Archive.lua enthĂ€lt keinerlei Logik; die Datei existiert nur, damit der Client etwas hat, woran er die SavedVariable hĂ€ngen kann. Die Logik steckt im Hauptaddon (Tracking/JournalArchive.lua). Das Design in KĂŒrze:
- Neue JournaleintrÀge landen in einem Eingang (Inbox) in den normalen Charakterdaten. Konstanten im Code:
INBOX_MAX = 3000,KEEP_RECENT = 500. - Beim Login wird das Archiv-Addon geladen, wenn ein Eingang mehr als
INBOX_MAXEintrĂ€ge hat, und alles bis auf die neuestenKEEP_RECENTEintrĂ€ge je Log zieht dorthin um. Auch das Ăffnen des Historienfensters (oder eines Diagramms, das ArchiveintrĂ€ge liest) lĂ€dt es. Danach bleibt es fĂŒr die Sitzung geladen. - Archivierte EintrĂ€ge speichert
RecordCodeckompakt: eine Textzeile pro Eintrag mit den Feldern in fester Reihenfolge, Zeichenketten (Namen, Zonen, Item-Links) einmal in einem Wörterbuch pro Charakter und in der Zeile nur als Nummer. Der Kommentar im Quelltext nennt fĂŒr eine Kill-Zeile rund 30 Byte statt 100 bis 150 als Lua-Tabelle; ich habe das nicht unabhĂ€ngig nachgemessen. - Fehlt das Archiv-Addon oder ist es deaktiviert, schlĂ€gt das Laden einmal fehl, der Zustand wird
unavailable, und alles bleibt im Eingang. Der Eingang ist begrenzt (INBOX_LIMIT = 20000plus etwas Spielraum), damit er nicht ewig wÀchst.
-- simplified from Tracking/JournalArchive.lua
local function loadAddOn(name)
local load = (C_AddOns and C_AddOns.LoadAddOn) or LoadAddOn
if not load then return false end
local ok, loaded = pcall(load, name)
return ok and loaded and true or false
end
Beachte den Fallback C_AddOns.LoadAddOn oder LoadAddOn: Neuere Clients haben die Funktion in einen Namensraum verschoben, Àltere kennen nur die globale. Dieses Muster begegnet dir stÀndig.
Das Ergebnis: Login und Logout kosten gleich viel, egal wie groĂ die Historie wird, und wer das Journal nie öffnet, zahlt auch nie dafĂŒr.
Ein Download, vier Clients
Retail, Classic Era, TBC Anniversary und WoW Forever unterscheiden sich in der API-VerfĂŒgbarkeit, in UI-Vorlagen und sogar darin, welche Werte Addons lesen dĂŒrfen. Level Time liefert nicht vier Builds aus, sondern nutzt drei Mechanismen.
1. Eine TOC mit mehreren Interface-Versionen. Die Zeile ## Interface: 120105, 11509, 20506, 16001 nennt je Client eine Interface-Nummer; der Client lĂ€dt das Addon, wenn seine eigene Nummer in der Liste steht. Die Dateiliste ist fĂŒr alle gleich. Die Interface-Nummern kommen aus GetBuildInfo, dessen vierter RĂŒckgabewert dieselbe Nummer ist.
2. Client-Erkennung aus dieser Nummer. Core/Client.lua hat gut fĂŒnfzig Zeilen:
-- simplified from Core/Client.lua
function Client.GetInterfaceVersion()
return select(4, GetBuildInfo())
end
function Client.IsForever()
local version = Client.GetInterfaceVersion()
return version >= 16000 and version <= 16999
end
function Client.IsRetail()
return Client.GetInterfaceVersion() >= 100000
end
Das braucht man fĂŒr Features, die es nur in einem Client gibt. Die Timer fĂŒr Lagerfeuer und Schlafsack sind zum Beispiel WoW-Forever-Features: Ihre Optionen erscheinen in den anderen Clients gar nicht. Die Paketierung nutzt dieselbe Zuordnung, sodass Code und Release ĂŒbereinstimmen.
3. Feature-Erkennung fĂŒr alles andere. Die meisten Unterschiede lauten nicht âwelcher Client ist dasâ, sondern âexistiert diese Funktionâ. Der Code fragt die API statt der Version:
-- simplified from Tracking/Experience.lua
local function isAtMaxLevel()
if GameRulesUtil and GameRulesUtil.IsPlayerAtEffectiveMaxLevel then
return GameRulesUtil.IsPlayerAtEffectiveMaxLevel()
end
if IsPlayerAtEffectiveMaxLevel then
return IsPlayerAtEffectiveMaxLevel()
end
return GetMaxPlayerLevel ~= nil and ns.level >= GetMaxPlayerLevel()
end
Drei Clients, drei Wege, dieselbe Frage zu stellen, eine Funktion. Dieselbe Idee deckt Events ab (RegisterEvent gibt false zurĂŒck), Unit-Events (RegisterUnitEvent nutzen, wenn der Frame es hat, sonst manuell filtern) und Secret Values (issecretvalue wird geprĂŒft, bevor ein Wert verglichen wird). Reparaturen ĂŒber die Gildenbank prĂŒfen die API (CanGuildBankRepair) und den Client.
Die ehrliche Kehrseite: Nichts prĂŒft das automatisch fĂŒr mich. Mein Test-Harness (Thema von Teil 2) fĂ€lscht die API und kann das Addon als verschiedene Clients laden, aber er prĂŒft Logik, nicht ob eine Funktion in einem Client wirklich existiert. Tests im Spiel auf jedem Client bleiben nötig, und das Projekt fĂŒhrt dafĂŒr eine manuelle Checkliste.
SavedVariables-Schema und Migrationen
Da der Client mir kein Schema gibt, habe ich ein minimales gebaut. Lib/Migrate.lua hat 33 Zeilen:
-- simplified from Lib/Migrate.lua
function Migrate.Run(data, migrations, targetVersion)
local version = data.schemaVersion or 1
if version >= targetVersion then return end
for nextVersion = version + 1, targetVersion do
if migrations[nextVersion] then
migrations[nextVersion](data)
end
end
data.schemaVersion = targetVersion
end
function Migrate.ApplyDefaults(data, defaults)
for key, value in pairs(defaults) do
if type(value) == "table" then
if type(data[key]) ~= "table" then data[key] = {} end
Migrate.ApplyDefaults(data[key], value)
elseif data[key] == nil then
data[key] = value
end
end
return data
end
Jede gespeicherte Tabelle trĂ€gt eine schemaVersion; eine Tabelle von Migrationen ist nach Zielversion geschlĂŒsselt. Es gibt getrennte Versionslinien fĂŒr die Account-Einstellungen (LevelTimerDB, derzeit Schema 7) und die Statistiken je Charakter (LevelTimerStatsDB, derzeit Schema 5). ApplyDefaults ergĂ€nzt danach alles, was noch fehlt, weshalb eine ganz neue Einstellung gar keine Migration braucht.
Zwei Entscheidungen verdienen eine ErklÀrung:
- Die Version sinkt nie. Nach einem Downgrade auf eine Ă€ltere Addon-Version wĂŒrde eine nicht wiederholbare Migration beim nĂ€chsten Upgrade sonst ein zweites Mal laufen.
- Ein defekter Charakter darf den Rest nicht blockieren. Beim Login wird jeder gespeicherte Charakter innerhalb von
xpcallmigriert; ein Fehler wird gemeldet und der Eintrag ĂŒbersprungen, die anderen laden normal.
Ein Beispiel, wie eine Migration in der Praxis aussieht: Version 2 machte aus einer alten absoluten Einstellung fontSize die relative scale, angewendet auf die Einstellungen und auf jede gespeicherte Profilkopie.
Die Daten liegen an drei Orten: LevelTimerDB (Account-Einstellungen und Profile), LevelTimerStatsDB (Statistiken, ein Eintrag je Name-Realm) und die Archivdatei. Eine vierte Variable, LevelTimerCharDB, ist ein veralteter Speicher pro Charakter, der nur noch einmal gelesen wird, um alte Daten in die accountweite Tabelle zu ĂŒbernehmen.
Performance-Regeln, die ich auf die harte Tour gelernt habe
Ein Addon teilt sich das Frame-Budget mit dem Spiel und mit jedem anderen Addon. Die Regeln in den Entwicklernotizen von Level Time stammen alle aus echten Profilen, nicht aus Theorie:
- Kein eigenes
OnUpdateje Modul.ns.EverybĂŒndelt alle Hintergrundaufgaben auf einem Frame, und eine Aufgabe kann einenabled-PrĂ€dikat tragen, damit ein ausgeschaltetes Feature nichts kostet. - Schmale Event-Abonnements.
UNIT_*-Events laufen ĂŒberRegisterUnitEventnur fĂŒr den Spieler. Sehr hĂ€ufige Events (das Kampflog) bekommen einen eigenen Frame mit der billigsten VorabprĂŒfung zuerst. - Pro Takt zwischenspeichern. Mehrere Zeilen eines Fensters fragen im selben Refresh denselben teuren Wert ab (Prognose, XP-Quellen).
TickCache.Memorechnet ihn einmal je Takt und vergisst ihn danach. - Kein MĂŒll in heiĂen Pfaden.
ns.SafeCallvermeidet eine Closure je Aufruf; Text wird nur gesetzt, wenn er sich unterscheidet. - Messen.
/lt debug perfschaltet einen eingebauten Profiler ein, der Gesamtzeit, Aufrufzahl und Maximum je Handler, Aufgabe, Listener und Fenster-OnUpdatemeldet. Der Trick: Ausgeschaltet kostet er nichts, denn das Einschalten tauscht die Verteiler gegen gemessene Varianten aus und das Ausschalten wieder zurĂŒck.
Benchmark-Zahlen habe ich hier bewusst nicht veröffentlicht; der Profiler existiert, damit jeder, ich eingeschlossen, auf dem eigenen Rechner messen kann.
Was ich anders machen wĂŒrde
- Die TOC als AbhÀngigkeitsgraph ist fragil. Eine vergessene Zeile ist ein stiller Fehler, und beim Verschieben von Dateien ist ein Client-Neustart nötig. Ein Test, der Dateien in TOC-Reihenfolge lÀdt (was mein Harness tut), fÀngt das erste Problem ab.
- Dirty-Flag-Polling ist einfach, aber nicht gratis. FĂŒr ein Fenster mit 20 Zeilen ist es richtig. FĂŒr ein hochfrequentes Overlay wĂŒrde ich anders bĂŒndeln.
- Feature-Erkennung streut.
if Foo and Foo.Barlandet in vielen Dateien. Die wiederkehrenden hinter kleine Helfer zu legen (wieClient.luaundAuras.lua) zahlt sich jedes Mal aus.
Wie es weitergeht
Ein Addon mit so vielen beweglichen Teilen und vier Client-Varianten lĂ€sst sich nicht durch Herumklicken testen. In Teil 2 zeige ich, wie ich das ganze Addon samt TOC-Reihenfolge in einem Go-Test mit gopher-lua und einer nachgebauten WoW-API laufen lasse, einschlieĂlich Layout-Tests in vier Sprachen.
Wenn du das Addon einfach ausprobieren willst: Die Level-Time-Seite hat Screenshots und Installationslinks, und der Code liegt auf GitHub.