Como criar clones?

Alguém sabe como criar clones como nesse jogo:
http://clickjogos.uol.com.br/Jogos-online/Acao-e-Aventura/The-Company-of-Myself/

OBS:Os clones não aparecem já na 1ª fase.

Fale sobre o que quer, não mostre apenas um jogo que teremos ainda que passar as fases para ver o que vocÊ quer, para sim aí tentar ajudá-lo.

explica melhor. e coloca uma imagem

Olha esse vídeo a partir dos 24 segundos
https://www.youtube.com/watch?v=tI0RfSn8oYg

Um clone que imite as ações que fizemos antes de apertar alguma tecla.

Certa vez eu joguei um jogo que usava uns clones, criados a cada intervalo de tempo, eu diria uns 2 segundos. Eles repetiam TODAS as ações do jogador, passo-a-passo. O objetivo do jogo era chegar até um determinado ponto da fase e voltar sem tocar nesses clones. Muito legal, mas esqueci o nome. Parece ser a mesma coisa que você quer (se não for o mesmo jogo, eu não tenho como ver daqui).

Também fiquei cismado com essa pergunta. Como?

Eu bolei um jeito que é parecido com a engine de voltar no tempo, do prince of persia (ou uma variação dela, o que eu vi foi a engine de um programador indie dizendo usar o mesmo princípio - e acreditei).

É assim, você armazena, a cada step, as informações que o clone vai precisar em arrays, ds_lists ou uma ds_map. Aí, quando o clone é criado, ele acessa esse banco de dados e simplesmente repete o que o jogador fez, sem nenhuma inteligência artificial envolvida.

Essas informações podem se resumir a:
- posição (x, y)
- visual (sprite_index, image_index, image_xscale, image_yscale, image_blend, image_alpha, image_angle)

Eu não me preocuparia em armazenar velocidades, gravidade, health, nada disso. A função do clone não é jogar, apenas estar no lugar que o jogador esteve, naquela posição em que ele esteve. Claro que o clone vai precisar de um delay, tipo se o jogador está escrevendo os dados na posição 0 do banco de dados, o clone deve ler a posição, digamos, 30. O segundo clone vai ler os dados da posição 60 e assim por diante.

Nunca tentei isso. Parti do princípio que vai funcionar e deixei a engine guardada numa gaveta do meu cérebro, sem nunca tê-la escrito de verdade.


Edit:
Cara, fui testar a teoria e acabei criando um puzzle que eu NÃO SEI se é possível ganhar (tenho a impressão que não). Funciona assim, o jogo cria os clones de tempos em tempos e quando os clones colidem com o jogador ou outro clone, é destruído. Quando o primeiro clone é destruído, conta-se quantas instâncias de clones existem. Se em algum momento houverem mais instâncias que esse número, você ganha.

Teoricamente, se houve qualquer colisão, essa colisão vai ser repetida pelo clone do clone, até o infinito. Mas existe a possibilidade de colidir com o clone recém-criado, antes da colisão, abrindo espaço pro clone mais velho passar impune pela posição de colisão. Mas aí, você gera outro evento de colisão, por isso acho que o puzzle é impossível. Mas vai saber.

Enfim, eis os códigos que usei:

objPlayer escreveu:create

Código:

globalvar posX, posY, angle, nMinimo, valendo;
indice = 0; //o índice em que os dados serão escritos
x = mouse_x; y = mouse_y; //posiciona o objeto no mouse, antes de começar a escrever nas arrays
posX[indice] = x; posY[indice] = y; angle[indice] = image_angle; //começa as arrays
tempoAlarme = 50; // de quanto em quanto tempo se cria um clone
alarm[0] = tempoAlarme;

criaX = x; criaY = y; // posição de criar os clones
nMinimo = 0; valendo = false; // um joguinho bobo, ver colisões do clone e alarme

step

Código:

image_angle = point_direction(x, y, mouse_x, mouse_y); // aponta pro mouse
x = median(0, mouse_x, room_width); y = median(0, mouse_y, room_height); // anda até o mouse
indice += 1; // atualiza o índice
posX[indice] = x; posY[indice] = y; angle[indice] = image_angle; // escreve nas arrays

alarm[0]

Código:

instance_create(criaX, criaY, objClone); //cria o clone
alarm[0] = tempoAlarme; //reinicia o alarme

// joguinho: se tem mais instâncias que na primeira colisão, you win.
if (valendo == true){
   if (instance_number(objClone) > nMinimo){
      show_message("you win!");
      }
   }

objClone escreveu:sprite_index = sprite index do objPlayer.

create

Código:

meuIndice = 0; //o índice a ser lido das arrays globais criadas pelo objPlayer

step:

Código:

x = posX[meuIndice]; y = posY[meuIndice]; image_angle = angle[meuIndice]; // segue as arrays
meuIndice += 1; //pula pro próximo índice da array

colisão com player

Código:

// joguinho: se for destruir o primeiro clone, começa a contagem de instâncias. Ver objetivo no alarme do player
if (valendo = false){
   nMinimo = instance_number(objClone);
   valendo = true;
   }
instance_destroy(); // ao colidir, morre

colisão com o próprio clone

Código:

// joguinho: se for destruir o primeiro clone, começa a contagem de instâncias. Ver objetivo no alarme do player
if (valendo = false){
   nMinimo = instance_number(objClone);
   valendo = true;
   }
instance_destroy(); // ao colidir, morre

draw

Código:

draw_sprite_ext(sprPlayer, 0, x, y, 1, 1, image_angle, $ffffff, 0.6); //um alpha menor, pra diferenciar

Se conseguir fazer "you win" aparecer, me conta!

Edit 2: Não, é possível ganhar sim! Consegui!

Valeu,funcionou do jeito que queria.

EDIT:
Tirei as colisões e tenho uma pergunta:
Tem algum jeito de deixar o clone parado após ele terminar de me copiar?

OFF:

Spoiler:

Bom, se você puser um limite na array, ele vai parar no final dela. Na verdade, vai aparecer um erro de "unknown variable or array limits off-bounds", ou algo assim. Você precisa dizer pro objeto: me copie até ESSE ponto aqui, depois fique parado.
Mas eu precisaria saber exatamente o efeito final que você quer atingir pra ajudar melhor.

O efeito é como o do vídeo que postei num comentário.

sim oque o Saim Respondeu esta certo, no Final da Clonagem e da ação, faça ele ficar parado.

Vi o Jogo no Video, e gostei do Jogo, ainda não tinha Visto essa idéia de Jogo, é sempre legal ver uma nova idéia de jogo e essa idéia ser legal.

Se quizer eu faço uma Engine, mas basicamente é só parar ao acabar a ação do clone.

Como fazer para parar ao acabar a ação?Não consigo fazer.

Vi o vídeo (alguns minutos, depois já tinha pegado a idéia). Pô, bacana!
Mas esse truque que eu passei NÃO VAI dar o mesmo resultado. Você vai notar que, em algumas fases, o clone colide com algumas paredes que a personagem não colide (e acho que o oposto também é verdade). Ou seja, não fica na mesma posição que a personagem.

Aí, fica a primeira pergunta valendo de novo. Como fazer?
Você não armazena mais arrays de sprites e posições, mas de comandos. Enquanto a personagem vai andando, você vai armazenando arrays como "esquerdaApertada[i]" ou "puloApertado[i]" e faz uma movimentação parecida com a da personagem. É mais complexo, mas deve funcionar se você fizer tudo no step.
Normalmente eu sou contra fazer tudo no step, mas nesse caso você precisa usar os mesmos eventos pra personagem e pros clones e fica difícil escolher checar os valores das arrays se não for assim.

Quanto à pergunta de "como fazer pra parar", basta não fazer mais nada. No caso do jogo, cada clone segue uma array diferente (eu fiquei com essa impressão), que acaba quando o jogador aperta espaço. Quando acabar os comandos, os clones não obedecem mais comando nenhum. Tão simples quanto soa.

Não consigo criar os códigos,me ajuda.

Você cria um monte de arrays e vai atualizando elas. Assim:

create:

Código:

globalvar esquerda, direita, pulo; //não vou definir valores, ainda
teclaEsquerda = vk_left; teclaDireita = vk_right; teclaPulo = vk_up; // prefiro trabalhar assim, pra poder alterar depois
inicioX = x; inicioY = y;
tempo = 0

step:

Código:

if keyboard_check(teclaEsquerda){
esquerda[tempo] = true;
}
else {
esquerda[tempo] = false
}
// mesma coisa pra direita e pulo
tempo += 1; // pro próximo índice das arrays
// aí se movimenta em função da situação de colisões, forças (gravidade) e teclas apertadas

apertar espaço:

Código:

with(instance_create(inicioX, inicioY, objClone)){
fimDeVida = other . tempo; //momento em que vai parar de obedecer às arrays
}

Aí, no clone, você faz algo assim:

create:

Código:

tempoClone = 0; // pra definir o índice da array a ser verificado

step:

Código:

if (tempoClone < fimDeVida){
if (esquerda[tempoClone] == true){
// anda pra esquerda ou acelera ou sei lá
}
else{
// desacelera ou simplesmente não anda pra esquerda
}
if (direita[tempoClone] == true){
// mesma coisa pro outro lado
}
else {
// e assim vai
}
// mesma coisa com o pulo
}
tempoClone += 1;
}
else {
// tá na hora de ficar parado, você pode simplesmente não fazer nada, pode eliminar a instância, pode fazer um monte de coisas.
}

O lance é que ao pular, andar, etc, você vai verificar por colisões diferentes daquelas verificadas pelo player, então o resultado da posição pode ser diferente.

Em outras palavras: ao invés do clone obedecer aos comandos atuais do jogador, ele vai obedecer aos comandos dados a um tempo atrás. Pra isso acontecer, você precisa armazenar esses comandos e dizer pro clone em que momento está o conjunto de comandos que é pra ele obeceder. Às colisões e etc, ele reage por conta própria.