Clean up comments and docs Clean up comments and docs

Simplify and remove redundant comments across Core, State, UI, and
Utils.
Clarify terse notes (ticker, quest XP handling, UI setup) and remove
outdated
or verbose documentation. No functional changes.

Core.lua

···
     if event == "PLAYER_ENTERING_WORLD" then
         F.State:UpdatePlayerXP()
         F.State:UpdateQuestXP()
-        -- Ensure Blizzard bars stay hidden after entering world (in case something re-enabled them)
+        -- Hide Blizzard bars after entering world (in case something re-enabled them)
         if F.UI and F.UI.HideBlizzardBars then
             F.UI.HideBlizzardBars()
         end
···
     F.UpdateUI()
 end)
 
--- 2. The Ticker
--- Updates every second for time-based texts (Session time, etc)
+-- ticker that updates the UI each second
 C_Timer.NewTicker(1, function()
     F.UpdateUI()
 end)
 
--- 3. UI Update (The "Main" function)
 function F.UpdateUI()
     if F.UI and F.UI.Update then
         F.UI.Update()

State.lua

···
     }
 }
 
---- Updates basic player XP data
 function F.State:UpdatePlayerXP()
     self.level = UnitLevel("player")
     self.currentXP = UnitXP("player")
···
     self.isMaxLevel = self.level >= maxLevel
 end
 
---- Updates Quest XP (Iterates Quest Log)
---- Optimized to define API calls locally for performance
 function F.State:UpdateQuestXP()
     local numEntries = C_QuestLog.GetNumQuestLogEntries()
     local qXP, cXP, iXP = 0, 0, 0
 
     for i = 1, numEntries do
         local info = C_QuestLog.GetInfo(i)
-        -- Skip header / hidden entries (they are not selectable quests)
+        -- this skips the XP header for a category / campaign as they should not be respected
         if info and not info.isHeader and not info.isHidden and info.questID > 0 then
-            -- Use the quest log index when querying the reward XP (API expects the index)
+            -- Use the quest log index when querying the reward XP
             local rewardXP = GetQuestLogRewardXP(i) or 0
             if rewardXP > 0 then
                 qXP = qXP + rewardXP
···
     self.incompleteXP = iXP
 end
 
---- Debug helper: dump quest entries and computed quest XP totals
---- Call with: F.State:DebugDumpQuests() or use the slash command /nxpdebug
 function F.State:DebugDumpQuests()
     local numEntries = C_QuestLog.GetNumQuestLogEntries()
     print("NixxnuxXPBar: DebugDumpQuests - numEntries =", numEntries)
···
     F.State:DebugDumpQuests()
 end
 
---- Calculates XP per hour and Time to Level
---- @return number hourlyXP
---- @return number timeToLevel (seconds)
 function F.State:GetSessionStats()
-    local currentTime = GetTime() -- Using GetTime for session delta usually safer than time()
-    -- Note: Original WA used time(), stick to time() if syncing with real world clock is needed,
-    -- but for session duration GetTime() is monotonic.
-    -- Sticking to time() to match WA logic for now:
+    local currentTime = GetTime()
     local now = time()
 
     local sessionTime = now - self.session.startTime

UI.lua

···
 
 F.UI = {}
 
--- Visual Configuration
 local CFG = {
     width = 600,
     height = 24,
-    texture = "Interface\\Buttons\\WHITE8x8", -- Flat, clean texture
+    texture = "Interface\\Buttons\\WHITE8x8",
     font = "Fonts\\FRIZQT__.TTF",
     fontSize = 14,
     barFontSize = 12,
···
     colorQuestComplete = {0.86, 0.52, 0.01, 1}, -- Completed Quest (darker)
 }
 
---- Helper to create consistent status bars
---- @param parent table The parent frame
---- @param layer string The draw layer (BACKGROUND, BORDER, ARTWORK)
---- @param subLevel number The sub-level for fine-grained stacking
---- @param color table {r, g, b, a}
 function F.UI.CreateStatusBar(parent, layer, subLevel, color)
     local bar = CreateFrame("StatusBar", nil, parent)
     bar:SetAllPoints()
     bar:SetStatusBarTexture(CFG.texture)
     bar:SetStatusBarColor(unpack(color))
-    -- SetDrawLayer allows us to stack bars on top of each other explicitly
     bar:GetStatusBarTexture():SetDrawLayer(layer, subLevel)
     return bar
 end
 
---- Creates the main frames and status bars
 function F.UI.Create()
-    -- 1. Main Container (Movable Anchor)
     local f = CreateFrame("Frame", "NXP_Frame", UIParent)
     f:SetSize(CFG.width, CFG.height)
     f:SetPoint("BOTTOM", UIParent, "BOTTOM", 0, 260) -- Default Position
     f:SetFrameStrata("LOW")
 
-    -- Enable dragging (only while Shift is held). Also add snap-to-center when dropped near the middle.
+    -- Enable dragging (only while Shift is held)
     f:SetMovable(true)
     f:EnableMouse(false)
     f:RegisterForDrag("LeftButton")
···
             self:StopMovingOrSizing()
             self.__nxb_moving = nil
 
-            -- Attempt to snap to center if dropped within a radial threshold of the UIParent center
             local fx, fy = self:GetCenter()
             if fx and fy then
                 local cx, cy = UIParent:GetCenter()
···
                 end
             end
 
-            -- ensure any update watcher is removed when we stop moving
             self:SetScript("OnUpdate", nil)
         end
     end
···
     f:SetScript("OnDragStart", function(self)
         if IsShiftKeyDown() then
             self:StartMoving()
-            -- mark as moving so we don't rely on IsMoving API (may be nil in some environments)
             self.__nxb_moving = true
 
-            -- Fallback watcher: if SHIFT is released or mouse is no longer down, stop dragging
             self:SetScript("OnUpdate", function(self, elapsed)
                 if not IsShiftKeyDown() or not IsMouseButtonDown("LeftButton") then
                     stopAndMaybeSnap(self)
···
 
     f:SetScript("OnDragStop", stopAndMaybeSnap)
 
-    -- Also only respond to direct clicks for moving when Shift is held
     f:SetScript("OnMouseDown", function(self, button)
         if button == "LeftButton" and IsShiftKeyDown() then
             self:StartMoving()
-            -- mark as moving so we can detect/release reliably
             self.__nxb_moving = true
 
-            -- Fallback watcher: if SHIFT is released or mouse is no longer down, stop dragging
             self:SetScript("OnUpdate", function(self, elapsed)
                 if not IsShiftKeyDown() or not IsMouseButtonDown("LeftButton") then
                     stopAndMaybeSnap(self)
···
         end
     end)
 
-    -- Stop dragging if SHIFT is released while dragging (listen to modifier changes)
     f:RegisterEvent("MODIFIER_STATE_CHANGED")
     f:SetScript("OnEvent", function(self, event, key, state)
         if event == "MODIFIER_STATE_CHANGED" then
             -- Enable/disable clicks based on Shift state
             self:EnableMouse(IsShiftKeyDown())
-            -- If Shift is no longer held while we are moving, stop and snap
             if not IsShiftKeyDown() and self.__nxb_moving then
                 stopAndMaybeSnap(self)
             end
···
     bg:SetTexture(CFG.texture)
     bg:SetVertexColor(unpack(CFG.colorBack))
 
-
-
-    -- 3. The Status Bars (Layered Bottom to Top)
-
-    -- Rested XP Bar (BACKGROUND layer, visible only if extending past Main)
+    -- Rested XP Bar
     F.BarRested = F.UI.CreateStatusBar(f, "BACKGROUND", 2, CFG.colorRested)
 
-    -- Quest XP Bar (BORDER layer, sits on top of Rested, below Main)
+    -- Quest XP Bar
     F.BarQuest = F.UI.CreateStatusBar(f, "BORDER", 1, CFG.colorQuest)
 
-    -- Completed Quest Bar (BORDER layer, drawn above Quest; shows completed quest XP)
+    -- Completed Quest Bar
     F.BarQuestComplete = F.UI.CreateStatusBar(f, "BORDER", 2, CFG.colorQuestComplete)
 
-    -- Main XP Bar (ARTWORK layer, sits on top of everything)
+    -- Main XP Bar
     F.BarMain = F.UI.CreateStatusBar(f, "ARTWORK", 1, CFG.colorMain)
 
-    -- 4. Text Labels (all placed on an overlay so they always render above the bars)
     local overlay = CreateFrame("Frame", nil, f)
     overlay:SetAllPoints()
     overlay:SetFrameLevel(f:GetFrameLevel() + 10)
     F.Overlay = overlay
 
-    -- Left: simple level label
+    -- level label
     F.LevelText = overlay:CreateFontString(nil, "OVERLAY")
     F.LevelText:SetFont(CFG.font, CFG.barFontSize, "OUTLINE")
     F.LevelText:SetPoint("LEFT", overlay, "LEFT", 8, 0)
···
     F.LevelText:SetDrawLayer("OVERLAY", 2)
     F.LevelText:SetTextColor(1, 1, 1, 1)
 
-    -- Center: current / max XP shown in the middle of the bar
+    -- current / max XP
     F.TextCenter = overlay:CreateFontString(nil, "OVERLAY")
     F.TextCenter:SetFont(CFG.font, CFG.barFontSize, "OUTLINE")
     F.TextCenter:SetPoint("CENTER", overlay, "CENTER", 0, 0)
···
     F.TextCenter:SetDrawLayer("OVERLAY", 2)
     F.TextCenter:SetTextColor(1, 1, 1, 1)
 
-    -- Right: percent text (plain right-aligned fontstring, no solid background)
+    -- percent text
     F.TextRight = overlay:CreateFontString(nil, "OVERLAY")
     F.TextRight:SetFont(CFG.font, CFG.barFontSize, "OUTLINE")
     F.TextRight:SetPoint("RIGHT", overlay, "RIGHT", -8, 0)
···
     F.TextRight:SetDrawLayer("OVERLAY", 2)
     F.TextRight:SetTextColor(1, 1, 1, 1)
 
-    -- Small informational text below the bar (completed quests/rested)
+    -- text below the bar (completed quests/rested)
     F.InfoText = overlay:CreateFontString(nil, "OVERLAY")
     F.InfoText:SetFont(CFG.font, CFG.fontSize - 2, "OUTLINE")
     F.InfoText:SetPoint("TOP", overlay, "BOTTOM", 0, -8)
···
     F.InfoText:SetDrawLayer("OVERLAY", 2)
     F.InfoText:SetTextColor(1, 1, 1, 1)
 
-    -- Leveling info shown above the bar on the top-left
+    -- Leveling info
     F.LevelingText = overlay:CreateFontString(nil, "OVERLAY")
     F.LevelingText:SetFont(CFG.font, CFG.fontSize - 2, "OUTLINE")
     F.LevelingText:SetPoint("BOTTOMLEFT", overlay, "TOPLEFT", 0, 6)
···
     F.LevelingText:SetDrawLayer("OVERLAY", 2)
     F.LevelingText:SetTextColor(1, 1, 1, 1)
 
-    -- Perform an initial update to set values
     F.UI.Update()
 
-    -- Hide default Blizzard bars if the option is enabled (guarded in the function)
     F.UI.HideBlizzardBars()
 end
 
--- Utility: Hide Blizzard's default experience and reputation bars (if configured)
--- This is safe even if the global Blizzard frames don't exist (we check for them).
 function F.UI.HideBlizzardBars()
     if not (F and F.DB and F.DB.hideBlizzardXPBar) then return end
 
-    -- Hide the main experience bar if present
     if MainMenuExpBar then
         MainMenuExpBar:UnregisterAllEvents()
         MainMenuExpBar:Hide()
     end
 
-    -- Hide the reputation watch bar (classic name)
     if ReputationWatchBar then
         ReputationWatchBar:UnregisterAllEvents()
         ReputationWatchBar:Hide()
     end
 
-    -- Hide the status-tracking manager (modern clients)
     if StatusTrackingBarManager then
         StatusTrackingBarManager:UnregisterAllEvents()
         StatusTrackingBarManager:Hide()
     end
 
-    -- Some clients expose a performance/progress bar container; hide if present
     if MainMenuBarPerformanceBar then
         MainMenuBarPerformanceBar:UnregisterAllEvents()
         MainMenuBarPerformanceBar:Hide()
     end
 end
 
---- The Main Draw Function (Called from Core.lua)
 function F.UI.Update()
-    -- Ensure frame exists
     if not F.Frame then F.UI.Create() end
 
     local s = F.State
     local db = F.DB
 
-    -- 1. Visibility Check
-    -- If max level and option is set to hide, hide and return early
     if s.isMaxLevel and not db.showAtMaxLevel then
         F.Frame:Hide()
         return
···
         F.Frame:Show()
     end
 
-    -- If we're at max level but configured to still show the frame, there is no XP to display
-    -- so hide the bars and only show textual information.
     if s.isMaxLevel then
         F.BarMain:Hide()
         F.BarQuest:Hide()
···
         F.BarMain:Show()
     end
 
-    -- 2. Update Bar Ranges & Values
-    -- Guard against a zero maxXP (can happen briefly on login or if at max level)
     local maxXP = (s.maxXP > 0) and s.maxXP or 1
 
-    -- Main Bar: Actual current XP (clamped to the computed range)
     F.BarMain:SetMinMaxValues(0, maxXP)
     F.BarMain:SetValue(math.min(s.currentXP, maxXP))
 
-    -- Quest Bar: Visualizes both completed and total quest XP prediction
     local projectedComplete = s.currentXP + (s.completeXP or 0)
-    -- Total projection includes completed and optionally incomplete (config)
     local projectedQuest = projectedComplete + (db.showIncompleteQuestBar and (s.incompleteXP or 0) or 0)
 
-    -- Completed quest bar (darker): show only if it extends past current XP
     if s.maxXP > 0 and projectedComplete > s.currentXP then
         F.BarQuestComplete:Show()
         F.BarQuestComplete:SetMinMaxValues(0, maxXP)
···
         F.BarQuestComplete:Hide()
     end
 
-    -- Total quest bar (lighter): shows only the delta beyond completed quests (if configured)
     if s.maxXP > 0 and projectedQuest > projectedComplete and projectedComplete < s.maxXP then
         F.BarQuest:Show()
-        -- Restrict this bar's range so it represents only the incomplete delta beyond completed quests
         F.BarQuest:SetMinMaxValues(projectedComplete, maxXP)
         F.BarQuest:SetValue(math.min(projectedQuest, s.maxXP))
     else
         F.BarQuest:Hide()
     end
 
-    -- Rested Bar: Visualizes "Potential" (Current + Rested)
     local projectedRested = s.currentXP + (s.restedXP or 0)
     if s.maxXP > 0 and (s.restedXP or 0) > 0 and s.currentXP < s.maxXP then
         F.BarRested:Show()
···
         F.BarRested:Hide()
     end
 
-    -- 3. Text Updates
-    -- Calculate derived stats for display
     local hourlyXP, timeToLevel, sessionTime = F.State:GetSessionStats()
     local percentXP = (s.maxXP > 0) and (s.currentXP / s.maxXP * 100) or 0
     local percentRested = (s.maxXP > 0) and (s.restedXP / s.maxXP * 100) or 0
 
-    -- Left / Center text updates
     F.LevelText:SetText("Level " .. s.level)
 
-    -- Center Text: show current / max XP in the bar center
     if s.isMaxLevel then
         F.TextCenter:SetText("Level " .. s.level .. " (Max)")
     else
         F.TextCenter:SetText(string.format("%s / %s", FormatLargeNumber(s.currentXP), FormatLargeNumber(s.maxXP)))
     end
 
-    -- Build percent string (e.g., "65.8% (68.2%)") and put it in the right-side percent box
-    -- The parentheses now show current% + COMPLETED quest XP only (not incomplete).
     local percentStr = ""
     if not s.isMaxLevel and s.maxXP > 0 then
-        -- Use only completed quest XP for the parentheses prediction
         local completedXP = (s.completeXP or 0)
         local percentCompleted = (s.maxXP > 0) and (completedXP / s.maxXP * 100) or 0
         local percentWithComplete = percentXP + percentCompleted
···
         F.TextRight:SetText("")
     end
 
-    -- Small info below the bar: e.g. Completed Quests / Rested Experience
-    -- Combined info line: Completed Quests / Rested Experience plus optional leveling info
     do
         local infoParts = {}
 
···
             F.LevelingText:SetText("")
         end
     end
-
-    -- Leveling/time info is now merged into `F.InfoText` above; no separate TextLeft usage
 end

Utils.lua

···
 
 F.Utils = {}
 
---- Rounds a number to specific decimal places
---- @param num number
---- @param decimals number
---- @return number
 function F.Utils.Round(num, decimals)
     local mult = 10^(decimals or 0)
     return math.floor(num * mult + 0.5) / mult
 end
 
---- Formats large numbers into readable strings (adds commas or uses K/M suffixes)
---- Examples:
----   950 -> "950"
----   10500 -> "10,500"
----   200500 -> "200.5K"
----   1500000 -> "1.5M"
---- @param n number
---- @return string
+-- Format large numbers into readable strings (commas or K/M suffixes)
 function F.Utils.FormatLargeNumber(n)
     n = tonumber(n) or 0
 
···
     end
 end
 
--- Backwards-compatible global alias (existing UI code calls FormatLargeNumber directly)
 FormatLargeNumber = function(n) return F.Utils.FormatLargeNumber(n) end
 
---- Formats seconds into readable time string
---- @param time number Seconds
---- @param formatString? string Optional format override
---- @return string
 function F.Utils.FormatTime(time, formatString)
     if time <= 59 then return "< 1m" end