Adding a delay to the execution of a loop

[Eommus]

Hi,

I use the following code to sell all items in a given bag, which is triggered when I click a Sell button for that bag.

function SellAllInBag(bag)
	for slot = 1, GetContainerNumSlots(bag) do
		UseContainerItem(bag, slot)
	end
end

The above loop tries to sell all the items in the bag at the same time, so it gets stuck and I have to click the Sell button 2-3 times to sell all items in a large bag.

What I am looking for is to add some sort of a delay (e.g. 0.1 seconds) to the loop, so that it will sell all items with one click without getting stuck.

Something like:

function SellAllInBag(bag)
	for slot = 1, GetContainerNumSlots(bag) do
		UseContainerItem(bag, slot)
		-- wait for 0.1 seconds, then continue with the loop
	end
end

Is that possible in LUA coding?

Thanks.

[zork]

I use C_Timer.After for that.
https://github.com/zorker/rothui/blo.../core.lua#L118

[kurapica.igas]

I have post a new framework named Scorpio, it'd provide a code style like :

__Thread__()
function SellAllInBag(bag)
    for slot = 1, GetContainerNumSlots(bag) do
        UseContainerItem(bag, slot)
        Delay(0.1)
    end
end

But you couldn't use a framework only for one feature, so there is another way :

local function delay(tick)
    local th = coroutine.running()
    C_Timer.After(tick, function() coroutine.resume(th) end)
    coroutine.yield()
end
 
function SellAllInBag(bag)
    for slot = 1, GetContainerNumSlots(bag) do
        UseContainerItem(bag, slot)
        delay(0.1)
    end
end
 
-- Call the function as coroutine
coroutine.wrap(SellAllInBag)(0)

Since the code is simple, you can use zork's solution, but it's better to use the coroutine when it's too hard to track the process states.

[Kanegasi]

Here's my take on using C_Timer.After for this:

function SellAllInBag(bag)
    for slot = 1, GetContainerNumSlots(bag) do
        C_Timer.After(slot/10, UseContainerItem(bag, slot) )
    end
end

I don't know how expensive this is, but it will schedule several timers with increasing delays all at once. The first action will be 0.1 seconds after the function is called, next will be 0.2 seconds, and so on.

[Ammako]

I know that, 1:1, it is less efficient/more expensive than C_Timer.After, but would C_Timer.NewTicker be fine for this? Or would it still be less efficient than scheduling dozens of C_Timer.After?

Though it looks like NewTicker doesn't let you pass arguments to the function being called, so you'd have to do something silly like using external variables instead.

PoC:

local slot
local currentBag
 
local function SellAllInBag()
    print("Bag number: " .. currentBag) -- debug
    print("Item slot being sold: " .. slot) -- debug
    UseContainerItem(currentBag, slot)
    slot = slot + 1
end
 
local function DoThing(bag)
    slot = 1
    currentBag = bag
    local timer = C_Timer.NewTicker(0.1, SellAllInBag, GetContainerNumSlots(bag))
end

Works as expected if I run DoThing([bag number]).

[MunkDev]

SellAllInBag = CreateFrame('Frame')
SellAllInBag.itemsToSell = {}
SellAllInBag.pendingBags = {}
 
function SellAllInBag:SetCurrentBag(bagID)
    wipe(self.itemsToSell)
    self.currentBagID = bagID
    self.itemsSold = 0
 
    local toggleEvent = (bagID ~= nil) and self.RegisterEvent or self.UnregisterEvent
 
    toggleEvent(self, 'BAG_UPDATE')
    toggleEvent(self, 'BAG_UPDATE_DELAYED')
end
 
function SellAllInBag:AttemptSellItems(index)
    for i=index or 1, #self.itemsToSell do
        UseContainerItem(self.currentBagID, self.itemsToSell[i])
    end
end
 
function SellAllInBag:ProcessNextInQueue()
    local bagInQueue = tremove(self.pendingBags, 1)
    if bagInQueue then
        self(bagInQueue)
    end
end
 
function SellAllInBag:OnEvent(event)
    if ( event == 'BAG_UPDATE' ) then
        self.itemsSold = self.itemsSold + 1
    elseif ( event == 'BAG_UPDATE_DELAYED' ) then
        if ( self.itemsSold == #self.itemsToSell ) then
            self:SetCurrentBag(nil)
            self:ProcessNextInQueue()
        else
            self:AttemptSellItems(self.itemsSold)
        end
    elseif ( event == 'MERCHANT_SHOW' ) then
        self.merchantAvailable = true
    elseif ( event == 'MERCHANT_CLOSED' ) then
        self.merchantAvailable = false
        self:SetCurrentBag(nil)
        wipe(self.pendingBags)
    end
end
 
SellAllInBag:RegisterEvent('MERCHANT_SHOW')
SellAllInBag:RegisterEvent('MERCHANT_CLOSED')
SellAllInBag:SetScript('OnEvent', SellAllInBag.OnEvent)
 
setmetatable(SellAllInBag, {
    __index = getmetatable(SellAllInBag).__index;
    __call = function(self, bagID)
    --------------------------------------------------
        if self.merchantAvailable then
            if not self.currentBagID then
                self:SetCurrentBag(bagID)
 
                local itemsToSell = self.itemsToSell
                for slot=1, GetContainerNumSlots(bagID) do
                    local link = select(7, GetContainerItemInfo(bagID, slot))
                    local sellPrice = (link and select(11, GetItemInfo(link))) or 0
 
                    if sellPrice > 0 then
                        itemsToSell[#itemsToSell + 1] = slot
                    end
                end
 
                if #itemsToSell > 0 then
                    self:AttemptSellItems()
                else
                    self:SetCurrentBag(nil)
                end
            else
                tinsert(self.pendingBags, bagID)
            end
        end
    --------------------------------------------------
    end;
})

Here's a robust solution for you. Using C_Timer.After is bad for multiple reasons, one of which is asynchronous execution.
Unlike the others, this takes into account if you're actually interacting with an NPC and it is safe to use even if you have massive lag.
It's a bit over-engineered, but I think this is your best bet. You can also run this for multiple bags and it'll queue them up and finish them off in order.

The way it works is it attempts to sell as many items as possible at once, counting each item that goes through, but when the server throttles your request, it'll queue a new attempt to sell as many items as possible from the items you have remaining in your bag. It will look like chunks of items are disappearing out of your bags.

Usage:

SellAllInBag(0)

[Eommus]

Thank you all for your inputs.

I tried the following, based on zork's sample code:

function SellAllInBag(bag)
	for slot = 1, GetContainerNumSlots(bag) do
		UseContainerItem(bag, slot)
	end
	C_Timer.After(0.1, SellAllInBag(bag))
end

It freezed the game. After I quit and logged back in, the items were sold. Probably I used C_Timer.After at the wrong place.

I tried Kanegasi's example, it sold only the first item in the bag and gave this error:

Message: Interface\AddOns\SellAll\SellAll.lua:3: Usage: C_Timer.After(seconds, func)
Time: 02/25/18 10:43:14
Count: 1
Stack: Interface\AddOns\SellAll\SellAll.lua:3: Usage: C_Timer.After(seconds, func)
[C]: ?
[C]: in function `After'
Interface\AddOns\SellAll\SellAll.lua:3: in function `SellAllInBag'
[string "*:OnClick"]:1: in function <[string "*:OnClick"]:1>

Locals:

I tried kurapica.igas sample code with coroutine, it sold only the first item in the bag and gave this error:

Message: attempt to yield across metamethod/C-call boundary
Time: 02/25/18 10:52:45
Count: 1
Stack: attempt to yield across metamethod/C-call boundary
[C]: ?
[C]: in function `yield'
Interface\AddOns\SellAll\SellAll.lua:4: in function <Interface\AddOns\SellAll\SellAll.lua:1>
Interface\AddOns\SellAll\SellAll.lua:10: in function `SellAllInBag'
[string "*:OnClick"]:1: in function <[string "*:OnClick"]:1>

Locals:

Ammako's solution seems to be working nicely, thank you again. I will continue my tests and give an update here shortly.

MunkDev, thank you for such a detailed solution. I always try to keep things as simple as possible, and in a way that I can understand and modify when needed. Can't tell if Ammako's solution is more or less efficient but it seems more preferrable to me due to its simplicity.

Just one thing: Will Ammako's timer(s) continue to tick in the background after all the items are sold in the bag? That wouldn't be ideal.

[MunkDev]

It's a terrible solution for the reasons I mentioned. It can also break in the exact same way you wanted to work around if you're having a massive lag spike.
You need more than this to be able to handle server throttling, not causing errors due to attempting to use inventory items from code and handling when you step away from the NPC. It's not more complicated than it actually needs to be for the feature you want, especially if you're going to release it as an addon for others to use. My solution is more efficient because it doesn't use C_Timer and actually reacts to the event that tells you when your request is throttled.

• UseContainerItem is a protected function, which doubles as a sell function. If you run a ticker function with UseContainerItem wrapped inside and you happen to be in combat, you had better keep talking to the NPC or you'll get action blocked messages.
• If you step away from the merchant while the ticker is executing, you'll end up trying to use/equip every item left on the ticker.
• Simplest code, but doesn't actually work properly.

[Ammako]

Your first attempt freezes the game because you recursively keep calling the function from within itself. Infinite loop.

Go with MunkDev's, they're way more experienced and know what they're talking about.

[Kanegasi]

I realized the problem with my code. I forgot C_Timer.After needs a direct function and cannot "call" one, as in it needs an anonymous function() end or the name of a function with no parenthesis. We're passing a function in as an argument to the After() function. Try this:

function SellAllInBag(bag)
    for slot = 1, GetContainerNumSlots(bag) do
        C_Timer.After(slot/10, function()
            UseContainerItem(bag, slot)
        end)
    end
end

I am sort of confused as to how the original even sold that first item.

If this works, as in it sells a bunch of items, but it doesn't sell everything, just adjust the slot/10. Even though the slot variable changes, the delay between each action is equal to the first delay, which is 1/10. If you wanted a delay of 0.5 sec, you would use slot/2.

[zork]

Here is my approach: https://github.com/zorker/rothui/blo.../rSellPoor.lua