Bom, o que ela faz é retornar o valor em horas, minutos e segundos baseado em um tempo de segundos...

Por exemplo:

Espero que tenham entendido

A função:

http://pastebin.com/Mkqf7gJe

Observações:

Ela retorna um array com, respectivamente, as horas, os minutos e os segundos do tempo que você inseriu

EXEMPLO USANDO 3665 SEGUNDOS

time = 3665
print(horas: "..formatTimeBySeconds(time)[1].." / minutos: "..formatTimeBySeconds(time)[2].." / segundos: formatTimeBySeconds(time)[3])

Resultado no console: horas: 1 / minutos: 1 / segundos: 5

Preferi deixar assim porque você nem sempre precisa saber as horas, ou os segundos de um tempo.

Coisas legais que descobri:

os.time() tem 43 anos, 19 dias (vai aumentando conforme o tempo passa) - ou, caso prefira, 377.150 horas!

FYI, essa função é custosa (demora mais que o método ideal pra ser executada, ou seja, é lenta) por causa dos whiles. Imagine o seu exemplo com o os.time(). Só para calcular os anos, o while rodou 43 vezes.

Existe um método melhor para converter esse tipo de dados, usando módulo (em Lua, é o operador %). O módulo retorna o resto de uma divisão, ou seja:

8 % 3 => 2

Significa que 8 dividido por 3 resta 2.

Usando isso, podemos converter um número de segundos em minutos, horas, ou o que for, usando uma operação matemática, que pode ser executada "instantaneamente".

Supondo que temos 100 segundos, que equivalem à 1 minuto e 40 segundos. Se dividirmos 100 por 60, obteremos 1.666... A parte fracionária desse número (0.666...) equivale aos outros 40 segundos. Se pegarmos somente e parte inteira (1), já temos o número de minutos! Mas agora precisamos ajustar o número de segundos que sobraram. Para isso, usamos o módulo para pegar o resto da divisão. Se pegarmos o resto da divisão de 100 por 60, dá 40. Com isso, podemos fazer o código que pega o número de minutos do os.time(), por exemplo.

local seconds = os.time()

local minutes = math.floor(seconds / 60) -- Pega o número de minutos em "seconds"
seconds = seconds % 60 -- Ajusta os segundos que sobraram

Para pegar o número de horas em tantos minutos, dias em tantas horas, meses em tantos dias, anos em tantos meses e et cetera, a ideia é exatamente a mesma.

local seconds = os.time()
local minutes, hours, days, months, years

minutes = math.floor(seconds / 60)
seconds = seconds % 60

hours = math.floor(minutes / 60)
minutes = minutes % 60

days = math.floor(hours / 24)
hours = hours % 24

months = math.floor(days / 30)
days = days % 30

years = math.floor(months / 12)
months = months % 12

Edit: Só por curiosidade, o os.time() retorna o tempo do sistema, que geralmente é medido em número de segundos decorridos desde o "epoch" (no tempo POSIX). Ou seja, o número de segundos desde 1 de Janeiro de 1970. Por isso dá 43 anos. Estamos em 2013: 2013-1970=43!

õ_o nem imaginei esse negócio de resto e de floor

muito bom cara, até porque o while tava dando lag mesmo T_T

vou ter que te dar rep+ , flw e parabéns ai por chegar nesse raciocínio

edit

edit²

e funcionou mesmo xD

o raciocinio tb poderia ter vindo dessa funçao aki q vem como padrao na lib.. ^^

string.timediff = function (diff)
   local format = {
       {"week", diff / 60 / 60 / 24 / 7},
       {"day", diff / 60 / 60 / 24 % 7},
       {"hour", diff / 60 / 60 % 24},
       {"minute", diff / 60 % 60},
       {"second", diff % 60}
   }

   local t = {}
   for k, v in ipairs(format) do
       local d, tmp = math.floor(v[2]), ""
       if(d > 0) then
           tmp = (k < table.maxn(format) and (table.maxn(t) > 0 and ", " or "") or " and ") .. d .. " " .. v[1] .. (d ~= 1 and "s" or "")
           table.insert(t, tmp)
       end
   end

   return t
end

O raciocínio não é meu, essa é a técnica padrão pra trabalhar com conversão de data e hora, que é utilizada à muitos anos. Apenas expliquei como funciona, porque acho que todo programador vai ter esse problema um dia, e todos deveriam saber resolver de forma eficiente. (Eu já fiz conversão de data e hora com while também!)

Agora pode parecer coisa besta, mas conforme você vai melhorando, começa a perceber que vários problemas teriam uma solução mais rápida, e começa a pensar na otimização do seu código. Um exemplo de experiência própria: estou fazendo uma biblioteca (que daqui uns dias vai ficar pronta e vou postar aqui), e entre uma das utilidades dela, possui uma função para gerar círculos à partir de uma posição central e o raio do círculo.

A ideia inicial é pegar o raio, duplicar, e fazer dois fors percorrendo todas as posições dentro da área formada pelo dobro do raio. Para um círculo de raio 5, por exemplo, a função rodaria os loops 100 vezes ((5*2)*(5*2)). Pode não parecer, mas esse é um numero muito grande em questão de desempenho. Imagine um círculo de raio 500, seriam 1000000 iterações!! Seu servidor travaria por vários segundos (talvez até minutos), e provavelmente seria morto pelo sistema operacional por usar memória demais dependendo do que você estiver fazendo.

Para quem não se importa com otimização, isso é suficiente. Mas quando você começa a se preocupar com otimização, algumas soluções bem mais fáceis e rápidas surgem em mente. Para resolver o problema acima, eu apenas espelhei um dos quadrantes do círculo. Afinal, ele é simétrico! Todos os quadrantes são iguais, apenas invertidos. Meu código ficou 4 vezes mais rápido, pois agora para um círculo de raio 5, eu percorro uma área apenas 5*5!

Depois disso, pensei em uma outra otimização bem mais complexa, onde eu efetivamente só passo pelas posições que o circulo vai realmente ocupar. Ou seja, se meu círculo tem área 5, só vão ser executados 5 loops. Isso faz muita diferença, principalmente quando você possui 300 jogadores fazendo várias coisas. Cada milisegundo é importante.