[TUTORIAL]+[ENGINE] escolhendo controles no jogo

Hoje vou explicar para vocês como definir os controles no jogo, de uma maneira simples e prática, vai funcionar dessa maneira
Criamos 1 variavel que armazena o valor dos controles e dois botões para mudar o valor dessa variável, se o valor dessa variável for igual a um valor x, então os comandos serão um, se a var for outro valor os comandos serão oputros e assim por diante.
Antes vou dizer que é mais simples do que se parece, sabendo um pouquinho de gml da pra se fazer tranqüilo, vamos lá

Crie 3 sprites, são elas:

Sprite do player, sprite de uma seta apontada para > e uma seta apontada para <, essas setas serão os botões que quando clicados vão aumentar e diminuir o valor da variável.
Agora crie um obj_control e no create dele coloque o seguinte:

global.controles=0
global.cima=vk_up
global.baixo=vk_down
global.esq=vk_left
global.dir=vk_right
- Só isso? Apenas estamos definindo variaveis globais onde ficara armazenado o valor dos controles , as variáveis de comando , cima baixo, etc o valor delas pode ser alterado por qualquer outra tecla, mas tenha em mente que esses serão os controles iniciais do seu player

Agora no draw desse obj vamos fazer um debug

if global.controles=0
{
draw_text (10,128," Agora voce esta usando o modo de setas para controlar seu player");
}

if global.controles=1
{
draw_text (10,128," Agora voce esta usando o modo de WASD para controlar seu player");
}

if global.controles=2
{
draw_text (10,128," Agora voce esta usando o modo de numeros (4,6,2,8 )para controlar seu player");
}

O que fizemos? Apenas checamos, se o valor da variável for 0 entao escreva na tela que estamos usando o modo de setas para controlar, se for 1 escreva que estamos usando o modo de WASD e se for 2 escreva que estamos usando o modo de números (4,6,2,8 )
Isso é apenas um debug para tu ter certeza de que esta dando certo.
Coloque agora meia colher de margarina um evento step e nele escreva o seguinte:

if global.controles>2
{
global.controles=0
}
if global.controles<0
{
global.controles=2
}

O que fizemos?? Checamos quando a var global.controles for maior que 2 ela se torna 0
e quando a var global for menor do que 0 ela se torna 2

E depois , nesse mesmo evento step coloque o seguinte

switch(global.controles)
{
case 0: global.cima=vk_up
global.baixo=vk_down
global.esq=vk_left
global.dir=vk_right
break;
case 1: global.cima=ord("W")
global.baixo=ord("S")
global.esq=ord("A")
global.dir=ord("D")
break;
case 2: global.cima=vk_numpad8
global.baixo=vk_numpad2
global.esq=vk_numpad4
global.dir=vk_numpad6
break;
}

AAAH meu deus que isso? Com a ajuda do saim, graças a isso daí o code ficou mais flexível, explicando:
Caso a var global.controles=0 definimos as variáveis de controle que declaramos no incio do tuto como vk_up, vk_down, etc...
Caso a var for=1 definimos as variáveis de controle com WASD
E caso for 2 declaramos essas variáveis como números (4,2,8,6)
Mas porque não usar o if?
Ai que vem a parte em que o saim me ajudou, na hora de fazer a movimentação do player vai ficar muito mais fácil pois tu so vai precisar colocar if keyboard_check(global.nomedavardecontrole)
{} não precisaremos checar a cada valor da variavel global.controles apenas colocamos para os controles ser igual as variáveis de controle, dessemodo ficou muito mais flexível pois se quiser alterar as teclas de controle não precisa mecher no code toodo apenas mecher na parte do case trocando seus valores pelas novas teclas que quiser, explicando assim parece complicado mas dê uma lida no código do case e é so interpretar.

Agora crie mais um objeto e coloque a sprite da seta virada para > que tu tinha feito no inicio do tutorial e coloque o evento do mouse left pressed e coloque o seguinte code:
global.controles+=1
Apenas aumentamos +1 da variável global.controles

Agora crie mais um objeto e coloque a sprite da seta virada para < e adcione o evento do mouse left pressed e coloque o seguinte code
global.controles-=1
Apenas diminuímos 1 da variável global.controles

Agora para fazermos a movimentação do player ficou muito mais fácil pois apenas na hora de definir a tecla definiremos a variável correspondente a tecla utilizada
No evento step do player coloque o seguinte:

if keyboard_check(global.esq)
{
x-=6
}
if keyboard_check(global.dir)
{
x+=6
}
if keyboard_check(global.cima)
{
y-=6
}
if keyboard_check(global.baixo)
{
y+=6
}
Entendeu? Agora não precisamos mais declarar os vk_up, ou ord, ou vk_numpad apenas colocamos as variáveis que correspondem a cada comando e como no código do case já foi checado para as variáveis terem um determinado valor quando a var for um numero x então não precisaremos declarar tudo de novo

Claro que tu pode personalizar tudo, não precisa necessariamente usar essa troca de controles para apenas movimentação pode ser usado para o que tu quiser
E também as setas podem ser outra coisa, pode ser uma tecla pressionada, pode ser o que quiser basta entender o que foi feito nos codes e ter 3 poneys rosa em casa.
É isso gente como vocês viram é super simples de se fazer e só requer um poquinho de atenção
ahh antes que eu esqueça ta ai a engine pra quem ta com preguiça de ler xD
Download

Créditos : saim que me ajudou a personalizar o code para ficar mais flexivel
Flws

Interessante, mas tenho uma dica: não seria melhor armazenar os controles em uma unica array do que criar uma variável global para cada tecla?

No caso simples de apenas os direcionais pode estar tudo bem, já que são apenas 4 teclas, mas imagine um jogo que tem inúmeras funções espalhadas pelo teclado, seria um desperdício de memória criar uma variável global para cada item.

No mais parabéns pelo artigo, personalização é um assunto legal.


flw............

com certeza irá ajudar os novatos a variar os comandos dos seus jogos.
mas como o HB disse, tem que diminuir o tanto de var global, poderia usar apenas uma var global, que definiria qual comando usar, e usar var simples que se altera dependendo do valor da var global.
parabéns.

continue com seus tutoriais...

Mas qual seria a diferença se criasse uma array? porque eu teria que fazer uma pra controle
exemplo

controles[0]=vk_up
controles[1]=vk_down
controles[2]=vk_left
etc ....
seria isso? mas daria no mesmo, ou então eu nao compreeendi o que voces falaram

valeu pelo coment ai galera amanha eu acho que ja posto outro tuto mas to um pouco sem ideias, quem tiver alguma ideia, pode mandar, se eu souber eu faço um tuto

flws

pense o seguinte:
isso esta no objeto_joao
controles[0]=vk_up
controles[1]=vk_down
controles[2]=vk_left
global.controles[0]=vk_up
global.controles[1]=vk_down
global.controles[2]=vk_left

ao compilar o jogo, isso continuará no objeto_joao
controles[0]=vk_up
controles[1]=vk_down
controles[2]=vk_left
global.controles[0]=vk_up
global.controles[1]=vk_down
global.controles[2]=vk_left

e isso será carregado por todos os outros objetos:
global.controles[0]=vk_up
global.controles[1]=vk_down
global.controles[2]=vk_left

ou seja, se você cria uma variavel global ela "causa" efeito em todos os objetos, se você cria uma variavel local ela causa efeito apenas no próprio objeto.

resumindo a variável global vai deixar seu jogo mais "pesado".

ahh sim cara é que tipo eu usei uma variaveis globais para que no caso o cara que as declarou possa usá-las em qualquer outro objeto, sem ter que chamar pelo objeto em que essas variaveis foram declaradas
mas ai fica a critério do criador, se quiser usar variaveis globais usa se quiser usar locais use
ai é com voces xD

vlw

flws

CogumeloDoRock escreveu:a variável global vai deixar seu jogo mais "pesado".

Como assim, mais pesado? Da forma que eu entendo, uma variável pesa o mesmo tanto, sendo global ou local. A diferença é que só o objeto a instância em que a local foi declarada tem acesso a ela, enquanto todos os objetos têm acesso às variáveis globais. Olhando dessa forma, uma variável global que só é declarada no início do jogo seria mais leve que uma local que seja declarada no create event de cada instância.
Mas isso é a forma que eu entendo, eu posso estar errado. Se for o caso, me expliquem como o programa funciona.

Quanto às arrays pra muitos comandos, acho interessante mas pouco... como dizer... subjetivo? Quero dizer o seguinte: estou eu lá, programando, e quero fazer o jogador atirar ao apertar a tecla de tiro. A tecla de tiro vai estar armazenada na array como "comando[8]". Eu teria que anotar o valor de cada índice da array, certo? Isso é flexível, mas pouco... caramba, qual é a palavra? Auto-explicativo?
Uma forma de contornar esse problema seria declarar os índices da array como constantes, nos resources. "pradireita=0", "pracima=1", "tiro=8". Daí, eu poderia chamar comando[tiro]. Mas não sei se isso é melhor que declarar variáveis globais.

vou te provar que uma variável global é mais pesada que uma variável local!!!
variável global afeta todas as variáveis enquanto a local, apenas uma!!

faça o seguinte:
vai no GM, crie um objeto e cole isso no evento create:
jab = 8
global.jab = 18

agora vá no evento draw e cole isso:
for (i=0;i<50000;i+=1)
{
jab = random(500000)
}

draw_text(20,20,"FPS: "+string(fps)+"/"+string(room_speed))
draw_text(20,50,"jab: "+string(jab))

ai está configurado para testar com a variável local, dps de ver a quantos FPS fica, transforme as variáveis para global e execute de novo.
aqui no meu PC, quando fiz esse teste de var, com a variável global o FPS ficava a 22, quando fiz o teste com uma variável local, o FPS ficava a 23 e logo em seguida ia para 24.

ou seja uma variavel local gasta menos memória que uma global.

o teste foi feito com a velocidade da room a 60 steps por segundo.

e em outro teste que fiz aqui, criei 10 mil variáveis globais e 10 mil variáveis locais em executáveis diferentes, o .exe de variável global era maior em tamanho que o de variável local.

Contra os fatos, não há argumentos. Isso é novidade, pra mim. Realmente lidar com variáveis globais deixa o jogo mais lento. Porque isso acontece?
Supus que fosse porque estamos usando uma variável de outro objeto (global) e testei o seguinte: criei um segundo objeto e mandei repetir a mesma função - random(5) - mas puxando a variável local do outro objeto. Eis a ordem de velocidades que eu encontrei (da mais rápida pra mais lenta):

- usar variável local do mesmo objeto
- usar variável global
- usar variável local de outro objeto

É o que você falou que acontece, mesmo? Quer dizer, cada vez que você usa uma global, ela é atualizada em um-a-um dos objetos? Eu entendia que ela ficava armazenada num objeto persistente chamado "global" (que tem a id=-5) e que era acessada através dele. Se fosse assim, usar global ou acessar através de outro objeto qualquer seria a mesma coisa. Mas não é.
Eu usei "globalvar" e "global.", não sei se isso influencia alguma coisa (parece que não).
Eu estou meio perdido, agora.