Movimentação de 4 lados

Bom,o que quero fazer,é oque está na imagem.

Quero que o player ande pelas bordas da tela,como se fossem "trilhos".
Mas,como fazer para que,ele só ande pelas bordas,e de acordo com o lado que ele está,mudar o angulo?
Porque o "player" vai ser um canhão(sim,tipo aquilo do BomberMan ).

Tem jeito de fazer isso?

Você colocar objetos nos cantos para quando o canhão colidir com os objetos ele mudar de direção e sprite essas coisas mas isso é uma forma generica de faser isso deve ter maneiras mais simples com apenas algumas linhas de codigo,
não sei se o path funciona para essa função ai mas acho que sim funciona sim!

O user Kapoty um dia me mostrou uma engine com essas funcionalidades ai se ninguem te ajudar manda uma mp pra ele que ele deve te ajudar.

Edit:
Tipo se você não tiver conseguindo usa a forma generica ai depois pode voltar atraz e alterar fazer algo mais profissional

usa A* pathfinding, o saim tem um tutorial e tem engines assim no fórum, acho que vai funcionar.
Tutorial do saim : https://gmbr.forumeiros.com/t18178-a-pathfinding-lite
As engines eu não achei

A ideia de usar objetos para os cantos é boa,se não achar um jeito mais,como você disse,"profissional",vou usar

Sobre o A*,eu tenho algumas dúvidas sobre isso,ele retorna um path,certo?
E como se aplicaria ela no meu projeto?

Eu tentei desse forma...

Código:

//movimentos e animação
switch(keyboard_key)
{
    case vk_left:
        if y==100 || y==400
        {
            if x>=100 && x<=500
            {
                hspeed = -5;
                if y==100
                {
                    sprite_index = spr_down;
                } else {
                    sprite_index = spr_up;
                }
            }
        }
    break;
    case vk_right:
        if (y==100 || y==400)
        {
            if (x>=100 && x<=500)
            {
                hspeed = 5;
                if y==100
                {
                    sprite_index = spr_down;
                } else {
                    sprite_index = spr_up;
                }
            }
        }
    break;
    case vk_up:
        if x==100 || x==500
        {
            if y>=100 && y<=400
            {
                vspeed = -5;
                if x==100
                {
                    sprite_index = spr_left;
                } else {
                    sprite_index = spr_right;
                }
            }
        }
    break;
    case vk_down:
        if x==100 || x==500
        {
            if y>=100 && y<=400
            {
                vspeed = 5;
                if x==100
                {
                    sprite_index = spr_left;
                } else {
                    sprite_index = spr_right;
                }
            }
        }
    break;
    case vk_nokey:
        hspeed = 0;
        vspeed = 0;
    break;
}
//limites simples
if x<100
{
    x = 100;
}
if x>500
{
    x = 500;
}
if y<100
{
    y = 100;
}
if y>400
{
    y = 400;
}

...e deu certo aqui.
Repare que eu não precisei criar variáveis até então.
É útil pra você?

Entendi,você checa pelas posições né?
Achei um pouco complicado o código,pouco flexivel...
Mas eu queria uma coisa tipo assim:

São apenas duas teclas,a seta da direita e da esquerda,que só colocam uma velocidade,dai quando colidissem com o canto,trocassem a direção para o respectivo canto

Pra simplificar em duas teclas o melhor mesmo é usar path.
Fiz esse exemplo pra você, aí você faz os blocos de image_angle do seu canhão.
No create:

Código:

caminho = path_add();
path_add_point(caminho,100,100,30);
path_add_point(caminho,500,100,30);
path_add_point(caminho,500,400,30);
path_add_point(caminho,100,400,30);
path_set_closed(caminho,1);

No step:

Código:

switch(keyboard_key)
{
    case vk_right:
        lugar = path_position;
        path_start(caminho,30,1,1);
        path_position = lugar;
    break;
    case vk_left:
        lugar = path_position;
        path_start(caminho,-30,1,1);
        path_position = lugar;
    break;
    case vk_nokey:
        path_end();
    break;
}

Vê se ta legal assim!

É,agora que eu percebi,com apenas 2 teclas fica estranho,pois os movimentos se invertem...

Peguei o seu primeiro código,e ao invez de usar sprites,coloquei image_angle,e as transições de angulo ficam duras.

Teria algum jeito de fazer o objeto ir rodando?

Sobre Girar Suavemente, acho que isso resolveria seu problema: https://gmbr.forumeiros.com/t24194-resolvido-ids-ainda-mas-dessa-vez-alvo-constante-e-giro-suave#179938 Engine te Thyago

Valeu!
Fiz uma engine aqui do que mais ou menos eu quero:
http://www.mediafire.com/?su4onfoldyhuqy9

Só que falta adaptar a movimentação,e não sei como fazer isso =/
Pode ser só as 2 teclas ;)

eu a faço para ti, mas eu sei que existe uma engine que tem esse sistema, se você tiver o Pacote de 203 Engines(acho que todos deveriam ter), você pode achá-la, não me lembro o nome dela, mas ela é com aquele bicho do mário que é um casco, e há uns com espinhos em cima.

Se Lembrar eu o coloco.

Objetos pras paredes são essenciais se você não quiser ficar checando a posição o tempo todo.
Bom, com duas teclas tem dois jeitos de fazer esse movimento. Um é fazer as teclas representarem sentidos "horário e anti-horário", que é relativamente simples num jogo ortogonal (como é o caso do bomberman e parece ser o seu caso).
Outro, um pouco menos simples, é fazer as teclas alternarem entre "direita a esquerda" e "sobe e desce".
Só pra não criar dúvidas: no primeiro caso, a mesma seta que faz o canhão andar pra direita na parte de baixo da tela faz ele andar pra esquerda na parte de cima.

Vou te dizer como eu faria pro primeiro caso. No evento da tecla estar apertada, você faz um loop, procurando por colisões com as paredes (que eu já falei que seriam uma boa, elas podem até ser invisíveis). Um loop assim:

Código:

var i;
for(i = 0; i < 4; i += 1){
if (place_meeting(x + lengthdir_x(1, i  * 90), y + lengthdir_y(1, i * 90), objParede){
colisao[i] = true;
}
else {
colisao[i] = false;
}
}

Simples, né? Se colide a um pixel na direção, a variável vira true, senão, false.

Aí vem a parte que eu não tenho muita certeza do que fazer. É que depois do loop, a gente já tem a situação atual. Em função de onde está a parede, a gente sabe pra onde tem que ir. Primeiro a situação simples, aquela em que apenas uma das colisões retornou true. Se o evento estiver na tecla "sentido horário", a gente precisa andar na direção da colisão + 90 graus. Diacho de teclado sem símbolo de graus... Se for na outra tecla, usa essa direção MENOS 90m graus.
Mas nos casos em que duas direções retornam "true" (ou seja, nos cantos)? Não consigo imaginar uma equação simples pra isso... Acho que vai ser preciso tratar esses casos como exceções. Naquele loop acima, adiciona-se um contador de colisões, se ele for maior que um, é o caso de ir pra um switch, ou coisa do tipo.

Aqui está a Engine que fiz para você, foi em cima de seu exemplo, por isso fiz com 4 objetos:
http://www.mediafire.com/?uurvmkd9ebxm3g8
Se quizer (caso for necessário) eu posto no 4Shared.

É exatamente oque eu queria!
Só que,se der uma volta,ele fica com os controles ao contrarío =/
Será que tem algum jeito de resolver isso?

Fiz um exemplo com algo a mais.
Mudança de ângulo de imagem de modo suave e um movimento bem diferente dos que somos acostumados a jogar. Quem sabe inovador.
Brinque por uns 5 minutos com esses movimentos e vai entender.
Link: https://dl.dropbox.com/u/70151484/bomber.gm81
As teclas o leva pro lugar certo, mas se não a soltar, o personagem fica se movimentando pro lado que corresponde a ela.

Tem como fazer essa engine em GM8?É porque eu não tenho o 8.1...

Luca$ escreveu:Tem como fazer essa engine em GM8?É porque eu não tenho o 8.1...

Poxa amigo, desculpa!
Vou ver se encontro um conversor aqui e já do um edite...

****Editado****
...pronto. Converti com o Lateral GM.
Pode usar esse link: https://dl.dropbox.com/u/70151484/bomber.gmk

To percebendo que esse tipo de movimento é muito complicado...
Achei que fosse ser apenas com os objetos de 4 cantos,e quando colidisse mudasse a direção...
Porque de path eu não entendo mtu =X

Valeu pela engine