[Ajuda] Script de Movimentação 2D

Salve todos os makers o/

Sou novo na comunidade e também no manuseio do Game Maker,
mas já possuo uma base de D&D e GML, somente o básico, mas o possuo ~ ;p
Outrora estava a programar uma engine em Visual Basic 6 seguindo o padrão "Mirage Source" em DX8
mas por uma série de imprevisto tive que parar -por enquanto- no seu desenvolvimento

Vamos a minha questão:
Estou tentando fazer um sistema de movimentação 2D estilo pokémon,
_ que possua a possibilidades de andar,
_ correr,
_ apenas olhar na direção,
_ parar de andar/correr caso bloqueado

Algumas particularidades: gostaria de faze-lo apenas por GML, evitando ao máximo D&D
("Create" e "Step" são aceitáveis, neh, XD)

Não pretendo usar engines já feitas, até porque estou interessado na aprendizagem do processo então
no máximo as usarei para fins de aprendizagem/estudo '-'
-sim, eu conheço a www.64digits.com
Este sonho maluco, já aprendi um bocado de GML sofrendo para fazer este script xD
Estou usando 5 sprites de um único personagem para criar o movimento, usando o personagem Ralph
do RTP do RPG Maker VX -Actor1-
Sendo: RalphS -animação abaixo-
_ RalphA -animação esquerda-
_ RalphD -animação direita-
_ RalphW -animação acima-
_ Ralph -animação com todas a imagens das sprites acima-
Lembrando que a sprites direcionais -S, A, D, W- possuem 3 frames;
e que a sprite Ralph é o bloco completo das demais animações

Para quem não conhece o sprite, aqui esta ela:

Estou montando este script -há dias o.O"

Código:

  if keyboard_check(ord("S")) then  //Abaixo
    {
      if place_free(x, y+4) then
        {
          sprite_index=RalphS;
          image_speed=0.333;
          y+=4;
        }
     
    }

   
  if keyboard_check(ord("A")) then  //Esquerda
    {
      if place_free(x-4, y) then
        {
          sprite_index=RalphA;
          image_speed=0.333;
          x-=4
        }
    }

   
  if keyboard_check(ord("D")) then  //Direita
    {
      if place_free(x+4, y) then
        {
          sprite_index=RalphD;
          image_speed=0.333;
          x+=4
        }
    }

   
  if keyboard_check(ord("W")) then  //Acima
    {
      if place_free(x, y-4) then
        {
          sprite_index=RalphW;
          image_speed=0.333;
          y-=4
        }
    }

Maaas...
não consigo pensar numa maneira pratica de o fazer O.O
Pensei nas hipótese de usar variáveis para diferenciar os movimentos de andar/correr...
e ainda penso como usar as setas direcionais e mouse para controlar o lado que a sprite do player
o movimento e o lado da sprite -o olhar dela- serem diferentes...
sendo a movimentação feita pelas letra já citadas, e "olhar" pelo mouse e setas

Outro problema foi a questão de controlar a sprite, porque elas continuam em seu movimento mesmo
quando encontra um bloqueio, e um personagem não é burro para ficar se tacando na "parede" neh '-'

Quero ver como irão usar o raciocínio lógico, e tentar desenvolver este script no decorrer deste tópico,
aberta a discussão e estudo!

Gratz, Lee

Muito simples para fazer ele andar e depois que você soltar a tecla desejada parar !

Crie quatro novos evento em um sprit
Key press
nas opção que vão abrir selecione a cada evento 1 direção.
Ex:.
Add Event > Key Press > Right
Add Event > Key Press > Left
Add Event > Key Press > Down
Add Event > Key press > Up

Va na aba move e arraste "Move Fixad" para dentro das Actions na janela que abrio selecione a direção certa (faça isso com os quatro eventos) Ex:.

Up: Subir
Down: Descer
Right: Direita
Left: Esquerda

Depois va na aba main1 e lecione chang sprits coloque o sprit de movimento do seu char. (faça com cada evento na posição certa)

Agora para parar depois que eu soltar a tecla vá em:

Add Event > Key Resease > Right
Add Event > Key Resease > Left
Add Event > Key Resease > Down
Add Event > Key Resease > Up

Va na aba move e arraste "Move Fixad" para dentro das Actions, na janela que abrio selecione o quadrado do meio em todas os eventos.
E pronto seu boneco ja está se movimentando.

Agora eu quero fazer uma pergunta...
eu vou fazer um jogo de bleach e quero fazer uma sprit ele atacando, eu faço todos os movimentos e como eu salvo em GIF ?

Assim...

eu gostaria, como eu disse, usar o menor número de D&D...
apenas o CREATE e STEP que são necessários -aturados ;p

Vou ver como isso ficaria em GML...
(depois edito aqui mesmo)



OFF:
Hmmm, sua dúvida sobre sprite, cria um tópico para ela!
Antes dê uma pesquisada no fórum, vi algumas coisas sobre isso por aqui...
só não lembro onde ou quando O.O""

Obrigado por participar e tentar me ajudar ^^
Gratz, Lee

Legal, parece que você não quer um código pronto.

Para fazer o movimento junto de animação, fica mais complicado mesmo. A melhor forma que eu conheço é usar uma variável de "Estado".
Hã?

Vou dar um breve exemplo:

Código:

if (hspeed > 0)
{estado = 1;}
else if (hspeed < 0)
{estado = -1;}
else
{estado = 0;}

Com isso temos que:
Estado = 1 = Personagem andando para a direita.
Estado = -1 = Personagem andando para a esquerda
Estado = 0 = Personagem parado.

Pra que usar isso?
Bom, facilita bastante para adicionar animação!
veja:

Código:

if (estado = 1)
{sprite_index = spr_player_andandoDir;}
else
if (estado = -1)
{sprite_index = spr_player_andandoEsq;}
else if (estado = 0)
{sprite_index = spr_player_parado;}

O jogo tem movimento em 4 ou 8 direções? Pelo seu código parece ser 8.
Você pode fazer algo assim:

Código:

var W,A,S,D,hor,ver;
W = keyboard_check(ord("W"));
A = keyboard_check(ord("A"));
S = keyboard_check(ord("S"));
D = keyboard_check(ord("D"));

if (A && !D)
{hor = 1;}
else if (D && !A)
{hor = -1;}
else {hor = 0;}

if (W && !S)
{ver = -1;}
else if (S && !W)
{ver = 1;}
else {ver = 0;}

if (hor = 1)
{
 if (ver = 1)
 {sprite_index = diagonal_DC;} //DC = direita cima
 else if (ver = -1)
 {sprite_index = diagonal_DB;} //DB = direita baixo
 else {sprite_index = spr_direita;}
}//Só coloquei parte do código... senão eu vo ta fazendo tudo...
if place_free(x+4*hor,y)
{x += 4*hor;}
if place_free(x,y+4*ver)
{y += 4*ver;}

Porem, dessa forma a velocidade do personagem vai parecer bem maior se você andar na diagonal (E vai estar mesmo), se você quiser "normalizar" isso, só precisaria modificar um pouco e saber geometria básica. Esse é um código bem simples.

Espero que tenha ajudado...

Eu sei um jeito de fazer bem facil, ponha no step:

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

if hspeed>0
{
if vspeed>0 sprite_index=sprite_direita_baixo;
if vspeed<0 sprite_index=sprite_direita_cima;
if vspeed==0 sprite_index=sprite_direita;
}

if hspeed<0
{
if vspeed>0 sprite_index=sprite_esquerda_baixo;
if vspeed<0 sprite_index=sprite_esquerda_cima;
if vspeed==0 sprite_index=sprite_esquerda;
}

if (hspeed==0)
{
if vspeed>0 sprite_index=sprite_baixo;
if vspeed<0 sprite_index=sprite_cima;
}

Gostaria de agradecer ao Janx -que é muito presente na comunidade-
potz o cara me respondeu! eu sendo um novato! O.O ~sou seu fã! o/
e ao Pedro Henrique que me deu uma boooa idéia (6)
A todos muito obrigado ~;p

Não usei nenhum código de vocês, ~u.ú
mas estudei as funções utilizadas por elas e como foram aplicadas, junto a sua lógica.

O que fiz?
Adaptando um pouco sobre a direção da sprite, deixei ela ao controle da posição do mouse,
e o controle do movimento nas teclas S, D, A, W como falei, mas ainda estou seguindo meu padrão lógico.
Gostei da idéia de Janx de usar variáveis! Dei uma olhada como são as variáveis do GM e futuramente
irão entender aquelas variáveis do meu código ~;p
Provável que use as variáveis para peculiaridades como a possibilidade de correr e olhar do player.
E o código do Pedro Henrique me deu a idéia de usar esta lógica na possibilidade de visão do player
usando comparações de coordenadas -basicamente geometria plana- do objeto player em relação a um
outro objeto que teria suas coordenadas definidas pelo mouse,..
Ainda estou trabalhando em todo o código, e é quase certeza de haver algum bug ou principalmente
erros comparações das variáveis x, y dos objetos e suas sprites.

Chega de blá blá blá e vamos ao código:

Código:

  /***************************************************
    Movimento do Player 1.0
    por WillerLee
  ***************************************************/
 
  //Movimentação
 
  var S, A, D, W;  //Variáveis de movimento

  if keyboard_check(ord('S')) then  //Abaixo
  //Checa se a tecla 'S' está pressionada,
    {
      if place_free(x, y+4) then
      //Checa se é possivel se mover 4 pixels abaixo,
        {
          S = 1;  //Salva na variável como true, e
          y+= 4  //Realiza o movimento!
        }
          else  //Senão,
        {
          S = 0  //Salva na variável como false!
        }
    }

  if keyboard_check(ord('A')) then  //Esquerda
    {
      if place_free(x-4, y) then
        {
          A = 1;
          x-= 4
        }
          else
        {
          A = 0
        }
    }
   
  if keyboard_check(ord('D')) then  //Direita
    {
      if place_free(x+4, y) then
        {
          D = 1;
          x+= 4
        }
          else
        {
          D = 0
        }
    }

  if keyboard_check(ord('W')) then  //Acima
    {
      if place_free(x, y-4) then
        {
          W = 1;
          y-= 4
        }
          else
        {
          W = 0
        }
    }
   
  /***************************************************
    Visão do player 1.0
    por WillerLee
  ***************************************************/
 
  //Campo de Visão
 
  var vS, vA, vD, vW;  //Variáveis de visão
 
  if oAim.x > oPlayer.x && oAim.y > oPlayer.y then  //Abaixo Direita
  //Checa se a seta abaixo está pressionada OU se o 'y' de oAim é maior oque oPlayer OU igual que oPlayer
    {
      if oAim.x > oPlayer.y then
        {
          sprite_index = RalphD
        } else
      if oAim.x < oPlayer.y then
        {
          sprite_index = RalphS
        }
    }
   
  if oAim.x < oPlayer.x && oAim.y < oPlayer.y then  //Esquerda Acima
    {
      if oAim.x < oPlayer.y then
        {
          sprite_index = RalphW
        } else
      if oAim.x > oPlayer.y then
        {
          sprite_index = RalphA
        }
    }

  if oAim.x > oPlayer.x && oAim.y < oPlayer.y then  //Direita Acima
    {
      if oAim.x < oPlayer.y then
        {
          sprite_index = RalphW
        } else
      if oAim.x > oPlayer.y then
        {
          sprite_index = RalphD
        }
    }
   
  if oAim.x < oPlayer.x && oAim.y > oPlayer.y then  //Abaixo Esquerda
    {
      if oAim.x > oPlayer.y then
        {
          sprite_index = RalphA
        } else
      if oAim.x < oPlayer.y then
        {
          sprite_index = RalphS
        }
    }

Ps : ainda a organizar o código
Ps2: mais alguma idéia? XD
Ps3: normalmente tenho tempo de trabalhar no meu game somente a noite, futuramente serei um
praça da marinha, ou seja, um militar graduado. Nada haver neh? Marinheiro? stafe!
Ps4: Pretendo fazer a especialização em Processamento de Dados u.ú

Opa, pensando em uma maneira prática, isso é bom!
Otimização de código em jogos é essencial.

Tenha certeza que o movimentação, animação, sons ou seja lá o que funcionem de maneira mais separada possível, ou seja, mesmo que você apague os scripts para animação, o movimento deve continuar sem bugs.
A variável para estado que Janx mencionou é bom exemplo disso. Mesmo que você apague o script onde os estados mudam as sprites o movimento continuaria a funcionar perfeitamente.

No 2D, um personagem de sprites de corpo inteiro só pode ter uma animação por vez, certo?
Uma variável estado preveniria bugs quando a isso, já que, sendo apenas uma variável você esta certo que só ela é que mudaria a animação.

Nesse ultimo script, você usa S,A,D,W.
Se S é true, naturalmente W é false...
Apenas uma variável para cima/baixo e um para esquerda direita seria necessário.

Otimizar é o poder!

Aew Kabeção, abrigado pelo lembrete ^ ^

Irei sim usar variáveis para separar os recursos, mas vou deixar para fazer esta separação
e criar as variáveis somente depois de ter o script pronto!
Assim fica mais fácil de ir me acostumando com as funções do GML ~;p

Assim,
quanto a questão das variáveis vS, vA, vD, vW,
penso que será melhor manter-las assim pois ficaria mais fácil de fazer o controle das sprites
que serão controladas pela posição do mouse...
Assim daria para ter dois casos em casa direção...
-Se possível andar na direção
-Se NÃO possível na direção
e se preciso, poderia até aumentar o número de casos facilmente ^ ^

Seria mais pela questão das colisões entende,
porque tendo elas daria para fazer alguns efeitos de colisão, e controle das sprites.
Falta agora incluir a possibilidade de correr!
E depois melhorar, organizar e re-limpar o código!

Obrigado pela sua ajuda Kabeção,
e de todos que vem dando uma conferida neste desenvolvimento!
Gratz, Lee.

Tópico resolvido?

souzalucasjose escreveu:Tópico resolvido?

Estou usando este tópico como portal de desenvolvimento de um script de movimentação,
ainda não está como eu quero que esteja...
Ainda estou acertando alguns pontos como pode ver,
para não bagunçar as coisas, poderia usar este tópico para tirar minhas dúvida sobre o
desenvolvimento e atualizar o decorrer da sua programação ^ ^

Este final de semana coloco a possibilidade de correr...
acho que dará certo, se me basear no que já me foi apresentado.

Quando terminar o desenvolvimento,
vou divulga-lo em outro tópico, irei fazer um post anunciando o fim do trabalho e deixando
o link para o tópico de divulgação e pedirei para você trancar isso daqui por PM o/
Pode ser assim,
Gratz, Lee

Desculpas pelo double-post,
não sei se é permitido para atualizar o decorrer do tópico >.<
!

Nah,
muito antes de esperava, terminei a parte do controle das sprites do char!
Agora eu tenho uma movimentação inteligente dividida por quadrantes, o player (oPlayer)
sempre estará olhando para sua mira (oAim)... maaas para deixar mais realista...


Dividi o movimento, onde cada quadrantes foi dividido em ângulos de 45º! bissetrizes
Fazendo assim 8 campos de visão!

Os campos com seus catetos menores em direção abaixo, fazem o player olhar para baixo!
Os campos com seus catetos menores em direção qualquer irá fazer o player olhar nesta
direção... isso dá uma "ar" mais realista ao jogo, e um chame a mais ^ ^

Aprendi uma função nova! abs()
Usei para calcular os valores negativos...
isso deu um trabalho... mas graças a Deus, lembrei dessa função do VB6.0 xD

Agora falta fazer o controle de bloqueio para parar as sprite quando bloqueadas, e quando
não pressionadas as teclas de movimento...
E a funcionalidade de correr! Que acho que será simples faze-la ;D

Ps: Ainda não organizei o código ^ ^
Ps2: Ainda estou aberto a opiniões XD
Otimizações sempre serão bem-vindas!
Acho que o código deva estar meio sujo... mas ao terminar meus objetivos eu irei limpa-lo.
Aqui vai minha nova atualização porque sem não fosse nova, não seria atualização XD

Código:

  /***************************************************
    Movimento do Player 1.0
    por WillerLee
  ***************************************************/
 
  //Movimentação
 
  var S, A, D, W;  //Variáveis de movimento

  if keyboard_check(ord('S')) then  //Abaixo
  //Checa se a tecla 'S' está pressionada,
    {
      if place_free(x, y+4) then
      //Checa se é possivel se mover 4 pixels abaixo,
        {
          S = 1;  //Salva na variável como true, e
          y+= 4  //Realiza o movimento!
        }
          else  //Senão,
        {
          S = 0  //Salva na variável como false!
        }
    }

  if keyboard_check(ord('A')) then  //Esquerda
    {
      if place_free(x-4, y) then
        {
          A = 1;
          x-= 4
        }
          else
        {
          A = 0
        }
    }
   
  if keyboard_check(ord('D')) then  //Direita
    {
      if place_free(x+4, y) then
        {
          D = 1;
          x+= 4
        }
          else
        {
          D = 0
        }
    }

  if keyboard_check(ord('W')) then  //Acima
    {
      if place_free(x, y-4) then
        {
          W = 1;
          y-= 4
        }
          else
        {
          W = 0
        }
    }
   
  /***************************************************
    Visão do player 1.0
    por WillerLee
  ***************************************************/
 
  //Campo de Visão
 
  var vS, vA, vD, vW;  //Variáveis de visão
 
  if oAim.x > oPlayer.x && oAim.y > oPlayer.y then  //Quadrante Abaixo Direita
  //Checa se a seta abaixo está pressionada OU se o 'y' de oAim é maior oque oPlayer OU igual que oPlayer
    {
      if oAim.x - oPlayer.x > oAim.y - oPlayer.y then //Obtem as coordenadas da mira em relação ao player
        {
          sprite_index = RalphD
        } else
      if oAim.x - oPlayer.x < oAim.y - oPlayer.y then
        {
          sprite_index = RalphS
        }
    }
   
  if oAim.x < oPlayer.x && oAim.y < oPlayer.y then  //Quadrante Esquerda Acima
    {
      if oAim.x - oPlayer.x < oAim.y - oPlayer.y then
        {
          sprite_index = RalphA
        } else
      if oAim.x - oPlayer.x > oAim.y - oPlayer.y then
        {
          sprite_index = RalphW
        }
    }

  if oAim.x > oPlayer.x && oAim.y < oPlayer.y then  //Quadrante Direita Acima
    {
      if oAim.x - oPlayer.x < abs(oAim.y - oPlayer.y) then  //Função abs(), que retorna um valor positivo
        {
          sprite_index = RalphW
        } else
      if oAim.x - oPlayer.x > oAim.y - oPlayer.y then
        {
          sprite_index = RalphD
        }
    }
   
  if oAim.x < oPlayer.x && oAim.y > oPlayer.y then  //Quadrante Abaixo Esquerda
    {
      if abs(oAim.x - oPlayer.x) > oAim.y - oPlayer.y then  //Função abs(), que retorna um valor positivo
        {
          sprite_index = RalphA
        } else
      if oAim.x - oPlayer.x < oAim.y - oPlayer.y then
        {
          sprite_index = RalphS
        }
    }

Usei da lógica de subtrair o valor do oPlayer de oAim, assim eu teria uma coordenada
precisa do objeto oAim, ou seja, da mira. E depois só foi aplicar as comparações entre os
pontos observando as regras cartesianas ^ ^
Hoje revisei uns três capítulos de trigonometria XD

Gratz, Lee

para ver a mira voce pode usar:

point_direction(player.x,player.y,aim.x,aim.y)

Se retornar um valor maior que 90, e menor que 270, esta olhando para a
esquerda, e assim por diante...fica mais facil!

obs: voce checou no codigo duas vezes se o Y do aim é maiorque o Y do player...

FLW

Salve galera!

Cada vez estamos mais próximos de um script perfeito ;D

Quero deixar o meu "Muito obrigado!" para o Pedro Henrique, que
me ajudou a economizar muitas linhas, e funções no script!
Na ultima versão do script eu usava comparação de coordenadas e suas
propriedades da trigonometria para criar quadrantes e após isso,
dividi-los ao meio com uma bissetriz, criando o efeito de "visão" do objeto.

Graças ao point_direction(x1, y1, x2, y2),
economizei muuitas linhas e tomadas de decisões, muito obrigado Pedro ;D

Dei uma revisada no que já tinha pronto, e re-organizei o desenvolver do código!
Estou usando agora variáveis, para determinar alguns pontos do script...
seguindo a idéia do Janx e Kabeção. Agora ficou muito mais prático.

Outra coisinha minha é a utilização de uma "if" que controla se o restante do código
será executado ou não, caso precise criar utilizar apenas uma parte do script ;p

Aqui segue o script:

Código:

  /***************************************************
    Movimento do Player 1.0
    por WillerLee
   
    OBS:
    No objeto, definir "Movimento = 1" para habilitar
    o controle de sua movimentação!
    Definir as teclas de controle nas variáveis:
    Abaixo =          exemplo: S
    Esquerda =        exemplo: A
    Direita =        exemplo: D
    Acima =          exemplo: W
    Definir o deslocamento em pixel's na variável:
    Deslocamento =    exemplo: 4
  ***************************************************/
 
  //Movimentação
if Movimento = 1  //Se verdadeiro, irá execultar o movimento
{
 
  var mS, mA, mD, mW;  //Variáveis de movimento
  //2 = tecla não pressionada
  //1 = movimento possivel
  //0 = movimento impossivel

  if keyboard_check(ord(Abaixo)) then  //Abaixo
  //Checa se a tecla "definida" está pressionada,
    { if place_free(x, y+Deslocamento) then
    //Checa se é possivel se mover "Deslocamento" pixels abaixo,
          { mS = 1;  //Salva na variável como true, e
            y += Deslocamento }  //Realiza o movimento!
      else            //Senão,
          { mS = 0 }  //Salva na variável como false!
    } else mS = 2
   
  if keyboard_check(ord(Esquerda)) then  //Esquerda
    { if place_free(x-Deslocamento, y) then
          { mA = 1;
            x -= Deslocamento }
      else
          { mA = 0 }
    } else mA = 2
   
  if keyboard_check(ord(Direita)) then  //Direita
    { if place_free(x+Deslocamento, y) then
          { mD = 1;
            x += Deslocamento }
      else
          { mD = 0 }
    } else mD = 2
   
  if keyboard_check(ord(Acima)) then  //Acima
    { if place_free(x, y-Deslocamento) then
          { mW = 1;
            y -= Deslocamento }
      else
          { mW = 0 }
    } else mW = 2
} 
 
  /***************************************************
    Visão do player 1.0
    por WillerLee
   
    OBS:
    No objeto, definir "Visao = 1" para habilitar
    o controle de sua visão!
    Definir os objetos de controle nas variáveis:
    Personagem =    exemplo: oPlayer
    Mira =          exemplo: oAim
    Definir as sprites nas variáveis:
    S = abaixo;    exemplo: RalphS
    A = esquerda;  exemplo: RalphA
    D = direita;    exemplo: RalphD
    W = acima;      exemplo: RalphW
    All = todas!    exemplo: Ralph
  ***************************************************/
 
  //Campo de Visão
if Visao = 1  //Se verdadeiro, irá execultar a visão
{
 
  var vS, vA, vD, vW;  //Variáveis de visão
  //1 = olhando na direção
  //0 = não olhando na direção
  Quadrante = point_direction(Personagem.x, Personagem.y, Mira.x, Mira.y)
  //Retorna a direção do ponto (x1, y1) em direcção ao ponto (x2, y2) em graus.
 
  if Quadrante <  45                    { vD = 1; sprite_index = D } else vD = 0
  if Quadrante >  46 && Quadrante <  90 { vW = 1; sprite_index = W } else vW = 0
  if Quadrante >  91 && Quadrante < 135 { vW = 1; sprite_index = W } else vW = 0
  if Quadrante > 136 && Quadrante < 180 { vA = 1; sprite_index = A } else vA = 0
  if Quadrante > 181 && Quadrante < 225 { vA = 1; sprite_index = A } else vA = 0
  if Quadrante > 226 && Quadrante < 270 { vS = 1; sprite_index = S } else vS = 0
  if Quadrante > 271 && Quadrante < 315 { vS = 1; sprite_index = S } else vS = 0
  if Quadrante > 316 && Quadrante < 360 { vD = 1; sprite_index = D } else vD = 0
}
 
  /***************************************************
    Colisão do player 1.0
    por WillerLee
   
    OBS:
    No objeto, definir "Colisao = 1" para habilitar
    o controle de colisões!
    Definir, "AlarmeDeColisao := 0" para controle de
    velocidade que será o "alarme"
    Definir o controle de steps na variável:
    Steps =    exemplo: 5
  ***************************************************/
 
  //Controle de colisões
if Colisao = 1  //Se verdadeiro, irá execultar o controle
{
  AlarmeDeColisao += 1  //Aumenta em +1 a cada Step

  if vD = 1 && AlarmeDeColisao >= Steps then 
  //Se estiver dentro do campo de visão e dentro do "alarme"
    { if mD = 1 then  //Se movimento possivel
          {
         
          }
      if mD = 0 then  //Se movimento impossivel
          {
          image_index = 1
          }
      if mD = 2 then  //Se tecla não pressionada
          {
          image_index = 1
          }
    }
   
  if vW = 1 && AlarmeDeColisao >= Steps then 
    { if mW = 1 then
          {
         
          }
      if mW = 0 then
          {
          image_index = 1
          }
      if mW = 2 then
          {
          image_index = 1
          }
    }
   
  if vA = 1 && AlarmeDeColisao >= Steps then 
    { if mA = 1 then
          {
         
          }
      if mA = 0 then
          {
          image_index = 1
          }
      if mA = 2 then
          {
          image_index = 1
          }
    }
   
  if vS = 1 && AlarmeDeColisao >= Steps then 
    { if mS = 1 then
          {
         
          }
      if mS = 0 then
          {
          image_index = 1
          }
      if mS = 2 then
          {
          image_index = 1
          }
    }
}

Agora estou trabalhando no controle de colisões!
Minha idéia é simples, usar as variáveis que determinam qual o campo de visão estou,
assim saber qual sprite estou a utilizar, e, usar as variáveis de movimento para saber
se "tecla não pressionada", "movimento possível", ou movimento "impossível" e assim
fazer a devida animação das do objeto ;D

Se alguem tiver alguma dica ou sugestão, seja bem-vindo! ^ ^

Ps: estou vendo uma possibilidade diferente da apresentada, conforme for...
Ps2: Próximo passo, possibilidade de correr!!

Grato a todos, Lee

na parte da visao vc poderia fazer assim

Código:


Quadrante = round(point_direction(Personagem.x,Personagem.y,Mira.x,Mira.y) / 45);

switch(Quadrante)
{
case 0: // angulo 0
vD = 1;
sprite_index = D;
break;
case 1: // angulo 45
//code
break;
case 2: // angulo 90
//code
break;
case 3: // angulo 135
//code
break;
}


Se você quer passa uma sensação de maior jogabilidade para o jogador, seria interessante suavizar os movimentos.
Seria ideal para um jogo com movimento livre como o Chrono Trigger do SNES e assim aplicar uma ação para correr será fácil.

Eu sempre uso duas variaveis básicas para controlar o movimento: x_speed e y_speed.
Em vez de acrescentar ou diminuir o x ou o y do objeto eu acrescento ou diminuo o x_speed e y_speed:

Código:

x_speed = 0;
x_fator = 0.2 // fator de aceleração x
x_max = 5 // velocidade máxima para x

y_speed = 0;
y_fator = 0.2 // fator de aceleração y
y_max = 5 // velocidade máxima para y

if keyboard_check(ord('W')) y_speed -= y_fator;
if keyboard_check(ord('S')) y_speed += y_fator;
if keyboard_check(ord('A')) x_speed -= y_fator;
if keyboard_check(ord('D')) x_speed += y_fator;

// Limitar velocidade
if abs(x_speed) > x_max y_speed = x_max*sign(x_speed);
if abs(y_speed) > y_max y_speed = y_max*sign(y_speed);

x += x_speed;
y += y_speed;

Isso faz com que o movimento comesse lento e ganhe velocidade e da mais realidade já que um carro não atingi 100 k/h antes de passar pelos outros 99.

No caso, para correr bastaria aumentar o fator e o valor máximo da velocidade quando se apertasse e segurasse uma tecla.
A animação se basearia na velocidade usando image_speed, quanto maior o velocidade, maior o image_speed.
Quando nem uma tecla de movimento esta sendo pressiona os valores diminuem proporcionalmente.

Código:

x_speed /= 1.2; // diminuir de forma escalar (20% por step)
y_speed /= 1.2; // diminuir de forma escalar (20% por step)

Também se pode fazer a aceleração de forma escalar.

Código:

x_speed *= 1.03; // aumentar 3% a cada step
y_speed *= 1.03; // aumentar 3% a cada step

Essa suavização faz muita diferença no resultado final.

Um muito obrigado ao dungeon333,
sua idéia tem uma lógica interessante!
Vou usa-la para evitar ficar fazendo as comparações, e determinação de quadrantes,
acho que isso irá limpar ainda mais o código
Quando mais fluente, melhor!
Ps: e o mais importante! Mais uma função para minha mente colecionar XD
Mais uma vez obrigado!

E um agradeçimento especial ao Kabeção,
sua idéia foi divina! A movimentação com aceleração -igual aos dos clássicos- é simplesmente
magnífica! Além de cortar a necessidade de criar mais variáveis e linhas para uma nova funcionalidade.
Com certeza irei aproveitar sua dica no script! Muito, muito obrigado! XD

Estou gostando da comunidade, o acervo é lindo! *-*
Parabéns a administração, staff e membros que fazem a familia XD
Ps2: Vou implementar as novas mudanças... dar uma revisada no código em geral...
e talvez amanhã poste a atualização. Hei desenvolve-lo hoje a noite xD

Ps3: ainda trabalhando na parte de controle de colisões do objeto...
ainda não tenho nenhuma idéia de como faze-la... apenas um leve noção de como deva ficar.

Gratz, Lee

Há muita coisa que se pode fazer para as colisões.
O básico é empurrar o objecto para fora quando ele estiver colidindo.

Algo como:

while place_meeting(x+2,y,objParede)
{
x -= 1;
}

Ele vai executar isso até o objeto saiu e evita que fique travado dentro dele mas também pode geral muitos bug se usado de qualquer jeito.

vc tbm poderia fazer assim , pegar o objeto que está colidindo e mudar o x e y de acordo com a pos dele (aqui está baseado nos seus sprites se estiverem centralizados )

Código:


var c;
c = place_meeting(x + 17,y,objParede)
if (c)
{
x = min(x,c.x - 16)
}
c = place_meeting(x - 17,y,objParede)
if (c)
{
x = max(x,c.x + 16)
}


Para colisão eu, sinceramente, acho muito melhor usar as funções "collision", você tem muito mais controle sobre elas.

Os tutoriais de colisão do AlexFC tratam bastante sobre esse assunto.
http://www.gamemakerbrasil.com/game-maker-f36/aulas-de-game-maker-por-alex-fc-t3569.htm