[edit: não resolvido] Timelines - revisão

Faz anos que não uso uma timeline. Agora, acho que tenho um jogo que fará bom uso delas. E já não sei mais como usá-las. Então venho pedir ajuda.

Por favor, direcionem as dicas para o GMS.

1 - Tenho uma constante (não é uma variável) chamada "rmSpeed" que é o tempo em que eu quero que a ação se repita (a cada "rmSpeed", a ação se repete). Com alarms é fácil fazer isso: alarm[?] = rmSpeed. Mas como fazer isso numa timeline? Só vi a opção de acrescentar eventos em momentos numéricos.

2 - Pretendo usar uma timeline pra criar inimigos e outra pra tocar sons. Mas pra rodar a timeline, só vi as variávies timeline_index (dá à instância uma timeline), timeline_running (começa a rodar a timeline) e timeline_loop (coloca a timeline num loop). É possível colocar duas, três ou mais timelines rodando na mesma instância? Fiquei com a idéia que só uma timeline_index pode ser usada por instância (testes parecem confirmar a hipótese).

3 - Como sincronizar perfeitamente uma timeline com um alarm? Tipo, eu quero que o evento da timeline ocorra no mesmo step que o evento do alarm[0]. Aí, no create, eu coloco "alarm[0] = 14; timeline_index = TL_tal; timeline_running = true;". Em que momento da timeline eu devo colocar o evento?
Em outras palavras: Em que momento eu devo colocar o evento da timeline de forma que colocar no create

Código:

timeline_index = TL_tal;
timeline_running = true;
timeline_loop = true;

seja o mesmo que colocar no create E no alarm[0]

Código:

alarm[0] = 14;
// + evento do alarm[0]

?

Para usar mais de uma timeline em uma mesma instância, você precisa criar o seu próprio sistema. O do GM se limita a uma.

Código:


//tempo relativo ao momento em que a timeline for iniciada
timeline_moment_add(timeline_index, 14 , codigo);
timeline_moment_add(timeline_index, 14+room_speed, codigo); //1 segundo depois

timeline_running = true;
timeline_loop = true;


Ou seja, ela vai se repetir a cada 14 steps.

Tenho a impressão de que é necessário criar uma timeline em tempo real para poder modificá-la.

Beleza, isso responde às 3 perguntas, mas a resposta da segunda ficou um pouco vaga. Acho que é porque eu estou com dificuldade pra FORMULAR a pergunta. Deixa eu tentar de novo.

Quando eu aciono um alarm, ponho nele o valor, tipo, 5, tenho a certeza de que dali a 18 steps ele vai rodar o evento. Porque ele agora vale 5, no step seguinte vale 4, depois 3, 2, 1. 5 steps depois, sem contar o step "agora", ele vai valer 0 e rodar o evento.
As timelines não rodam "de trás pra frente", como os alarms. Elas andam pra frente mesmo. Então se eu jogo um evento no momento 5, ele vai acontecer quantos steps depois do evento que eu iniciar a timeline? Suponho que sejam 5 steps, mas isso pressupõe que a timeline comece no momento "0", não no momento "1", por exemplo.
Mais que isso: se eu coloco a timeline num loop, esse evento acontece a cada 5 steps, certinho, ou ela se reinicia no step seguinte ao último momento? Eu não sei testar isso - e estou com a impressão que os sons (que tocam na timeline e no objeto que usa um alarm com o mesmo valor da timeline) estão dessincronizados.

As sequencias de tiros dos inimigos do meu jogo CoaS foram praticamente feitas só com timelines.

Timelines e alarmes executam no final do Begin Step e antes do Step.
Ela começa no 0 então o momento 5 são 6 frames assim alarmes que começam no 5 são 6 frames para ativar.

Mas timelines são mais útil para cronometrar ação complexas, porque alarmes só suportam um único script.
Se você vai usar apenas um script não a necessidade de fazer isso com timelines.

O interessante é que você pode controlar a posição da timeline.
Por exemplo:
A tl vai de 0 a 200, no momento 50 cria uma instancia e no 200 essa instancia começa atirar misseis. mais eu quero que ela faça isso 20 vezes em intervalos de 15 step. Solução:

Código:

// no momento 200 da timeline
if repetiu < 20 {
    atirar();
    repetiu += 1;
    timeline_position -= 15;
} else {
    // continuar timeline
}

Com é fácil fazer multiplas sequencia em uma só timeline. Depois de atirar 20 missel no momento 300, por exemplo, posso fazer outra sequencia. Tudo cronometrado.
Muito útil em shmups.

Então se eu jogo um evento no momento 5, ele vai acontecer quantos steps depois do evento que eu iniciar a timeline?

Depois de iniciar a timeline, vai demorar 5 steps.

O 0 é o atual, que não é executado. Conta-se a partir do próximo step.
Corrigido porque o Kabeção mostrou que a posição 0 é executada.

Mais que isso: se eu coloco a timeline num loop, esse evento acontece a cada 5 steps, certinho, ou ela se reinicia no step seguinte ao último momento?

Num loop ela se reinicia.

Como dito pelo Kabeção, você pode manusear o tempo como quiser.

Só algumas correções do eu escrevi e do que o PedroX escreveu também.

O momento 0 da timeline é executado sim, até mesmo porque se colocar código lá você vai confirmar, por isso são 6 frames.

Tem uma diferença entre tl e alarme.
O alarme se ativa ao passar do 1 pra 0 e a timeline aumenta depois de executar o código, ou seja, no momento 5 o código é executado e depois a posição do tl vai para 6 (vou volta pra 0 se tiver loop).
Isso quer dizer que um alarme que começa em 5 são 5 frames exatos para executar e um tl com momento 5 são 6 frames pois o 0 esta contando.

Hmm... Isso está ficando complexo...
Não é só um script na timeline... eu já dei uma dica do que é o problema no tópico do SIGILOSO...

Eu estou fazendo um jogo baseado em ritmo. Mas ele não tem nada a ver com guitar hero. Depois fiquei sabendo que é um estilo de jogo pra lá de comum, até o nome que eu estou usando é comum: "Avoider". Os inimigos surgem e andam na tela, você tem que desviar deles. Mas no meu caso, ele é baseado em ritmo.
Então os sons têm que acontecer dentro do ritmo, que eu ainda não sei se vão ser 4 ou 8 vezes a cada 32 steps (32 é pra ficar mais fácil contar o tempo). E têm aqueles eventos geradores de som que acontecem em função das ações do jogador, como morrer, por exemplo.

Então pensei em fazer o seguinte: numa timeline eu marco esses tempos e, nos eventos, eu LIBERO os sons pra tocar, mas não toco. Na timeline eu faço "SE (somTáLiberado) { toca; somTáLiberado = false; } ", o que também evita que muitos sons iguais se sobreponham (aumentando o volume deles). Pode dar um delay de até 7 steps pra tocar o som? Pode, por isso ainda não sei se o ritmo vai ser 4/32 ou 8/32. 3 steps, eu já vou considerar imperceptível. E tem som que só vai tocar a cada tempo completo, tem som que só vai tocar a cada meio tempo, então eu acho mais fácil fazer uma timeline de um segundo 32 steps, jogar os tempos nela e ir programando à medida que for bolando os sons/eventos.
Beleza, essa é a teoria, agora vem a prática.

Então eu coloco 4 vezes na timeline: "SE (somTipo1TáLiberado) {tocaSomTipo1(); somTipo1TáLiberado = false; }" e repito 2 vezes pros sons tipo 2 e só uma pros sons tipo 3. Pro loop de 32 steps ter 4 eventos equidistantes eu devo colocar os momentos 7, 15, 23 e 31 ou 8, 16, 24 e 32?

Outra coisa... Um exemplo dos eventos de som é o inimigo mudar de direção, a cada 16 steps. O alarm[0] dele é mais ou menos assim:

Código:

defineDirecao(); //0,90,180 ou 270 graus
alarm[0] = 16;
somTipo2TáLiberado = true;

Pra que todos inimigos estejam alinhados à grid, mudando de direção ao mesmo tempo, o próximo inimigo deve ser criado no momento 31 ou 32 da timeline?

Terceira coisa: o que acontece primeiro, os alarms ou as timelines? Ambos estão entre o begin e o normal step, mas qual vem primeiro? Porque se a timeline vier antes do alarm, isso me garante um - indesejado - delay entre o evento e o som. Aí, não sei, talvez usar 4 alarms num controle seja melhor que arriscar com timelines.

Edit: bolei um jeito de verificar isso... No objControle, eu defino "debug = 0" no create e, no step, "debug += 1". Daí, tanto nos alarms quanto na timeline, eu coloco "with (objControle) { show_message(debug); }". Assim que fizer o teste eu edito aqui.

Suas perguntas sempre me dão um nó no cérebro. xD

Por que não criar o próprio sistema de timelines?

Aproveitei e fiz um: https://dl.dropboxusercontent.com/u/38888521/Exemplos/timeline_by_pedrox.gml

Modo de usar:

Código:

time_init()

t1=time_create()
time_set(t1, 120)
time_loop(t1, 1)
time_code(t1, 150, "show_message('a')") //depois de 1 segundo

Dentro de um evento repetitivo (a cada step):

Código:

time_step()

Ele usa execute_string(), pois não achei outro jeito... ou melhor, não quis complicar mais do que já está complicado.

Desse modo você pode criar uma timeline para cada coisa a ser repetida.

UMA DICA: NÃO USE TIMELINES!!!

elas são muito limitadas e quando as tentei usar sempre tive vários problemas, por isso acho que é um recurso inútil(para min), e só fica ocupando espaço de variaveis que não precisavam ser checadas(timeline_index..).

Como o pedro disse, crie seu própio sistema, acredito que para você será fácil fazê-lo, mas aqui vai um modo:
script:

Código:

switch StepTimeLine
{
case 30 : /* acontece a ação */ ;break
case 100 : /* acontece a ação */break
}

daí é só chamá-lo a todos step.

Eu estou fazendo um jogo baseado em ritmo. Mas ele não tem nada a ver com guitar hero.

o.O alguem disse que tinha? isso seria uma prevençao contra isso? você não gosta de guitar hero? você o odeia?? você quer acabar com ele???

A idéia das timelines é FACILITAR o trabalho... o que, agora que eu saquei como funcionam (é aquilo que o kabeção falou, só precisava digerir a informação), fica possível.
Eu estava montando o sistema com alarms, um de cada tempo, mas estava difícil lembrar qual alarm fazia o que - e toda hora que eu mudava de idéia, quanto à forma de programar, tinha que ir de alarm em alarm, mudando tudo. Foi aí que eu parti pras timelines (depois de anos sem tocar nelas) e comecei a me dar mal. Mas agora isso passou e eu tenho todos os eventos "de tempos em tempos" num pacotinho acessível.
A resposta é essa mesma: definindo um alarm pra "X" e um evento no momento "X-1" da timeline que é iniciada no mesmo step que o alarm, os dois eventos serão simultâneos. Testei com os "show_message", funciona. Funciona com timelines em loop, também.

off: hahaha! não, eu ADORO o guitar hero. É que quando falamos em jogos de ritmo, o guitar hero é o primeiro modelo que vem à mente. Como o meu jogo não parece com ele nem de longe, já quis evitar as possíveis confusões que poderiam surgir. Eu já escrevo pra caramba sem ninguém entender errado o meu problema... se deixar qualquer margem pra ambiguidade, eu danço!

[Edit] Droga... os sons NÃO estão sincronizados... estranho, na hora de contar os steps, o número bate, na hora de tocar os sons, parece que ficou um eco.
Deixa.
Eu descobri um jeito de fazer com alarms mesmo, sem tanta complicação. Fica um alarm só, o script dele é que é longo.
Mas, diabo, eu odeio não saber usar as ferramentas do game maker!