(AceDB-3.0) I don't get where my codes are going wrong.

[Layback_]

Hi all,

Sorry for keep asking a Ace3.0 related questions here. Take all and put together in one lump, Wowinterface is actually the most activated community to discuss this (even if it is a specific library related question).

SO,

I am currently trying to re-write one of my addon that tracks various data of player such as currency, money, class, etc and here's what I've got so far.

ToonTracker.toc

## Interface: 70200
## Title: ToonTracker
## Author: Layback
## SavedVariables: ToonTrackerDB

ToonTracker.lua

currency.lua

ToonTracker.lua

-- Declare addon ------------------------------------------------------------------
local ToonTracker = LibStub("AceAddon-3.0"):NewAddon("ToonTracker");
 
-- Declare & define variables -----------------------------------------------------
local db;
 
-- Defaults db --------------------------------------------------------------------
local defaults = {
    global = {
        modules = {
            ["*"] = true,
        },
 
        experience = {
            pos = {"CENTER", "UIParent", "CENTER", 0, 0},
        },
    },
 
    realm = {
        ["*"] = { -- character's name
            currency = {},
        },
    },
}
 
function ToonTracker:OnInitialize()
    self.db = LibStub("AceDB-3.0"):New("ToonTrackerDB", defaults, true);
 
    db = self.db;
 
    local name = UnitName("player");
    local _, englishClass = UnitClass("player");
 
    db.realm[name].class = englishClass;
end

currency.lua

-- Get addon ----------------------------------------------------------------------
local ToonTracker = LibStub("AceAddon-3.0"):GetAddon("ToonTracker");
 
-- Declare module -----------------------------------------------------------------
local Currency = ToonTracker:NewModule("Currency");
 
-- Declare & define variables -----------------------------------------------------
local db;
 
local name = UnitName("player");
 
local CURRENCY_ID = {
    824,    -- Warlords of Draenor garrison resource
    1220,   -- Legion order resource
    1342,   -- Legionfall War Supplies
    1226,   -- Nethershard
}
 
function Currency:OnInitialize()
    db = ToonTracker.db.realm;
 
    -- Gold
    db[name].money = GetMoney();
 
    -- Currency
    for i = 1, #CURRENCY_ID do
        local currencyName, currencyAmount = GetCurrencyInfo(CURRENCY_ID[i]);
 
        db[name].currency[CURRENCY_ID[i]] = currencyAmount;
    end
end

And here's the output when I first log-in to the toon.


class is well set, but neither money nor currency table are correctly filled with the actual values.
(strangely currency table is properly formed with currencyIDs lol......)

In order to fix this, I'll have to forcibly reload an ui, which is stupid


Could I get some advice, please?

Thank you!



----------------------------------------------------------------------------------------------------------------

EDIT

Would that be because both :OnInitialize() functions are called simultaneously, which I don't think they are.

If they ran at a time, accessing db in Currency:OnInitialize() should return nil, shouldn't it?

[VincentSDSH]

Have you tried using :OnEnable()? I built my currency tracker during LK beta so my memory is a bit fuzzy but there are a fair number of things the client doesn't have right off the bat.

[Layback_]

Originally Posted by VincentSDSH Have you tried using :OnEnable()? I built my currency tracker during LK beta so my memory is a bit fuzzy but there are a fair number of things the client doesn't have right off the bat.

Hi Vincent,

you mean :OnEnable() for module, not addon, right?

I'll have a go and let you know !

[Layback_]

Originally Posted by VincentSDSH Have you tried using :OnEnable()? I built my currency tracker during LK beta so my memory is a bit fuzzy but there are a fair number of things the client doesn't have right off the bat.

It worked

The only change was

Currency.lua

-- Get addon ----------------------------------------------------------------------
local ToonTracker = LibStub("AceAddon-3.0"):GetAddon("ToonTracker");
 
-- Declare module -----------------------------------------------------------------
local Currency = ToonTracker:NewModule("Currency");
 
-- Declare & define variables -----------------------------------------------------
local db;
 
local name = UnitName("player");
 
local CURRENCY_ID = {
    824,    -- Warlords of Draenor garrison resource
    1220,   -- Legion order resource
    1342,   -- Legionfall War Supplies
    1226,   -- Nethershard
}
 
function Currency:OnInitialize()
    db = ToonTracker.db.realm;
end
 
function Currency:OnEnable()
    -- Gold
    db[name].money = GetMoney();
 
    -- Currency
    for i = 1, #CURRENCY_ID do
        local currencyName, currencyAmount = GetCurrencyInfo(CURRENCY_ID[i]);
 
        db[name].currency[CURRENCY_ID[i]] = currencyAmount;
    end
end

What would be cauinsg this, lol...?

[myrroddin]

OnInitialize() only fires once per addon or module, meaning it fires once for the addon, and once for each and every loaded module. Even if you /reloadui it still won't fire again. It would be the equivalent of registering for ADDON_LOADED (for saved variables) and PLAYER_ENTERING_WORLD (for miscellaneous other start up code) and then unregistering both events. OnInitialize() just makes that process a bit cleaner.

OnEnable() is somewhat like PEW, keeping in mind that it is never unregistered. Each time you /reloadui, OnEnable() fires.

If you are not getting the correct currency information, that probably means the game cannot provide that information ... yet.

With Ace3, you register events and library callbacks in OnEnable(). And handling events is always through a function, then register for PLAYER_MONEY in currency.lua's OnEnable(), and immediately call that function from OnEnable().

In your PLAYER_MONEY handler function, have a line that reads:

db.realm[name].money = GetMoney() -- or whatever you actually need

[Layback_]

Originally Posted by myrroddin OnInitialize() only fires once per addon or module, meaning it fires once for the addon, and once for each and every loaded module. Even if you /reloadui it still won't fire again. It would be the equivalent of registering for ADDON_LOADED (for saved variables) and PLAYER_ENTERING_WORLD (for miscellaneous other start up code) and then unregistering both events. OnInitialize() just makes that process a bit cleaner. OnEnable() is somewhat like PEW, keeping in mind that it is never unregistered. Each time you /reloadui, OnEnable() fires. If you are not getting the correct currency information, that probably means the game cannot provide that information ... yet. With Ace3, you register events and library callbacks in OnEnable(). And handling events is always through a function, then register for PLAYER_MONEY in currency.lua's OnEnable(), and immediately call that function from OnEnable(). In your PLAYER_MONEY handler function, have a line that reads: db.realm[name].money = GetMoney() -- or whatever you actually need

Hi myrroddin,

So, does the following look better?!

-- Get addon ----------------------------------------------------------------------
local ToonTracker = LibStub("AceAddon-3.0"):GetAddon("ToonTracker");
 
-- Declare module -----------------------------------------------------------------
local Currency = ToonTracker:NewModule("Currency", "AceEvent-3.0");
 
-- Declare & define variables -----------------------------------------------------
local db;
 
local name = UnitName("player");
 
local CURRENCY_ID = {
    824,    -- Warlords of Draenor garrison resource
    1220,   -- Legion order resource
    1342,   -- Legionfall War Supplies
    1226,   -- Nethershard
}
 
function Currency:OnInitialize()
    db = ToonTracker.db.realm;
end
 
function Currency:OnEnable()
    self:RegisterEvent("PLAYER_MONEY");
    self:RegisterEvent("CURRENCY_DISPLAY_UPDATE");
end
 
function Currency:OnDisable()
    self:UnregisterEvent("PLAYER_MONEY");
    self:UnregisterEvent("CURRENCY_DISPLAY_UPDATE");
end
 
function Currency:PLAYER_MONEY()
    db.realm[name].money = GetMoney();
end
 
function Currency:CURRENCY_DISPLAY_UPDATE()
    for i = 1, #CURRENCY_ID do
        local currencyName, currencyAmount = GetCurrencyInfo(CURRENCY_ID[i]);
 
        db.realm[name].currency[CURRENCY_ID[i]] = currencyAmount;
    end
end

+ Another question

AceEvent-3.0 has two ways of registering handler function to an event.

First is like my code above, while the second one is passing as a argument on event registration.

e.g:

local function PEW()
    -- Code...
end
 
self:RegisterEvent("PLAYER_ENTERING_WORLD", PEW);

Do they have any big difference?

[myrroddin]

Looking better. Here's a couple of notes:

function Currency:OnEnable()
    self:RegisterEvent("PLAYER_MONEY");
    self:RegisterEvent("CURRENCY_DISPLAY_UPDATE");
    -- call your functions so you get some data right away
    self:PLAYER_MONEY()
    self:CURRENCY_DISPLAY_UPDATE()
end

I am not sure your example question will work with AceEvent-3.0; I read the API and it might work, but I am not convinced. Try it for yourself. I will elaborate what the docs actually mean, as far as I can tell.

self:RegisterEvent("SOME_EVENT", "SomeCallback", arg)
-- "SOME_EVENT" is obviously a WoW event, wrapped in quotes
-- "SomeCallback" (could be "Some_Callback" but never "Some Callback" because that is not how functions are named) is a psuedonym for your event handler.
 
-- basic version
self:RegisterEvent("PLAYER_REGEN_DISABLED") -- in OnEnable()
 
function currency:PLAYER_REGEN_DISABLED()
    -- do something
end
 
-- callback version
self:RegisterEvent("PLAYER_REGEN_DISABLED", "CombatStarted") -- in OnEnable()
 
function currency:CombatStarted()
    -- do something
end

And arg could be anything you pass into your handler function. It could be a string, number, Boolean, etc. As per the AceEvent-3.0 API, you can only pass arg to the callback version of the event handler.

The callback method is convenient if there were, say, a few very similar events (ie: their args are virtually the same) and you wanted to handle all the events in the same function to make things easier on you when coding.

For example, let's say there are three events. Since all events pass the event name as the first arg, I will list the args as expected. However, AceEvent knows this, and you do not need to account for this when registering.

• SOME_ANIMAL(event, "dog")
• CUTE_ANIMAL(event, "cat")
• RIDEABLE_ANIMAL(event, "camel")

Now, you want to register all the events as normal, except that you will pass a callback because you want one function handler for all three events.

-- register events in OnEnable()
self:RegisterEvent("SOME_ANIMAL", "MyAnimal")
self:RegisterEvent("CUTE_ANIMAL", "MyAnimal")
self:RegisterEvent("RIDEABLE_ANIMAL", "MyAnimal")
 
-- in main chunk, handle the events
function MyAddon:MyAnimal(event, arg)
    local WhatIsMyAnimal = arg
    if WhatIsMyAnimal == "dog" then
        print("woof")
    elseif WhatIsMyAnimal == "cat" then
        print("meow")
    else
        print("Gnomes cannot see over a camel's humps!")
    end
end

[Layback_]

Hi again myrroddin,

Thank you so much for such a detailed explanations!

I really appreciate it !!

[myrroddin]

You are most welcome. Another tip: if you register a few events via the callback method, I did mention that they have to have similar args. That said, the args can be sequentially similar.

Let's say your three events return the following, besides the necessary event name itself:

1. unit
2. unit, target
3. unit, target, target of target

function myaddon:SOME_FUNCTION(event, ...)
    local me, you, your_target = ...
end

You could process all three of these events in the same function handler, because the args are sequential. However, the following list will mess you up. You could account for the changes using if/then and = replacement (see SmartRes2's handling of LibResInfo's resurrection and mass resurrection callbacks as examples), but it can get messy.

1. unit
2. target, unit
3. target of target, target, unit

Obviously, these args are not sequential, and the above code will not work.

[myrroddin]

Yet another tip, you can use UnregisterAllEvents() in OnDisable() rather than listing each one individually. Of course, if there were events you do not want unregistered when putting the addon into standby mode, you'd either have to register them again in OnDisable() or list all your events individually.

UnregisterAllEvents() takes no arguments, and it is slower, as AceEvent has to loop through all registered events to unregister them. However, unless you are registering dozens of events and unregistering them rapidly, nobody will ever know you have done this. Modern computers are just way too fast!

Conversely, there is also RegisterAllEvents() which does exactly that: registers all events in the entire game. Unless you are a madman, don't do that!

RegisterEvent, RegisterAllEvents, UnregisterEvent, and UnregisterAllEvents are all native to WoW. AceEvent only really offers passing the additional argument as something new. Also, AceEvent does not support RegisterUnitEvent, but UnregisterAllEvents will unregister those hooks.

In other words, if you ever need to use RegisterUnitEvent, then do not use AceEvent. Do not load it via your toc, do not embed it in your AceAddon addon table creation line, just do not use AceEvent.

[Layback_]

Hi myrroddin,

Thank you for extra tips!

1. What if I was to use a handler to figure out which event is called and pass the arguments like the following?

function Currency:EventHandler(event, ...)
    if event == "PLAYER_MONEY" then
        functionA();
    elseif event == "CURRENCY_DISPLAY_UPDATE" then
        functionB();
    elseif event == "CHAT_MSG_CURRENCY" then
        functionC(...);
    elseif event == "GUILD_ROSTER_UPDATE" then
        functionD(...);
    end
end

"PLAYER_MONEY" and "CURRENCY_DISPLAY_UPDATE" doesn't have an argument, but "CHAT_MSG_CURRENCY" and "GUILD_ROSTER_UPDATE" have some arguments which differ from each other.

In that case, should I still consider making separate handler for those events?

2. To be honest, I still haven't decided whether I should keep using an AceEvent-3.0 or not

[Lombra]

The main reason for separating event handling code is for your own readability. Long if-chains can be difficult to read, and separating the event can make the code neat.

I wouldn't recommend using AceEvent. It's not bad, it just doesn't do anything that you can't accomlish yourself with a couple of lines of code. (unless maybe if you want to use internal addon callbacks)

local frame = CreateFrame("Frame")
frame:SetScript("OnEvent", function(self, event, ...)
	Currency[event](Currency, ...)
end)

This will look for a method on your Currency object with the same name as the triggered event. If you want a custom method name you'll just do this:

function Currency:EVENTX()
end

Currency.OnEventX = Currency.EVENTX

[myrroddin]

What Lombra said. There are two main reasons to use AceEvent-3.0:

• Hooking two or more events to the same function (function, handler, and callback all basically mean the same thing)
• Passing an additional argument to the function that the events do not pass

There are also two main reasons to not use AceEvent-3.0:

• As Lombra showed, unless you need the above functionality, it brings nothing but overhead
• It does not support RegisterUnitEvent, and can conflict if not processed correctly

If you are on the fence about whether or not to use AceEvent, then I suggest not to use it.

[Layback_]

Many thanks to Lombra and myrroddin.

Yeah, guess I should not use AceEvent-3.0 until I see the necessity

Gotta change all my codes haha

[Layback_]

Oh, and this might be the very last question.

It's not related to Ace3, but is kinda close to the topic of this thread(?).

How do you guys think of functions being created within a function like the following?

-- Get addon ----------------------------------------------------------------------
local Core = LibStub("AceAddon-3.0"):GetAddon("Core");
local ExtraPower = LibStub("AceAddon-3.0"):GetAddon("ExtraPower");
 
-- Declare module -----------------------------------------------------------------
local Power = ExtraPower:NewModule("Power");
 
local ADDITIONAL_BAR_NAME = ADDITIONAL_BAR_NAME;
local ADDITIONAL_BAR_INDEX = ADDITIONAL_BAR_INDEX;
 
-- Declare & define variables -----------------------------------------------------
local db;
 
local LSM = LibStub("LibSharedMedia-3.0");
local font = LSM:Fetch("font", "MeatEdition");
local statusbar = LSM:Fetch("statusbar", "fer28");
 
local InitObjects;
 
function Power:OnInitialize()
    db = ExtraPower.db.global;
 
    self:SetEnabledState(db.modules[self:GetName()]);
end
 
function Power:OnEnable()
    InitObjects();
end
 
function Power:OnDisable()
    
end
 
function InitObjects()
    local bar = CreateFrame("StatusBar", ExtraPower:GetName() .. "Bar", UIParent);
    bar:RegisterEvent("PLAYER_ENTERING_WORLD");
    bar:RegisterUnitEvent("UNIT_POWER_FREQUENT", "player", "vehicle");
    bar:RegisterUnitEvent("UNIT_DISPLAYPOWER", "player");
    bar:SetMinMaxValues(0, 100);
    bar:SetStatusBarTexture(statusbar);
    bar:SetSize(db.power.bar.width, db.power.bar.height);
    bar:SetPoint(unpack(db.power.bar.point));
    bar:SetTemplate(true);
    bar:SetBackground();
 
    function bar:OnEvent(event, ...)
        if event == "PLAYER_ENTERING_WORLD" then
            self:PLAYER_ENTERING_WORLD();
        elseif event == "UNIT_POWER_FREQUENT" then
            self:UNIT_POWER_FREQUENT(...);
        elseif event == "UNIT_DISPLAYPOWER" then
            self:UNIT_DISPLAYPOWER();
        end
    end
 
    function bar:PLAYER_ENTERING_WORLD()
        -- ...
    end
 
    function bar:UNIT_POWER_FREQUENT(...)
        -- ...
    end
 
    function bar:UNIT_DISPLAYPOWER()
        -- ...
    end
 
    bar:SetScript("OnEvent", bar.OnEvent);
 
    bar.playerClass = nil;
 
    Power.bar = bar;
 
    local text = bar:CreateFontString("$parentText", "OVERLAY");
    text:SetFont(font, 12, "OUTLINE");
    text:SetAllPoints();
 
    bar.text = text;
end

The reason that I have done this is to prevent those 'bar' related event functions being created when the frame (bar) doesn't even exist, yet, and I would like to avoid wasting a memory by creating those functions in local which will never be used when module is disabled.

However, I have seen a post saying that this kind of structure has performance issue as it takes more time than it does with creating a local functions.

[myrroddin]

That looks confusing to me.

You can blend Ace3 and vanilla WoW code easily enough.

function Currency:OnInitialize()
    Currency.eventFrame = CreateFrame("Frame") -- OnInit only fires once, so creating frames and setting their parameters here would be a good idea    
end
 
function Currency:OnEnable()
    -- mimic AceEvent without the callback or extra arg
    -- basic functionality, but it works
    -- you also gain RegisterUnitEvent yay!!
    Currency.eventFrame:SetScript("OnEvent", function(self, event, ...)
        Currency[event](Currency, ...) -- notice the change on this line?
    end)
 
    Currency.eventFrame:RegisterEvent("SOME_EVENT")
    Currency.eventFrame:RegisterEvent("ANOTHER_EVENT")
    Currency.eventFrame:RegisterUnitEvent("PLAYER_EVENT", "player", "target")
end
 
function Currency:OnDisable()
    Currency.eventFrame:UnregisterAllEvents()
end
 
function Currency:SOME_EVENT()
    -- do something
end
 
-- etc
-- etc

Here are some issues I have with your InitObjects()

• It is not a local function, but should be
• You have some things in there that should be done only once, like creating frames, which is presumably good, yet there are other things that ought to be handled multiple times like registering events
• Nothing wrong with having your event handlers inside that function, but it doesn't look easy to debug in a year or two

[Layback_]

Just edited codes based on your advice!

-- Get addon ----------------------------------------------------------------------
local Core = LibStub("AceAddon-3.0"):GetAddon("Core");
local ExtraPower = LibStub("AceAddon-3.0"):GetAddon("ExtraPower");
 
-- Declare module -----------------------------------------------------------------
local Power = ExtraPower:NewModule("Power");
 
-- Upvalue variable ---------------------------------------------------------------
local ADDITIONAL_BAR_NAME = ADDITIONAL_BAR_NAME;
local ADDITIONAL_BAR_INDEX = ADDITIONAL_BAR_INDEX;
 
-- Declare & define variables -----------------------------------------------------
local db;
 
local LSM = LibStub("LibSharedMedia-3.0");
local font = LSM:Fetch("font", "MeatEdition");
local statusbar = LSM:Fetch("statusbar", "fer28");
 
local InitObjects, UpdateBarAndText;
 
function Power:OnInitialize()
    db = ExtraPower.db.global;
 
    if db.modules[self:GetName()] then
        InitObjects();
    end
 
    self:SetEnabledState(db.modules[self:GetName()]);
end
 
function Power:OnEnable()
    local bar = Power.bar;
 
    bar:RegisterEvent("PLAYER_ENTERING_WORLD");
    bar:RegisterUnitEvent("UNIT_POWER_FREQUENT", "player", "vehicle");
    bar:RegisterUnitEvent("UNIT_DISPLAYPOWER", "player");
 
    bar:SetScript("OnEvent", function(self, event, ...)
        Power[event](Power, self, ...);
    end);
end
 
function Power:OnDisable()
    local bar = Power.bar;
 
    bar:UnregisterAllEvents();
end
 
function Power:PLAYER_ENTERING_WORLD()
    UpdateBarAndText();
 
    self:UnregisterEvent("PLAYER_ENTERING_WORLD");
end
 
function Power:UNIT_POWER_FREQUENT()
    UpdateBarAndText();
end
 
function Power:UNIT_DISPLAYPOWER()
    UpdateBarAndText();
end
 
function InitObjects()
    local bar = CreateFrame("StatusBar", ExtraPower:GetName() .. "Bar", UIParent);
    bar:SetMinMaxValues(0, 100);
    bar:SetStatusBarTexture(statusbar);
    bar:SetSize(db.power.bar.width, db.power.bar.height);
    bar:SetPoint(unpack(db.power.bar.point));
    bar:SetTemplate(true);
    bar:SetBackground();
 
    local text = bar:CreateFontString("$parentText", "OVERLAY");
    text:SetFont(font, 12, "OUTLINE");
    text:SetAllPoints();
 
    Power.bar = bar;
 
    bar.playerClass = nil;
    bar.text = text;
end

1. Transferred RegisterEvent(...) functions to :OnEnable() function from InitObjects() function.

2. Added UnregisterAllEvents(...) function on :OnDisable() function.

3. Transferred InitObjects() function (which creates frames and other objects) call to :OnInitialize() function from :OnEnable() function.

4. On L#39, I've added self (bar) as an argument for just in case if I need them (which would be redundant as Power.bar is same anyways ).

If I missed something, please let me know!!

+ About InitObject() function, I have been told that once it is declared as local at the top of .lua file, it functions as local, thus I didn't put local at L#63.

[Layback_]

Here's one more question!!

How would you manage a module with more than one lua files?

For example, my Unitframe (which I made with oUF) is made up of five different lua files called:

• api.lua: Holds 24 local functions to create a unitframe
• core.lua: Responsible for style registration and actual unitframe spawning
• group.lua & unit.lua: Nothing really special
• unitframe.lua: Being a core part of module (Those AceAddon-3.0 functions, :OnInitialize(), :OnEnable() & :OnDisable() functions are called here)

If the module is disabled, those 24 local functions and function calls on core.lua becomes useless, but occupies memory.

What would be the best practice for this case?

[myrroddin]

You would load those lua files in your toc as usual. When the module is disabled, you are correct, their functionality also gets disabled, and Lua will garbage collect as usual.

Without more information, that is the best answer I can provide right now.

[Layback_]

Hm... I'm still confused.

You mean that those local functions will also get collected by garbage collection?

Here I've attached my addon.

If you don't mind, could you please have a look at them when you have a spare time?
(OnInitialize(), OnEnable() & OnDisable() functions for Unitframe module are not properly used, yet...)

Thank you!!