[resolvido] problema com lógica de wrap

Estou tentando criar um movimento "wrap" usando clones, como foi sugerido numa dúvida recente aqui do fórum. A idéia é que assim que uma beira da sprite toque o final da room, uma cópia seja criada do outro lado. Isso funciona na horizontal e na vertical. Eu preciso fazer isso num objParent, porque quase todos os objetos do jogo usarão esse movimento.

O problema é que ao colocar o objeto numa quina da tela, MUITOS clones são criados. Não consigo determinar o porque. Nas laterais, o código funciona bem, mas nas quinas dá esse bug.

Eu já previa que isso iria acontecer e, pra evitar, coloquei uma variável (na verdade, uma array) no objeto, que chamei "clone". Se existir um clone naquela direção, não se cria outro. Se não está na área de verificar por clones e EXISTIR um clone, então ele está pra fora da tela e é eliminado. Mas nas quinas, parece que minha lógica falhou.

Os códigos:

objWrapParent escreveu:>create<

Código:

borda1H = sprite_xoffset;  borda2H = room_width - sprite_xoffset;
borda1V = sprite_yoffset / 2; borda2V = room_height - sprite_yoffset;
var i; for (i = 0; i < 4; i += 1){ // 1 pra cada beirada
   clone[i] = noone;
   }

>step<

Código:

var i, criou;
for (i = 0; i < 4; i += 1){ // 1 pra cada beirada
   criou[i] = false; // pra não repetir a passagem de variáveis a cada step
   }
// verifica se deve criar um clone
if (x > borda2H && clone[0] == noone){
   clone[0] = instance_create(x - room_width, y, object_index);
   criou[0] = true;
   }
if (y < borda1V && clone[1] == noone){
   clone[1] = instance_create(x, y + room_height, object_index);
   criou[1] = true;
   }
if (x < borda1H && clone[2] == noone){
   clone[2] = instance_create(x + room_width, y, object_index);
   criou[2] = true;
   }
if (y > borda2V && clone[3] == noone){
   clone[3] = instance_create(x, y - room_height, object_index);
   criou[3] = true;
   }

// passa as variáveis pros clones
for (i = 0; i < 4; i += 1){
   if (criou[i]){ // se foi nesse step que criou o clone
      with(clone[i]){
         clone[(i + 2) mod 4] = other . id; // pra ele saber que eu sou clone dele, também
         speed = other . speed; direction = other . direction;
         gravity = other . gravity; gravity_direction = other . gravity_direction;
         }
      // passa o valor de cada variável exclusiva dos childs
      // if (variable_local_exists(""){
         // clone[i] .  = ;
         // }
      }
   }

>draw (pra debug)<

Código:

draw_text(20, 20, instance_number(objTesteWrap));
var i; for(i = 0; i < 4; i += 1){
   draw_text(x + lengthdir_x(sprite_width, 90 * i + 180), y + lengthdir_y(sprite_height, 90 * i + 180), clone[i]); // no lado oposto mesmo, pra ficar visível na tela
   }
draw_sprite(sprite_index, image_index, x, y);

objWrapTeste escreveu:parent: objWrapParent
>create<

Código:

event_inherited();
minhaVel = velBase; // uma constante, de valor 4

>step<

Código:

event_inherited();
vspeed = minhaVel * (keyboard_check(vk_down) - keyboard_check(vk_up));
hspeed = minhaVel * (keyboard_check(vk_right) - keyboard_check(vk_left));

Alguma idéia do motivo do bug?

ideia:
simplesmente repitia o draw com -room _height +x e o mesmo em y quando maior q a metade e -x +room_height quando menor, e n esqueca de colocar wrap manual

É como o rodrigo falou ai, esse movimento pode codificado apenas no Draw, sobre o efeito de transição entre os lados da tela, você precisa desenhar do outro lado o que desapareceu do objeto verdadeiro. isso pode ser feito com os atributos da room e do sprite do objeto como room_width, room_height, sprite_width e sprite_height.

Ehm... não. Eu realmente preciso de uma instância do objeto, pra poder colidir. Não é um wrap só visual. Eu realmente preciso descobrir onde está o erro...

Teoricamente, o código está ok, ele até funciona nas laterais. Quando é nas quinas é que dá pau.

SAQUEI!!! As novas instâncias têm só o índice "(i + 2) mod 4" definido! Os outros índices são definidos como "noone"! Estou surpreso de não ter entrado num loop infinito!

Corrigido:

Código:

(...)// passa as variáveis pros clones
for (i = 0; i < 4; i += 1){
   if (criou[i]){ // se foi nesse step que criou o clone
      with(clone[i]){
         clone[i] = other . clone[(i + 2) mod 4];
         clone[(i + 1) mod 4] = other . clone[(i + 3) mod 4];
         clone[(i + 2) mod 4] = other . id; // pra ele saber que eu sou clone dele, também
         clone[(i + 3) mod 4] = other . clone[(i + 5) mod 4];
         speed = other . speed; direction = other . direction;
         gravity = other . gravity; gravity_direction = other . gravity_direction;
         }
      // passa o valor de cada variável exclusiva dos childs
      // if (variable_local_exists(""){
         // clone[i] .  = ;
         // }
      }
   }
(...)

Testado e aprovado, podem trancar o tópido.

False. Fui emplogar, me dei mal. Continua criando algumas instâncias. Diminuiu, mas continua...

Os filhos estão repetindo o comando dos seus pais. Você precisa fazer algo assim:

Create

Código:

if (instance_number(object_index)==1) {event_inherited(); step=1;} else {step=0;}

Step

Código:

if (step)event_inherited();

Claro, os outros códigos continuam iguais.

Também não resolve... eu quero muitas instâncias do objeto, andando com IA. Elas podem estar em qualquer ponto da tela.
No exemplo que eu dei, eu usei movimentação por teclado, mas é porque ainda estou começando a programar. Quando o problema for resolvido, vou passar pra IA (por isso deixei em comentário aquela parte que repassa pros clones os valores de variáveis genéricas: eu ainda não sei que variáveis serão).

O que eu queria mesmo era entender onde houve falha na lógica.
1 - O objeto está numa posição que o obriga a criar clones na horizontal e na vertical. Ele não tem clones nessas direções.
2 - Ele cria o clone na horizontal, que também está em posição de criar clones. Mas ele já tem um clone na horizontal (o objeto inicial) e ainda não chegou no step event, pra poder criar outro clone.
3 - O objeto inicial cria um clone na vertical, que também está em posição de criar clones. Mas ele já tem um clone na vertical (o objeto inicial) e ainda não chegou no step event, pra poder criar outro clone.
4 - O objeto inicial explica pros 2 clones criados quais os clones existem, pra que eles não criem mais clones.

hmm... faltou um quarto objeto aí... aposto que é no step seguinte, quando os clones vão criar o clone no espaço que falta, que é gerada uma duplicata. Vou tentar contornar isso criando os 3 clones no mesmo step.
Acho que vou precisar prever a situação de cada quina separadamente.
E depois ainda tem a situação em que o objeto morre e os clones têm que morrer junto... Pensar que isso era pra ser programado em 15 minutos, hein?

Por qual motivo você cria clones na horizontal e na vertical? Poderia criar um que se adaptasse à posição correta.

O que eu queria mesmo era entender onde houve falha na lógica.

Código:

var i; for (i = 0; i < 4; i += 1){ // 1 pra cada beirada
  clone[i] = noone;
  }

Isso no evento Create faz com que qualquer clone crie seus próprios clones.
Você não especificou nada para as instancias novas não criarem outras instâncias.

A solução talvez seja

Código:

if (x > borda2H && clone[0] == noone){
    clone[0] = instance_create(x - room_width, y, object_index);
 
    with (clone[0]) {
        var i; for (i = 0; i < 4; i += 1) clone[i] = false; // não criar
    }
    criou[0] = true;
}

@PedroX
Se eu passo pra direita da tela, preciso de um clone na esquerda, e vice-versa. horizontal.
Se eu passo pra baixo da tela, preciso de um clone acima, e vic-versa. vertical.
Se eu estou no canto superior-direito da tela, preciso de um clone na parte de baixo, um no canto esquerdo e até um na parte inferior-esquerda, pra mostrar a porção superior-direita da minha sprite.

Já vi que o problema na minha lógica está nesse terceiro clone, que é criado, no step seguinte, tanto pelo clone à esquerda quanto pelo clone na parte de baixo. Agora é dar um jeito de ambos criarem o mesmo clone (ou seja, só uma instância).
Nesse instante, estou fritando a cabeça com isso.

@kabeção: no create, ele não cria os clones, ele define uma variável. No final do step que ele cria um clone, ele redefine o valor dessa variável, inclusive para os clones.
O que o PedroX sugeriu foi permitir apenas duas instâncias do objeto. Como eu expliquei pra ele no post anterior e nesse aqui, não dá pra limitar o número de clones desse jeito...

O que eu já percebi é que NÃO VAI DAR pra manter só 4 ids como clone[0], [1], [2] e [3]... se o clone acima de mim tem a id "a", o clone acima do clone à minha direita NÃO PODE ter a mesma id "a". Aí, está difícil amarra as id's direitinho, mesmo fazendo um código pra cada situação. Estou começando a ficar tentado a usar o move_wrap mesmo, e dane-se, mas... isso vai piorar TANTO, o jogo...

O que você quer é fazer uma transição nas bordas da tela num é isso? se sim você não vai precisar de outras instancias, a não ser que a mecânica do seu game necessite deste recurso, além disso, da forma que você especificou, quando ultrapassar as bordas deve-se aplicar a inversão do sprite.

Finalmente consegui:

https://dl.dropbox.com/u/38888521/Exemplos/saim.gmk

O problema, eu acho (até me perdi), é que ao sair da room, seu objeto não voltava mais para dentro e assim ia criando várias instâncias.

Até mais!

Valeu, PedroX! Vou baixar ainda hoje!
Mas... até lá... não quer explicar como fez? Senão, vou passar o dia inteiro me roendo de curiosidade...

Primeiramente, o pai controla o clone, mas o clone não faz nada com o pai. E também o clone é destruido quando o pai sai totalmente da tela (o pai é inserido novamente).

Foi mal pela demora, PedroX, achei que eu teria o tempo que eu queria pra olhar...

Infelizmente, seu código não me atende. Ele até cria o clone no extremo oposto da tela, mas só na diagonal. Isso não pode ser relevado, porque se estando numa dessas quinas o objeto se deslocar na horizontal ou vertical, saindo da quina, o clone "pula" pra nova posição correta. Esse salto fica sem explicação e chama mais atenção do que usar o move_wrap.

Mas valeu a tentativa!

saim, eu fiz um exemplo com draw_sprite(), mais você pode adaptar facilmente para instance_create().

GMZ

Ainda vou dar uma olhada, mas não acho a adaptação tão simples assim... O lance é que uma colisão num "clone" deve eliminar os demais clones. Além disso, pra não correr risco de criação infinita de clones, eu preciso eliminar aqueles clones que estão fora da tela - que pode ser a instância original ou não.

Se eu conseguir adaptar seu exemplo, eu venho aqui e edito a mensagem. Por enquanto, um pouco mais de brainstorming.

Acho que se eu pegar caso-a-caso, consigo dar nomes aos bois, com uma array... Eu tenho indexado como
[0] o clone à esquerda (que surge quando você vai pra direita)
[1] o clone abaixo (que surge quando você vai pra cima)
[2] o clone à direita (etc)
[3] o clone acima (etc)
Isso tem gerado conflito. O clone à direita da instância "A", que é "B", não pode ter o mesmo id que o clone à direita da instância "C", que está abaixo de "A", porque são instâncias diferentes.

Se eu apelar e indexar, por exemplo, como
[0] o clone no topo à direita
[1] o clone no topo à esquerda
[2] o clone abaixo à esquerda
[3] o clone abaixo à direita
aí, não tem risco de ambiguidade, tem? Se "A" está no topo, à direita, todos os clones vão reconhecer a id de "A" como "no topo, à direita" - inclusive o próprio "A".

Por outro lado, que índices eu daria pra quando só existe um clone (horizontal ou vertical)?
...
É, parece que vou ter que criar exceções mesmo... SE (está no meio da tela) {não esquenta} SENÃO, SE (está nas laterias) {tem uma lógica}, SENÃO /* aí está numa quina */ { aí tem outra lógica}.
Apelar de com força!

Mas depois. O chefe chegou e quer produção!

[edit] É, diegoLuiz, infelizmente seu código não leva em conta esses problemas, só coloca a imagem na posição correta... Mas comecei um código imenso que PARECE que vai funcionar... e deixei ele no computador do serviço. Não vou reescrevê-lo todo hoje; amanhã, se eu tiver tempo, eu termino e me mando por e-mail, senão só mando por e-mail.
Ele é cheio de redundâncias, um monte de if-else, TEM que ser usado no step, enfim, tudo do jeito que eu NÃO gosto de programar, mas se é o jeito, vamos nessa!

[edit2] pfffew! terminei. Se isso aqui não der certo, lascou! Ainda não testei, estou no computador do trabalho, mas vou colocar o código aqui pra permitir testes e, também, tê-lo num lugar acessível...
Acho que vai acabar valendo a pena definir os valores das bordas no create, me parece mais eficiente que defini-las a cada step. Fiz isso.
A idéia é criar 2 famílias (arrays) de clones, pras laterais e pras quinas, ambas com 4 membros. As laterais, a princípio, só precisam de 2 membros, mas mudar de uma família pra outra num único step (raro, mas possível) estava mais complicado que criar novos membros. Aí, em cada step, eu vejo qual família usar (se for preciso usar alguma) e me organizo. Por "me organizo" quero dizer verificar se a família já está povoada, se as outras famílias já foram eliminadas, e tomar providências.
Ufa!
c-a-s-o - a - c-a-s-o...

Código:

if (x > bordaH0 && x < bordaH1 && y > bordaV0 && y < bordaV1){ // está no meio da tela
    logica = 0;
    }
    else if ((x > bordaH0 && x < bordaH1) || (y > bordaV0 && y < bordaV1)){ // está nas laterais (já que não está no meio)
        logica = 1;
        }
        else { logica = 2; } // está numa das quinas

switch(logica){
    case 0: { // clones não fazem sentido
        // simplesmente elimina todos os clones
        var i; for (i = 0; i < 4; i += 1){
            if (cloneLat[i] != noone){
                if (cloneLat[i] != id){
                    with (cloneLat[i]){ rodaDestroy = false; instance_destroy();}
                    }
                cloneLat[i] = noone;
                }
            if (cloneQuina[i] != noone){
                if (cloneQuina[i] != id){
                    with (cloneQuina[i]){ rodaDestroy = false; instance_destroy();}
                    }
                cloneQuina[i] = noone;
                }
            }
        };break
    case 1: { // clones só na horizontal ou na vertical. Esquerda=0; acima=1; direita=2; abaixo=3;
        // elimina os clones das quinas, caso existam
        var i; for (i = 0; i < 4; i += 1){
            if (cloneQuina[i] != noone){
                if (cloneQuina[i] != id){
                    with (cloneQuina[i]){ rodaDestroy = false; instance_destroy();}
                    }
                cloneQuina[i] = noone;
                }
            }

        // define se é na vertical ou horizontal
        if (x < bordaH0 || x > bordaH1){ // está no sentido horizontal
            // elimina os clones indesejados, caso existam
            for (i = 1; i < 4; i += 2){ // 1 e 3
                if (cloneLat[i] != noone){
                    if (cloneLat[i] != id){
                        with(cloneLat[i]){ rodaDestroy = false; instance_destroy(); }
                        }
                    cloneLat[i] = noone;
                    }
                }
            if (cloneLat[0] == noone || cloneLat[2] == noone){ // se não existe clone
                if (x < bordaH0){ // eu sou o da esquerda (0)
                    cloneLat[0] = id;
                    cloneLat[2] = instance_create(x + room_width, y, object_index);
                    with (cloneLat[2]){
                        cloneLat[0] = other . id;
                        cloneLat[2] = id;
                        }
                    }
                if (x > bordaH1){ // eu sou o da direita (2)
                    cloneLat[0] = instance_create(x - room_width, y, object_index);
                    cloneLat[2] = id;
                    with (cloneLat[0]){
                        cloneLat[2] = other . id;
                        cloneLat[0] = id;
                        }
                    }
                }
            }
        else { // está no sentido vertical
            // elimina os clones indesejados, caso existam
            for (i = 0; i < 4; i += 2){ // 0 e 2
                if (cloneLat[i] != noone){
                    if (cloneLat[i] != id){
                        with(cloneLat[i]){ rodaDestroy = false; instance_destroy(); }
                        }
                    cloneLat[i] = noone;
                    }
                }
            if (cloneLat[1] == noone || cloneLat[3] == noone){ // se não existe clone
                if (y < bordaV0){ // eu sou o de cima (1)
                    cloneLat[1] = id;
                    cloneLat[3] = instance_create(x, y + room_height, object_index);
                    with (cloneLat[3]){
                        cloneLat[1] = other . id;
                        cloneLat[3] = id;
                        }
                    }
                if (y > bordaV1){ // eu sou o de baixo (3)
                    cloneLat[1] = instance_create(x, y - room_height, object_index);
                    cloneLat[3] = id;
                    with (cloneLat[1]){
                        cloneLat[3] = other . id;
                        cloneLat[1] = id;
                        }
                    }
                }
            }
        };break
    case 2: { // clones nas quinas. topleft=0; bottomleft=1; bottomright=2; topright=3;
        // elimina os clones das laterais, caso existam
        var i; for (i = 0; i < 4; i += 1){
            if (cloneLat[i] != noone){
                if (cloneLat[i] != id){
                    with (cloneLat[i]){ rodaDestroy = false; instance_destroy();}
                    }
                cloneLat[i] = noone;
                }
            }
        var deveCriar; deveCriar = false;
        for (i = 0; i < 4; i += 1){
            if (cloneQuina[i] == noone){ deveCriar = true;}
            }
        if (deveCriar){
            if (x < bordaH0 && y < bordaV0){ // eu sou o topleft (0)
                cloneQuina[0] = id;
                cloneQuina[1] = instance_create(x,                  y + room_height, object_index);
                cloneQuina[2] = instance_create(x + room_width, y + room_height, object_index);
                cloneQuina[3] = instance_create(x + room_width, y,                  object_index);
                }
            if (x < bordaH0 && y > bordaV1){ // eu sou o bottomleft (1)
                cloneQuina[0] = instance_create(x,                  y - room_height, object_index);
                cloneQuina[1] = id;
                cloneQuina[2] = instance_create(x + room_width, y,                  object_index);
                cloneQuina[3] = instance_create(x + room_width, y - room_height, object_index);
                }
            if (x > bordaH1 && y > bordaV1){ // eu sou o bottomright (2)
                cloneQuina[0] = instance_create(x - room_width, y - room_height, object_index);
                cloneQuina[1] = instance_create(x - room_width, y,                  object_index);
                cloneQuina[2] = id;
                cloneQuina[3] = instance_create(x,                  y - room_height, object_index);
                }
            if (x > bordaH1 && y < bordaV0){ // eu sou o topright (3)
                cloneQuina[0] = instance_create(x - room_width, y,                  object_index);
                cloneQuina[1] = instance_create(x - room_width, y + room_height, object_index);
                cloneQuina[2] = instance_create(x,                  y + room_height, object_index);
                cloneQuina[3] = id;
                }

            for (i = 0; i < 4; i += 1){
                with (cloneQuina[i]){
                    if (id != other . id){
                        var j; for (j = 0; j < 4; j += 1){
                            cloneQuina[j] = other . cloneQuina[j];
                            }
                        }
                    }
                }
            }
        };break
    }

[edit 3] O código tinha algumas falhas, tanto de lógica quanto de digitação. Dei uma corrigida e FUNCIONOU!!!

Mas fiquei com a impressão que eu não preciso mais definir pra instância qual membro da "família" ela é. Se eu conseguir eliminar isso, o código dá uma diminuída. Se eu conseguir um tempinho, eu faço isso, mas o jogo ainda tem muita coisa por fazer, pra eu me preocupar com isso no momento.

Obrigado a todos que ajudaram e/ou tentaram ajudar. Por mim, podem trancar o tópico.