How do I do a wait() function?

[aadenboy]

How would I have the code pause when I want it to with a wait() function? I'm not sure how to make one.

[nesbox]

There is no wait function, but you can do something like this

local t=0
function TIC()
    cls(12)
    t=t+1
    
    -- wait 2 seconds
    if t<2*60 then return end
    
    print("HELLO WORLD!",84,64)
end

[aadenboy]

what if I wanted to do that inside of a function?

[joshgoebel]

You really can't. But you might want to look into coroutines or fibers. Some languages make this easier than others to have functions that can wait/yield.

Then your TIC function just sets up your fiber/coroutine and passes control to it every frame.

But really it's not a common pattern most people use.

Sorry I don't have an example.

[aadenboy]

I figured out how to use coroutines, and made some code, thanks!

-- part of a function
if chrData.inv[chrData.selected] ~= nil then
			if success and chrData.inv[chrData.selected].placeable then
				tiles[#tiles+1] = {
					position = {
						xPos = math.round(((x - 4) + xOffset) / 8),
						yPos = math.round(((y - 4) + yOffset) / 8)
					},
					type = chrData.inv[chrData.selected].linkedblock
				}
				nextcode = coroutine.create(function ()
           table.remove(chrData.inv, chrData.selected)
         end)
				wait(5)
			end
		end

-- part of TIC()

if dowait then
		waittime = waittime + 1
		
		if waittime >= ending * 60 then
			waittime = 0
			dowait = false
			coroutine.resume(nextcode)
		end
	end

Edit: wait is a function that just assigns two variables

[farvardin]

I was looking for something similar.
At the moment I'm using this

function wait(a)
	t1=time()
	t2=time()
	while ((t2-t1)<=a)
	do
		t2=time()
	end
end

and I can wait(1000) one second for example. But the problem is when the wait function is working, the mouse is stalled and it just looks ugly.

I don't really understand your function.

[franalbani]

function sleep(duration_ms)
  t0 = time()
  while time() - t0 < duration_ms
  do
  end
end

[farvardin]

just to be helpful, since no one mentioned this yet, instead of "burning CPU" with some kind of wait function, if you need to delay some action, if possible it's better to use the modulo, for example instead of:

wait(500)
dosomething()

use:

if t%30 == 0 then
dosomething()
end

[atesin]

what about something like...

delayTimer=0

function TIC()

  if delayTimer > 0 then
    delayTimer = delayTimer -1
    return
  end

  -- do stuff
  
  while someCondition do
    -- do more stuff

    -- DELAY like emulation
    if otherCondition() then
      delayTimer = 30
      return
    end
  end
  
  -- do even more stuff
end 

this is quick, but it has the disadvantage that can't resume the program flow where were left

i learned this the hard way... in my ignorance, i did while true then end making tic-80 eat all my real cpu, i had to kill it through task manager and lose all my unsaved work xD... then l learn to call return instead (i guess tic-80 does stuff while outside TIC() like read keyboard)

[atesin]

version 2: using time() instead

-- global variable
delayTimer=time()-2000 -- this prevents delay trigger at program start

function TIC()

  -- check for a 2 seconds delay (the good way, see note below)
  if time()-delayTimer<2000 then return end
 
  doSomething()

  if needsDelay() then -- set delay and skip further execution
    delayTimer=time()
    return
  end

  doSomethingNew()
end

time difference has to be calculated everytime to avoid delay imprecisions
when time() overflows, wraps around 0 (resets) and starts counting again
(actually also fails with delays near INT_MAX, but such huge delays are unlikely)

[AdriProg2000]

@nesbox Can you add a function sleep() or wait()?

[D4yvid]

A simple sleep function for Lua that allows you to run other code while sleep is happening:

Untitled.mov

local tasks = {}

-- https://stackoverflow.com/questions/640642/how-do-you-copy-a-lua-table-by-value
function copy(obj, seen)
  if type(obj) ~= 'table' then return obj end
  
  if seen and seen[obj] then return seen[obj] end
  
  local s = seen or {}
  local res = setmetatable({}, getmetatable(obj))
  
  s[obj] = res
  
  for k, v in pairs(obj) do res[copy(k, s)] = copy(v, s) end
  return res
end

function sleep(duration_ms, on_finish) -- Tick is relative to TIC() function rate
  local target = time() + duration_ms

  table.insert(tasks, coroutine.create(function ()
    while time() < target do
      coroutine.yield()
    end

    on_finish()
  end))
end

message = "Hello, (waiting...)"

function TIC()
  -- Make a copy so we do not remove a index from a table that is being iterated
  local runningTasks = copy(tasks)

  -- NOTE: if this code isn't being called periodically, all `sleep` tasks will be delayed and/or never called. I'd recommend put this at the top of the TIC function
  for idx, task in pairs(runningTasks) do
    -- Will resume all submitted sleep tasks, until a `coroutine.yield` is found
    coroutine.resume(task)
    
    if (coroutine.status(task) == "dead") then
      -- Finished execution, remove
      table.remove(tasks, idx)
    end
  end
  
  -- from example 1: (should remove if using this)
  cls(0)
  print(message)
  
  -- ... other code
end

-- example 1:
sleep(1000, function ()
  message = "Hello, world!"
end)

sleep(2000, function ()
  message = "Hello, world!!"
end)

sleep(2500, function ()
  message = "Hello, world!! (you really waited!!)"
end)

How it works?

Lua Coroutines are like functions, but they can be suspended at any point (coroutine.yield() is for suspending a coroutine function), and the code uses this mechanism to see if the timer is already reached it's target

If the timer already reached it's target, the while loop will be false and it will execute the callback function before returning. When a coroutine function returns instead of suspending with coroutine.yield(), it's status is set to "dead", to indicate that it's operation finished executing.

So what the code is really doing is iterating through all the timers that the sleep function created, and checking each one to see if the timeout has passed, if the timeout did in fact ended, the callback will be executed and the coroutine will die, otherwise, the coroutine will suspend itself and will run the loop again, until there's no more coroutines to check and it will just run the other code as nothing happened.

[Anrock]

That's pretty much a small task scheduler.

I wonder if coroutines are necessary here? TIC() is called every 16ms, so it seems like you could decrement time of each scheduled functions on every TIC and when time <= 0 just do on_finish().

[D4yvid]

No, the coroutines are not needed, i've only used them because they're so simple and they maintain their own "space" to handle these.

For simple scenarios like just sleeping, it's a little overkill. I've sent this code because my scenario runs lots of different tasks instead of sleep, but it is a solution! People can use it to submit other tasks, like, repeating timers are just sleep() that calls sleep() again at the end of the scope, so something like this can be done:

function repeating(func, delay)
  local run = true

  function loop()
    if run then
      sleep(delay, loop)
      func()
    end
  end

  sleep(delay, loop)

  return {
    cancel = function ()
      run = false
    end
  }
end

[atesin]

A simple sleep function for Lua that allows you to run other code while sleep is happening:
Untitled.mov

local tasks = {}

-- https://stackoverflow.com/questions/640642/how-do-you-copy-a-lua-table-by-value
function copy(obj, seen)
  if type(obj) ~= 'table' then return obj end
  
  if seen and seen[obj] then return seen[obj] end
  
  local s = seen or {}
  local res = setmetatable({}, getmetatable(obj))
  
  s[obj] = res
  
  for k, v in pairs(obj) do res[copy(k, s)] = copy(v, s) end
  return res
end

function sleep(duration_ms, on_finish) -- Tick is relative to TIC() function rate
  local target = time() + duration_ms

  table.insert(tasks, coroutine.create(function ()
    while time() < target do
      coroutine.yield()
    end

    on_finish()
  end))
end

message = "Hello, (waiting...)"

function TIC()
  -- Make a copy so we do not remove a index from a table that is being iterated
  local runningTasks = copy(tasks)

  -- NOTE: if this code isn't being called periodically, all `sleep` tasks will be delayed and/or never called. I'd recommend put this at the top of the TIC function
  for idx, task in pairs(runningTasks) do
    -- Will resume all submitted sleep tasks, until a `coroutine.yield` is found
    coroutine.resume(task)
    
    if (coroutine.status(task) == "dead") then
      -- Finished execution, remove
      table.remove(tasks, idx)
    end
  end
  
  -- from example 1: (should remove if using this)
  cls(0)
  print(message)
  
  -- ... other code
end

-- example 1:
sleep(1000, function ()
  message = "Hello, world!"
end)

sleep(2000, function ()
  message = "Hello, world!!"
end)

sleep(2500, function ()
  message = "Hello, world!! (you really waited!!)"
end)

How it works?

Lua Coroutines are like functions, but they can be suspended at any point (coroutine.yield() is for suspending a coroutine function), and the code uses this mechanism to see if the timer is already reached it's target

If the timer already reached it's target, the while loop will be false and it will execute the callback function before returning. When a coroutine function returns instead of suspending with coroutine.yield(), it's status is set to "dead", to indicate that it's operation finished executing.

So what the code is really doing is iterating through all the timers that the sleep function created, and checking each one to see if the timeout has passed, if the timeout did in fact ended, the callback will be executed and the coroutine will die, otherwise, the coroutine will suspend itself and will run the loop again, until there's no more coroutines to check and it will just run the other code as nothing happened.

very cool technique... but this is more like JS setTimeout(fn, ms) function than sleep(ms), where you schedule a function to be run later ... still very useful though

because instead write something like:

sleep(1000)
print('hello')

with this we must actually write something like this?

sleep(1000, print('hello'))

i suggest change the function name to runLater() or something... i am learning lua too, thanks

[AdriProg2000]

Thanks! El mié, 30 jul 2025 a las 15:19, Dayvid Albuquerque (< ***@***.***>) escribió:

…

No, the coroutines are not needed, i've only used them because they're so simple and they maintain their own "space" to handle these. — Reply to this email directly, view it on GitHub <#1864 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/BPW6R2ATVLURLJCLX7QP5JT3LDA6BAVCNFSM6AAAAAB2ZWBUWKVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTGOJTGQ3DMMA> . You are receiving this because you commented.Message ID: ***@***.***>