Movimento tabuleiro : Razão para array

troque

Código:

if (passos < maxPassos){

por

Código:

if (passos <= maxPassos){

Não tenho como ver o erro daqui, mas se der tempo (não acho que vai dar) eu testo.
O código parece menor, mas é bem mais lento, porque ele fica chamando a si mesmo dentro de um loop até que não tenha mais como continuar. Quando você for usar esse tipo de script, é importante garantir que esse momento não vai demorar muito pra acontecer, porque o consumo de memória é exponencial. Experimente trocar "passos + 1" por "passos" e você vai entender.
...
Hm... Acho que sei o que aconteceu... as instâncias criadas primeiro impediram de criar outras por um caminho mais rápido. Eu devia ter previsto isso. Vou tentar arrumar e dou um edit.

Edit: esse, mais que qualquer outro, requer testes (temo que possa travar sua máquina, fechando o jogo), mas se sair como planejado, vai resolver. Acabei criando uma variável permanente nas instâncias, o que eu não queria, mas se resolver, vale a pena.

Código:

var passos, maxPassos, grid, block, caminho, i, xx, yy;
passos = argument0; //o número de iterações já ocorridas
maxPassos = argument1; //máximo de passos permitido
grid = argument2; //o tamanho da grid (32, no caso)
block = argument3; //o parent dos objetos que não podem ser transpostos
caminho = argument4; //o objeto a ser criado pra mostrar o caminho

if (passos < maxPassos){
  for(i = 0; i < 4; i += 1){
      xx = x + lengthdir_x(grid, 90 * i);
      yy = y + lengthdir_y(grid, 90 * i);
      if (!place_meeting(xx, yy, block) //se nada me bloqueia
      if (!place_meeting(xx, yy, caminho)){ //se ainda não tem um "caminho" lá
         with(instance_create(xx, yy, caminho){ //cria um caminho
            meusPassos = passos + 1;
            achaCaminho(passos + 1, maxPassos, grid, block, caminho); //manda o caminho rodar o script de novo, aumentando o número de passos
            }
         }
         else { //se TEM um caminho
            var caminhoExistente;
            caminhoExistente = instance_position(xx, yy, caminho); //grava ele numa variável
            if (caminhoExistente . meusPassos > passos + 1){ //se ele parte de um caminho mais longo
               with (caminhoExistente){
                  achaCaminho(passos + 1, maxPassos, grid, block, caminho); //manda o caminho rodar o script de novo, aumentando o número de passos
                  }
               }
            }
        }
    }

Hmm, realmente.
Dei uma olhado no código, mas não cheguei a nada concreto, só em uma conclusão, que alguma operação estava errada. Após mudar valor, percebi isso melhor, vou testar .!

Valew SAIM !

Não funcionou. só por parte da direita.
Vou te passar a engine pra vc ver melhor como ta o projeto e me ajudar a chegar a um desfeche.

EDIT:
Resolveu. Mas sinceramente, estou chatiado.
Eu não entendi muita coisa doque está nos códigos disponibilizados por vocês, eu os li, e entendi por parte.
Queria entender como vc chegou a conclusão que seria bom fazer por script e ter feito o script.
E seus elementos, conheço o lenght que vi ne um tutorial que está na sua assinatura, mas o resta ficou meio confuso.

FlyAway escreveu:estou chatiado.
Eu não entendi muita coisa doque está nos códigos.

Opa, então ainda não terminamos! A idéia surgiu em função da necessidade. Quando era só descobrir até onde o jogador pode chegar com n passos, o código do ninja era melhor e mais rápido. Ele pegava, numa grid limitada pelo máximo de passos possíveis pra cada lado (que era a maior distância possível de ser caminhada) e verificava se cada ponto podia ser alcançado com o número de passos disponível. Mas como precisamos desviar de alguns blocos, o jeito (que eu encontrei) foi sair testando uma a uma das opções.

saim escreveu:Já que há o risco de termos que contornar algum objeto, acho que o caminho vai ser menos esperto. Teremos que seguir na base da tentativa-e-erro (como o A*), mas em todas as direções. Um algoritmo que faça o seguinte:
- verifica nas 4 direções se é possível caminhar
- em cada direção que é possível caminhar repete o processo de verificar as 4 direções
- a cada repetição conta um passo, até chegar no máximo de passos
Provavelmente será um algoritmo recursivo.

Pra verificar as quatro direções, um "for(i = 0; i < numeroDeDireções; i += 1)".
Pra verificar se é possivel andar, um teste de colisão. Pra "andar", cria-se uma instância.
Pra repetir o processo, e essa é a "grande" sacada, chama-se o script novamente na instância criada.

Aí, enquanto eu pensava, cheguei à conclusão que seria preciso verificar, em algum momento, se o número de passos chegou no valor máximo, por isso acrescentei o primeiro "if" e incluí "passos + 1" como argumento do script. Também concluí que haveriam muitas instâncias sobrepostas se eu não checasse, antes de criar uma nova instância, se já existe uma ali.
O erro aconteceu porque eu não pensei no script da forma que ele realmente acontece. O que eu pensei foi:

- nas 4 direções, se puder andar, eu crio uma instância de "caminho".
- DEPOIS DISSO, se o número de passos permitir, eu mando as instâncias fazerem o mesmo.

O erro foi que eu estou mandando as instâncias rodarem o script ANTES de terminar as 4 direções. Aí, o lado direito (i = 0) acontece até o número de passos chegar no máximo. DEPOIS DISSO o computador vai voltando atrás e verificando, pras instâncias anteriores, as direções restantes.

Caramba, isso é difícil de explicar! Deixa eu tentar de novo.
- a personagem manda o script rodar. i, por enquanto, é igual a zero e o máximo de passos é 2.
- Ela cria uma instância de "caminho" vou chamar de caminho[0] e manda esse caminho rodar o script. Agora, o número de passos já é 1.
- o script cria uma instância à direita de caminho[0], que vou chamar de caminho[1]. Como o número de passos já é 2, caminho[1] não roda o script, o que dá tempo de fazer i = 1 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[2]) logo acima de si. "Passos" já é 2 e caminho[2] não roda o script. i = 2 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[3]) à sua esquerda - o mesmo lugar onde a personagem está. "Passos" já é 2 e caminho[3] não roda o script. i = 3 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[4]) abaixo. "Passos" já é 2 e caminho[4] não roda o script. i = 4 em caminho[0], que finaliza o loop.
- i finalmente chega ao valor de 1 na personagem que cria uma instância de caminho (caminho[5]) acima de si. O número de passos em caminho[5] é 1, então...

Acho que deu pra pegar o andamento de agora pra frente. Agora pense num valor maior pra maxPassos. Aquela instância abaixo de caminho[0] vai rodar o loop e criar uma instância abaixo do jogador. Quando o jogador tiver a chance de tentar uma instância lá, vai dar de cara com uma já existente e decidir que não é uma boa criar o bicho lá.
A alteração faz isso: se houver uma instância quando eu for tentar criar outra, eu vejo quantos passos foram dados pra criar ela. Se forem menos do que a que eu criaria, então eu faço com que ela aja como se tivesse sido recém-criada e rode tudo de novo.

Ufa! Explicar é bem mais complicado do que conceber a idéia...

Kkk, explicar é dificiul msm. Mas sei lá, é prazeroso .
Vlw, entendi só quando cheguei no final. Você fez rodar denovo se ainda tiver mais passos a dar e se ela estiver sido criada no mesmo momento. ( mas tudo acontece muito rapido o_O) vlw ai vc me ajuda mto !

Show de bola heim saim! Genial cara, essa forma que você fez! Adorei o script, vou guardá-lo no meu acervo de scripts! =]

saim escreveu:

FlyAway escreveu:estou chatiado.
Eu não entendi muita coisa doque está nos códigos.

Opa, então ainda não terminamos! A idéia surgiu em função da necessidade. Quando era só descobrir até onde o jogador pode chegar com n passos, o código do ninja era melhor e mais rápido. Ele pegava, numa grid limitada pelo máximo de passos possíveis pra cada lado (que era a maior distância possível de ser caminhada) e verificava se cada ponto podia ser alcançado com o número de passos disponível. Mas como precisamos desviar de alguns blocos, o jeito (que eu encontrei) foi sair testando uma a uma das opções.

saim escreveu:Já que há o risco de termos que contornar algum objeto, acho que o caminho vai ser menos esperto. Teremos que seguir na base da tentativa-e-erro (como o A*), mas em todas as direções. Um algoritmo que faça o seguinte:
- verifica nas 4 direções se é possível caminhar
- em cada direção que é possível caminhar repete o processo de verificar as 4 direções
- a cada repetição conta um passo, até chegar no máximo de passos
Provavelmente será um algoritmo recursivo.

Pra verificar as quatro direções, um "for(i = 0; i < numeroDeDireções; i += 1)".
Pra verificar se é possivel andar, um teste de colisão. Pra "andar", cria-se uma instância.
Pra repetir o processo, e essa é a "grande" sacada, chama-se o script novamente na instância criada.

Aí, enquanto eu pensava, cheguei à conclusão que seria preciso verificar, em algum momento, se o número de passos chegou no valor máximo, por isso acrescentei o primeiro "if" e incluí "passos + 1" como argumento do script. Também concluí que haveriam muitas instâncias sobrepostas se eu não checasse, antes de criar uma nova instância, se já existe uma ali.
O erro aconteceu porque eu não pensei no script da forma que ele realmente acontece. O que eu pensei foi:

- nas 4 direções, se puder andar, eu crio uma instância de "caminho".
- DEPOIS DISSO, se o número de passos permitir, eu mando as instâncias fazerem o mesmo.

O erro foi que eu estou mandando as instâncias rodarem o script ANTES de terminar as 4 direções. Aí, o lado direito (i = 0) acontece até o número de passos chegar no máximo. DEPOIS DISSO o computador vai voltando atrás e verificando, pras instâncias anteriores, as direções restantes.

Caramba, isso é difícil de explicar! Deixa eu tentar de novo.
- a personagem manda o script rodar. i, por enquanto, é igual a zero e o máximo de passos é 2.
- Ela cria uma instância de "caminho" vou chamar de caminho[0] e manda esse caminho rodar o script. Agora, o número de passos já é 1.
- o script cria uma instância à direita de caminho[0], que vou chamar de caminho[1]. Como o número de passos já é 2, caminho[1] não roda o script, o que dá tempo de fazer i = 1 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[2]) logo acima de si. "Passos" já é 2 e caminho[2] não roda o script. i = 2 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[3]) à sua esquerda - o mesmo lugar onde a personagem está. "Passos" já é 2 e caminho[3] não roda o script. i = 3 em caminho[0].
- caminho[0] cria uma instância de caminho (caminho[4]) abaixo. "Passos" já é 2 e caminho[4] não roda o script. i = 4 em caminho[0], que finaliza o loop.
- i finalmente chega ao valor de 1 na personagem que cria uma instância de caminho (caminho[5]) acima de si. O número de passos em caminho[5] é 1, então...

Acho que deu pra pegar o andamento de agora pra frente. Agora pense num valor maior pra maxPassos. Aquela instância abaixo de caminho[0] vai rodar o loop e criar uma instância abaixo do jogador. Quando o jogador tiver a chance de tentar uma instância lá, vai dar de cara com uma já existente e decidir que não é uma boa criar o bicho lá.
A alteração faz isso: se houver uma instância quando eu for tentar criar outra, eu vejo quantos passos foram dados pra criar ela. Se forem menos do que a que eu criaria, então eu faço com que ela aja como se tivesse sido recém-criada e rode tudo de novo.

Ufa! Explicar é bem mais complicado do que conceber a idéia...

EDIT: vc disse que usando o A-STAR não resolveria ... mas vc implementou o algortimo de DJSKTRA (de quem o A-STAR deriva) recusivamente ... e sem uma priority_queue para sempre ir pelo que tem menor 'passo'

isso não é um problema enquanto o numero de passos for baixo , e o numero de chamadas for baixa.

O código do saim está funcionando perfeitamente.
Por isso o tópico já está resolvido, e foi melhor pq foi feito com códigos que eu entendo e se quizer muder eu posso, já naum sei mexer com A* .
Se quizer pode fazer e postar aqui, irei olhar também.

Ninja8086 escreveu:
Show de bola heim saim! Genial cara, essa forma que você fez! Adorei o script, vou guardá-lo no meu acervo de scripts! =]

Um script meu no acervo do Ninja8086? Ok, posso me dar por satisfeito com programação...

diego333 escreveu:EDIT: vc disse que usando o A-STAR não resolveria ... mas vc implementou o algortimo de DJSKTRA (de quem o A-STAR deriva) recusivamente ... e sem uma priority_queue para sempre ir pelo que tem menor 'passo'

isso não é um problema enquanto o numero de passos for baixo , e o numero de chamadas for baixa.

Mesmo? Bom, como eu disse, a solução, como o A*, seria por tentativa-e-erro, mas não sabia que existia algo do tipo. Vou pesquisar mais a respeito do DJSKTRA (nossa, vou precisar voltar a esse tópico pra lembrar esse nome...).

Eu tenho muito pé atrás em usar scripts recursivos, primeiro pela memória que eles gastam (nesse caso, acho que nem é tanta, mas de modo geral, eu tenho um pé atrás). Segundo, porque se você deixar de prever alguma situação, o loop criado pode se tornar infinito e o erro será invisível até um olho de fora entrar na jogada. Esse é o tipo de erro que quem cometeu nunca vai conseguir encontrar.
No caso do FlyAway, as possibilidades de loop são poucas, então eu acho que consegui cercar o código todo. Mas tive que visualisar e evitar pelo menos duas armadilhas.

Se o problema é pq se o número de passos for grande, não tem problema pra mim, pois usarei passos com no maximo 6, mas seria bom ver . È chato ficar com erro;

Revivo o tópico para melhorar oque há aqui

O Saim com o ultimo código solucionou o meu problema, mas agr o problema é outro.
Além do movimento horizontal e vertical eu quero tb o movimento diagonal, na diagonal tb contaria como 1 passo como ja funciona. Tentei de várias formas fazer cm q o scripte crie os obj_passos tanto na vertical e na horizontal quanto na diagonal, mas n deu muito certo, alguem pode ajudar?