Copyright © 2022 Gabriel Vinicius de Souza. Todos os direitos reservados.

Este documento ou qualquer parte dele não pode ser reproduzido ou usado de forma alguma
sem autorização expressa, por escrito, do autor ou editor.

Curso RPG - Game Maker Studio 2

Do básico ao avançado

Tópicos
1. Introdução
a. Como criar um jogo?
b. O que é programar?
c. O que iremos aprender nesse curso
d. Introdução ao Game Maker

2. Movimentação e Colisão
a. Movimentação Básica e Projéteis (Coordenadas e Direções)
b. Movimentação Melhorada e Colisão Perfeita (Cálculo de Direção e Loops)
c. Inimigos (States e Scripts)
d. Câmera Suave (Camera e Views)
e. Orientação de Sprite para o Mouse/Teclado (Sprites e Switch)
f. Vida e receber dano (Draw GUI e States do jogador)
g. Novos inimigos/Adicionando Sprites (Parents)
h. Placas (Textos)
i. Status e Level Up (Definir dano, vida e outros status)
j. Nova arma para o jogador (Hitbox e Ataque ‘melee’)
k. Mostrar Dano causado
l. Roll/Dash (Invunerabilidade)
m. Npcs (Diálogo e Paths)
n. Ciclo Dia e Noite
o. Inventário e Drop de Inimigos
p. Craft
q. Plantação
r. Construção
s. Bosses
 Introdução

Como criar um jogo?

Essa é uma pergunta que na verdade eu não tenho como responder, mas eu
precisava de algum nome para o primeiro tópico, o motivo é que não existe uma única
resposta, da mesma forma que não existe apenas uma maneira de se aprender algo. O
que será apresentado nos próximos tópicos, são dicas e explicações que ME AJUDARAM
a aprender e desenvolver minhas habilidades, e espero que ajudem vocês ou pelo menos
ajude a entender qual a melhor forma para VOCÊ aprender.

O que é programar?
Durante o curso, nós iremos abordar muitas das áreas envolvidas no
desenvolvimento do jogo, algumas delas são:

● Programação
● Game Design
● Pixel Art
● SFX (Efeitos sonoros)
● VFX (Efeitos visuais)

E destas a que mais falaremos é a programação, então antes de tudo vamos

entender, o que é programar um jogo?
Meu objetivo com essa pergunta não é explicar tecnicamente o que é a
programação, como o seu computador processa os códigos, como sua memória RAM
armazena dados ou como sua placa de vídeo renderiza o jogo, para falar a verdade eu
nem tenho ideia se o que falei anteriormente faz sentido e está correto, e esse é o
exemplo perfeito de como você não precisa entender muito de tecnologia ou ciências
exatas para aprender a programar e criar seus jogos.
Na minha experiência (e o motivo de eu gostar de programar), para aprender a
programar, você precisa gostar/desenvolver 3 principais habilidades:

● Solução de Problemas: Eu gosto de pensar em programação como um grande

quebra-cabeça, no sentido que existem algumas técnicas que você pode aprender
que irão facilitar o processo de programar, porém cada mecânica de um jogo é um
novo problema a ser resolvido, com suas próprias nuâncias e dificuldades, então
você precisa estar disposto a errar e buscar novas soluções para cada problema
que você se deparar, e os problemas NUNCA irão acabar em programação, não
importa quantos anos de experiência você tenha, você sempre irá descobrir novas
formas de programar e novas maneiras de resolver problemas.
 ● Criatividade: ‘Criatividade’ não é uma palavra que eu gosto muito de usar, porque
na maioria das vezes as pessoas vêem a criatividade como um “super poder” onde
você possui ou não. Porém eu acredito que criatividade esteja ligado à referências
e experiências na vida, e a sua capacidade de criar ligações entre elas, e é
basicamente isso que se trata a programação, você pegar problemas e criar um
caminho que se liguem e se transformem em uma solução. E quando eu digo
CRIAR um caminho, é exatamente isso, não existe uma fórmula para se seguir, o
mesmo problema em programação pode ser resolvido de mil maneiras diferentes,
e cabe a você desenvolver uma forma criativa de resolvê-los.

● Curiosidade e Limitação: O que eu quero dizer com ‘curiosidade e limitação’ é estar

disposto a buscar como resolver os problemas, e aprender como procurar ajuda.
Um exemplo que posso dar é a minha falta de conhecimento em relação à alguns
tópicos de matemática, porém existem muitas pessoas que são melhores do que
eu nesses tópicos, então eu possuo 2 opções: Buscar ajuda de alguém que
entenda mais do assunto e aprender apenas o que é necessário para mim ou
quebrar a cabeça e ficar estressado tentando entender um assunto complicado
que eu provavelmente irei usar uma vez para uma mecânica específica.
Obviamente se for interessante, você pode aprender mais sobre os tópicos
profundamente, porém muitas vezes você irá copiar uma solução que você
encontrou, entender rasamente o que está acontecendo e seguir em frente, e em
algum momento no futuro, com mais conhecimento, você entenderá melhor. Saber
seus limites e o que é possível aprender e executar em certos momentos pode te
salvar muitas dores de cabeça, então tenha calma, programar é um processo
demorado principalmente no início, e infelizmente eu devo dizer, o seu primeiro,
jogo não será o jogo mundo aberto super incrível que você está planejando fazer
com mecânicas maravilhosas e um combate nunca antes visto (Nem esse jogo
que faremos durante esse curso), mas isso não quer dizer que você não pode criar
coisas divertidas que irão ajudar você a criar seu projeto dos sonhos no futuro.

O que iremos aprender nesse curso?

Agora sim iremos entrar no que interessa, O RPG QUE IREMOS CRIAR DURANTE O
CURSO, porém antes eu gostaria de explicar o porque eu escolhi fazer um RPG, e o motivo
na verdade é bem simples: em um RPG você pode fazer o que você quiser. Com isso eu
quero dizer que um RPG abranje tantas mecânicas diferentes, que é o tema perfeito para
um curso de programação de jogos. Então antes de finalmente começarmos a criar nosso
jogo, eu gostaria de dizer que esse curso não irá te ensinar necessariamente a fazer
apenas um RPG, mas nós iremos aprender a programar muitas mecânicas diferentes que
poderão ser aplicadas em muitos dos seus projetos futuros, mesmo que eles não tenham
NADA a ver com um RPG.

E eu estou muito ansioso para ver o que vocês irão criar com esse
curso!!
 Introdução ao Game Maker
(Recomendo manter o Game Maker aberto a partir desse tópico e testar tudo que for
apresentado a partir de agora)

Se você nunca abriu o Game Maker ou nunca mexeu com programação essa
sessão é muito importante, então vamos começar.

(tela inicial do Game Maker)

A primeira vez que você abrir o Game Maker e iniciar seu projeto, você irá ver essa
tela, esse é lugar onde iremos criar nosso jogo. À esquerda (talvez direita para você)
temos as nossas pastas, e elas representam as diferentes funcionalidades do Game
Maker, e o que podemos criar nele, por exemplo: objects, sprites, tile sets, fonts, paths,
etc… Porém, iremos ver um por um com muita calma. Começando pelos ‘Objects’.
Obs: é possível alterar a linguagem do Game Maker para português se necessário, porém
eu recomendo seguir com ele em inglês pois a programação utiliza palavras em inglês e acho
mais fácil entender dessa maneira, recomendo tentar utilizar o Google Tradutor se possível, mas
abaixo ireia mostrar como alterar a linguagem.

(Selecione a opção ‘File’ -> ‘Preferences’ -> ‘General Settings’ -> IDE Language)
 Então para começar iremos criar o nosso primeiro objeto, para isso basta seguir os
seguintes passos:

(Clique com o botão direito na pasta ‘Objects’, selecione ‘Create’ e depois ‘Object’)

Parabéns!! Você criou seu primeiro objeto!! Porém é bom primeiro entendermos
o que é um objeto, então vamos lá!
O objeto é onde iremos executar todo o nosso código, então tudo que
acontecerá dentro do nosso jogo será executado em um objeto, desde um
personagem até um menu. Essa é a ideia básica, temos muito mais para entender
porém com o tempo cobriremos todos os tópicos.
Agora se você criou seu ‘Object’ você irá ver essa janela:

(Editor de Objetos do Game Maker)

 Temos muitas informações nesse Editor de Objetos, por enquanto iremos
ignorar a maior parte e focar nos ‘Eventos’. Se selecionarmos ‘Add Event’ veremos a
lista de eventos possíveis que esse Objeto pode executar, por enquanto iremos ignorar
a maioria e focar no ‘Step Event’ para entendermos a programação, então podemos
selecioná-lo.

(Editor de Código do Game Maker)

Essa é a janela que mais iremos ver durante nosso curso, é aqui onde
escreveremos nossos códigos, mas primeiro vamos entender, como funciona a
programação e quais são os básicos que precisamos entender.
Resumidamente, a programação é a maneira como nos “comunicamos” com o
computador. Para nos comunicarmos utilizamos uma linguagem de programação que
é interpretada pela Engine, no nosso caso a engine é o Game Maker e a linguagem de
programação é a GML (Game Maker Language), porém temos muitas engines por aí
que utilizam muitas linguagens diferentes, ela se diferenciam de alguns maneiras mas
na maioria a lógica que seguimos para programar é a mesma, por exemplo a Unity,
Godot, Unreal, etc…

● O Básico da Programação (Lógica, variáveis, operadores e

funções)

Então vamos falar sobre a linguagem de programação do Game Maker, para

isso vamos ver a seguinte imagem:
 O que temos acima é o que chamamos de variável, e as variáveis são utilizadas
para guardar informações que podem ser usadas depois de definidas, elas podem
assumir quaisquer nomes, então poderíamos escrever:

● variavel = 5;
● numero = 5;
● asuidhsaiudha = 5;
● umapalavraqualquer = 5;

Onde a palavra é uma referência para o valor que atribuímos, então se nós
criarmos essa variável ‘numero = 5’ e nós definirmos para o Game Maker desenhar
essa variável na tela, ele desenharia o número ‘5’.
Agora que entendemos a ideia geral de uma variável, vamos esclarecer o que
podemos armazenar dentro das variáveis. Os tipos de informações que podem ser
armazenadas são: Números Reais, “Strings”, Integers e Booleans.
● Real Numbers: Número reais são números que podem possuir decimais. Tanto
números negativos quanto positivos.
○ Exemplo: 23, -12, 6.99, 5/2, 3.14, etc…
● Strings: Strings são apenas letras, então se definirmos uma variável como
“Jogo” ela é uma string. É importante lembrarmos que strings devem ser
escritas entre aspas (“”).
○ Exemplo: “Jogo”, “Gabriel”, “Programar”, etc…
● Integer: Integrais são números que não possuem casas decimais. Podem ser
tanto números positivos quanto negativos.
○ Exemplo: 1, 2, 3, 123123, -28193, -100, 3456, 0, etc…
● Booleans: Boolean é um tipo de informação que só pode assumir dois valores
diferentes, verdadeiro ou falso. Onde uma variável definida como verdadeira
pode ser interpretada pelo valor 1 e uma variável definida como falsa pode ser
interpretada pelo valor 0.
○ Exemplo: true, false, 1, 0.

Obs: no futuro abordaremos melhor esse tópico, mas é bom termos em mente que alguns tipos
de variáveis não poder ser combinadas, por exemplo, não podemos juntar uma ‘String’ com um número,
seja ‘Integer’ ou ‘Real Numbers’, para que isso seja possível precisamos converter o número em uma
string, no caso do Game Maker isso pode ser feito utilizando a função string() (variável que queremos
converter).

Agora que abordamos as variáveis vamos dar uma olhada na seguinte imagem:
 O que vemos nessa imagem é a estrutura básica de um código no Game Maker,
para simplificar vamos abordar da seguinte maneira:

As duas imagens representam a mesma ideia, então vamos entender agora o

que são as condições, expressões e afirmações:

● Condição: Podemos pensar na condição como um interruptor de uma lâmpada,

nós possuímos 2 possibilidades: aceso ou apagado. Agora se convertermos
para a linguagem de programação seria: verdadeiro (true) ou falso (false), ou
seja, essa condição está sendo correspondida (está acontecendo) ou não.
Existem muitas condições que podemos utilizar no Game Maker, por exemplo: if,
else, else if, for, while, repeat, etc… Cada uma corresponde a uma condição à
ser executada. Então para começarmos a entender, vamos abordar a mais
simples: ‘if’, se traduzirmos para o português seria ‘se’, então vamos traduzir
toda a imagem abaixo.

Podemos ler da seguinte maneira esse código: “Se (if) a variável (variavel) for
igual (==) a 5, a variável (variavel) será (=) 10”
Agora se pegarmos apenar o que coloquei em parênteses temos:
if variavel == 5 variavel = 10;

Resumo: A condição é o que determina de um código irá ser executado ou não

● Expressão: A expressão é o que determina se a condição deve ser verdadeira ou

falsa, então usando o mesmo exemplo anterior

Aqui podemos ver que a expressão é ‘variável == 5’, ou seja, o código só irá
acontecer se a variável (variavel) for exclusivamente igual a 5, então se
definíssemos:
variavel = 6;
O expressão não seria mais válida e o código não seria executado.
 Porém temos mais um detalhe, no exemplo acima nós utilizamos o que
chamamos de operadores, no caso apresentado o operador é o ‘==’ e ‘=’, abaixo
iremos ver alguns operadores presentes no Game Maker:

● Operador de atribuição (=): Utilizando esse operador, estamos atribuindo

um valor desejado.
○ Exemplo: variavel = 5, numero = variavel.
● Operadores de Comparação (<, <=, =>, >, !=, ==): Esses operadores são
utilizados para comparar valores. Eles são os seguintes: < (Valor menor),
<= (Valor menor ou igual), => (Valor maior ou igual), > (Valor maior), !=
(Valor diferente) e == (Valor igual).
○ Exemplo: ‘variavel >= 5’ - Essa expressão só será verdadeira se o
valor da variável for um número IGUAL ou MAIOR à 5.
○ Exemplo: ‘variavel == 5’ - Essa expressão só será verdadeira se o
valor da variável for um número IGUAL à 5.
○ Exemplo: ‘variavel != 5’ - Essa expressão só será verdadeira se o
valor da variável for DIFERENTE de 5.
IMPORTANTE: Preste atenção na diferença entre ‘=’ e ‘==’, quando utilizamos apenas um ‘=’ é
um sinal de atribuição e dois ‘==’ é um sinal de comparação, é muito importante aprendermos a
diferenciar um do outro
● Operadores de Adição e Subtração (++, --): Esses operadores são
utilizados para acrescentar ou subtrair o valor 1 de uma valor.
○ Exemplo: variavel++ - se utilizarmos esse código será adicionado
na variável ‘variavel’ mais um (+1) a cada vez que o código for
executado.
○ Exemplo: variavel– - se utilizarmos esse código será subtraido da
variável ‘variavel’ menos um (-1) a cada vez que o código for
executado.

● Afirmação: Não temos muito o que abordar especificamente sobre as

afirmações, elas representam o código que será executado se a nossa condição
e nossa expressão foram verdadeiras.
○ Exemplo: No caso do nosso exemplo, se a variável ‘variavel’ for igual a 5,
ela será definida para ser 10 e o código não será mais executado pois a
condição não é mais correspondente.

MUITO IMPORTANTE: Podemos observar no exemplo que utilizamos chaves

({}) após declararmos nossa condição e nossa expressão, e elas são extremamente
necessárias, todas as afirmações devem estar entre estas chaves.
 Utilizamos primeiro a chave ‘{‘ para começar nossa afirmação e depois de
terminarmos colocamos a chave ‘}’ para fechar.

Também é importante perceber que as afirmações estão posicionadas em um

parágrafo de distância.

Isso é muito importante para mantermos nosso código organizado, podemos

adicionar um parágrafo apertando TAB e voltar um parágrafo com Shift + TAB.

Agora que introduzimos o básico da programação, vamos falar de uma parte

muito importante: funções. Acredito que a melhor maneira de se definir o que é uma
função é: “A função é um código pré-definido que irá executar uma ação, podendo
retornar algum valor, e aceita argumentos que podem alterar seu resultado”, para ficar
mais claro podemos ver o exemplo a seguir:
● Exemplo: O Game Maker possui muitas funções integradas com o programa
que são chamadas de ‘Runtime Functions’ (Também é possível criarmos nossas
próprias funções, mas só falaremos sobre isso no futuro), usaremos como
exemplo a seguinte função:

Essa é uma função utilizada para checar se alguma tecla do nosso teclado está
sendo pressionada, só que para utilizarmos essa função, precisamos definir qual tecla
queremos checar, isso é o que chamamos de argumento da função. Então para
utilizarmos essa função da maneira correta poderíamos fazer da seguinte maneira:

Agora essa função está checando se estamos pressionando a tecla “Espaço” do

nosso teclado, caso estejamos, essa função irá retornar para o Game Maker o valor
true (ou seja, é verdadeiro que estamos apertando a tecla) e caso não estejamos
apertando a tecla “Espaço” ela irá retornar false (ou seja, é falso que estamos
apertando a tecla).
Essa é a ideia geral de uma função, porém existe MUITO mais para falarmos
sobre elas, agora estamos preocupados apenas em aprender o básico e introduzir
alguns conceitos da programação.
 Obs: ‘vk_space’ é o que chamamos de constante, nesse caso ela representa uma tecla que o
Game Maker reconhece predefinidamente, por exemplo, se escrevermos ‘vk’ no Game Maker temos a
seguinte lista:

(Diferentes teclas que podemos utilizar para checar)

MUITO IMPORTANTE: Você pode estar se perguntando “Mas Gabriel, como eu

vou saber quais funções usar, eu preciso decorar todas elas??” E a resposta é simples:
>>>NÃO!!!!<<< NEM TENTE DECORAR FUNÇÕES NEM NADA DE PROGRAMAÇÃO, só
para termos uma ideia, essa é uma pequena (MUITO PEQUENA) parte da lista de
funções do Game Maker:

Com o tempo iremos começar a utilizar várias funções e ensinarei algumas

técnicas para você encontrar as funções desejadas. Porém você nunca irá saber todas
as funções que existem, até hoje diariamente eu descubro novas funções que eu não
tinha ideia que existiam, isso é parte da programação, todo dia você irá descobrir uma
nova maneira de abordar os problemas.

Bom, é isso, acabamos a introdução do nosso curso,

agora iremos direto pro Game Maker e começaremos a
programar nosso jogo!!
 Movimento e Projéteis

Movimentação
Começaremos nosso jogo programando a movimentação do nosso
personagem, se você seguiu até aqui você já possui um ‘objeto’ criado, caso contrário
siga os passos apresentados no tópico ‘Introdução ao Game Maker’.
Antes de programarmos, vamos criar uma sprite simples para o nosso
personagem. Sprites representam tudo o que for visual no nosso jogo. Para criarmos
nossa Sprite faremos o seguinte:

(Clique com o botão direito na pasta Sprites’, selecione ‘Create’ e depois ‘Sprite’)

A janela que vemos a seguir é o “Editor de Sprites” do Game Maker:

(Editor de Sprites do Game Maker)

 Por enquanto iremos ignorar a maioria das funções e apenas selecionaremos
“Edit Image”.

Nesta área podemos desenhar o que quisermos, o Game Maker possui suas
próprias ferramentas para criação de sprites, porém no momento só selecionaremos a
ferramenta balde (‘F’), uma cor e preencheremos nossa sprite para formar um
quadrado.

Então esse é o nosso primeiro personagem!! Agora iremos alterar o seu nome,
para isso, faremos o seguinte:

(Botão direito na nossa sprite -> Rename/Ou podemos clicar na sprite e pressionar F2)
 Agora falaremos rapidamente como fazemos as nomenclaturas do Game
Maker, não existe uma regra, mas para fins de organização e para facilitar nossa vida,
utilizamos algumas abreviaturas, por exemplo:
● Em Sprites utilizamos a abreviatura spr, então podemos criar uma Sprite com o
nome ‘spr_personagem’, ‘spr_parede’, ‘spr_inimigo’, etc…
● Em Objetos utilizamos a abreviatura obj, então pode ficar ‘obj_personagem’,
‘obj_parede’, ‘obj_inimigo’, etc…

Então nesse caso iremos nomear nosso primeiro sprite ‘spr_personagem’:

(Nossa linda primeira sprite)

Também nomearemos nosso primeiro objeto ‘obj_personagem’:

Agora precisamos associar a nossa sprite ao nosso objeto para isso podemos
fazer de duas maneiras:

(Podemos apenas arrastar a sprite para a região destacada do nosso Objeto)

 Agora iremos adicionar o nosso objeto no nosso jogo, para isso basta acessar a
‘Room’ que já vem criada pelo Game Maker, e arrastar nosso objeto para dentro dela:

Aproveitando que estamos na room, vamos falar sobre coordenadas, o Game

Maker é um engine 2D, ou seja, ele possui 2 dimensões, que são: O eixo x e o eixo y.
O eixo x corresponde à horizontal e o eixo y à vertical, podemos entender
melhor vendo a seguinte imagem:

A coordenada inicial da nossa room é no canto esquerdo superior, e

corresponde ao x = 0 e y = 0, e o canto inferior direito corresponde a coordenada x =
largura da room e y = altura da room. Então resumindo: Se o nosso personagem está
indo para a direita o x está aumentando, para a esquerda o x está diminuindo, se for
para baixo o y está aumentando e se for para cima o y está diminuindo.

(Alterações nas coordenadas dependendo da direção)

 Com essa ideia das coordenadas em mente, vamos fazer nosso personagem se
movimentar, para isso vamos retornar ao nosso ‘obj_personagem’ que criamos, e
acessar seu evento ‘Step’, então iremos escrever nosso primeiro código, e ele é muito
complexo, longo e incrivelmente difícil:
● x = x + 2;
Agora se você executar o seu jogo (Pressione F5 ou clique no ícone: )
você irá ver nosso personagem se mexendo para a direita. Abaixo preparei um breve
GIF para ilustrar o que está acontecendo no jogo:

Podemos ver nosso personagem se movendo para as 4 direções e o código

correspondente dessa movimentação acima da sprite, recomendo você mesmo testar
o movimento para todas as direções com os códigos apresentados.
Agora vou mostrar à vocês outra maneira de escrever esses códigos que
aprendemos:
● x = x + 2; → x += 2;
● x = x - 2; → x -= 2;
● y = y + 2; → y += 2;
● y = y - 2; → y -= 2;
O código da esquerda faz exatamente o mesmo do código correspondente da
direita, porém é uma maneira mais simples de se escrever.
Bom, com isso vamos entender o que esse código está fazendo, para isso
precisamos primeiro entender o seguinte: o nosso jogo no Game Maker roda a 60 FPS
(Frames por segundo), então o código que escrevermos irá acontecer 60 vezes em 1
segundo, por exemplo: se eu escrever para somar +1 em uma variável, em 1 segundo,
o valor dessa variável será 60. Então com essa ideia em mente, vamos pegar o ‘x += 2’,
a cada frame que passa, estamos somando +2 na coordenada X do nosso
personagem, então se começarmos no x = 0, depois de um frame estaremos no x = 2,
depois x = 4, x = 6, x = 8, x = 10, e após 1 segundo (60 frames) nossa posição X será
120 (60 * 2).
 Agora já temos nosso personagem se movimentando, porém nós queremos ter
controle sobre a sua movimentação, para que possamos apertar uma tecla e aí sim ele
se mover na duração que pressionarmos, então vamos agora configurar para nosso
personagem de movimentar utilizando as setas do nosso teclado, para isso nós
podemos pensar da seguinte maneira: “se estamos apertando a seta da direita, nosso
x deve acrescentar +2.”
Talvez você tenha entendendido o que fiz acima, basicamente se fizermos a
mesma coisa que fizemos na introdução, podemos transformar a frase em código,
então ficaria da seguinte maneira:

(Código para movimentar o personagem para a direita pressionando a seta direita)

Então if é a nossa expressão (“se”), keyboard_check é uma função que

utilizamos para checar se estamos pressionando uma certa tecla, e no caso a tecla é
vk_right, a seta para direita do nosso teclado, e por fim, se isso for true (se estamos
pressionando a tecla para direita) iremos acrescentar no X do nosso personagem +2.

PARABÉNS!! VOCÊ ESCREVEU SUA PRIMEIRA LÓGICA EM

PROGRAMAÇÃO
Obs: Quando digitamos ‘keyboard’ dentro do Game Maker, irá aparecer essa lista de funções
disponíveis, nesse caso utilizamos a “keyboard_check”, pois ela é uma expressão que retorna
verdadeiro (true) enquanto SEGURAMOS a nossa tecla escolhida, no caso da
“keyboard_check_pressed” só irá acontecer UMA VEZ quando APERTAMOS a tecla, e o
“keyboard_check_released” só irá acontecer UMA VEZ quando SOLTARMOS a tecla. RECOMENDO
VOCÊS TESTAREM ESSAS 3 FUNÇÕES PARA ENTENDEREM MELHOR.
 Agora que podemos mover nosso personagem para a direita, vamos fazer a
mesma coisa para as outra direções, então o seu código deve ficar da seguinte
maneira:

(Código para movimentar o personagem para todas as direções)

E pronto!! Já temos nosso personagem se movimentando com apenas esses

códigos. Podemos ver que alteramos o argumento da função “keyboard_check”
dependendo da direção, então:
● vk_right → seta direita → x += 2;
● vk_left → seta esquerda → x -= 2;
● vk_down → seta baixo → y += 2;
● vk_up → seta cima → y -= 2;

Bom, temos nosso código funcionando, porém nós podemos fazer algumas
mudanças para otimizá-lo, para começar, o valor da “velocidade” do nosso
personagem que estamos utilizando é 2, ou seja, o tanto de pixels que ele se mexe por
frame, agora vamos pensar no caso onde queremos alterar esse valor, então toda vez
que formos mudar, vamos ter que passar por cada código e mudar o valor de 2 para 3
por exemplo.
 Agora imagine que estamos usando esse valor em 10 códigos diferentes, nós
teríamos que ir em todos os 10 códigos e alterar o seu valor, porém existe uma maneira
mais simples para resolver esse problema, para isso, vamos falar sobre um novo
evento dos objetos: Create Event.

(Acesse o obj_personagem -> Add Event -> Create)

No ‘Step Event’ que estávamos utilizando até então, o nosso código é executado
TODO FRAME DO JOGO (60 vezes por segundo), sem parar, no caso do ‘Create Event’,
o código que escrevermos só será executado UMA VEZ QUANDO O OBJETO POR
CRIADO. Então a sequência dos eventos até então será:

Iniciar o jogo
↧
Objeto é criado
↧
Código no Create Event é executado UMA ÚNICA VEZ
↧
Código do Step Event começa a executar

Então o Create Event é usado principalmente para declaramos nossas variáveis

iniciais, então para entendermos melhor, vamos criar uma variável no nosso Create
Event:

(spd é uma abreviação de speed, que traduz para velocidade)

 Talvez você já tenha entendido o que faremos a seguir, mas se retornarmos para
o nosso ‘Step Event’ podemos substituir todos os valores que utilizamos para a
velocidade por essa nossa variável ‘spd’:

Então a partir de agora, se alterarmos o valor dessa variável spd, a velocidade

do nosso personagem para todas as direções será alterado automaticamente.
Agora vamos fazer o nosso personagem ‘correr’ quando segurarmos a tecla
“Shift”, ou seja, nós iremos aumentar o valor da nossa variável ‘spd’ se a tecla Shift
estiver pressionada e caso não esteja, o valor retornará ao valor original. Para isso
podemos escrever o seguinte código:

O código acima faz com que quando APERTARMOS a tecla ‘Shift’, a nossa
variável spd seja alterada para o valor 5 e quando SOLTAMOS a tecla Shift o valor da
variável retorna para o inicial (2 no meu caso, mas você pode alterar da maneira que
quiser).
E essa é uma ideia básica de como utilizamos variáveis em nosso código.

Projéteis
Agora que temos nosso personagem se movento e podendo “correr” vamos
fazê-lo disparar projéteis simples, para isso vamos entender a ideia geral destes
projéteis, quando eu estou programando, eu gosto de colocar as minhas ideias em
uma sequência, por exemplo:
 Pressionar botão esquerdo do mouse OU ‘espaço’
↧
Criar Projétil
↧
Projétil receber uma direção para seguir
↧
Projétil seguir a direção em uma velocidade

Então esses são os 4 passos para se criar um projétil, mas para começar, igual
nosso personagem, precisamos de uma SPRITE e um OBJETO para o projétil, então
começaremos pela sprite:

(Alterar o tamanho de uma sprite)

Esse nosso projétil eu nomeei ‘spr_projetil’ e alterei o tamanho para ser 32x32
(32 pixels de largura e 32 pixels de altura), você pode fazer isso seguindo a imagem
acima. Agora podemos criar um círculo para ser a sprite do nosso projétil:

(Para acessar essa Janela, clique em ‘Edit Image’ na sua sprite)

Você pode criar a sprite que desejar para seu projétil, por enquanto manterei
esse simples círculo, agora iremos aprender algo sobre as sprites, chamado: “Origem
da Sprite” ou ‘Sprite Origin’, que se refere ao ponto que a sprite será criada a partir e
aquele é seu ponto inicial x e y:
 Originalmente esse ponto é o 0x0 da sprite, ou seja, o ponto na esquerda
superior, abaixo preparei um gif para entendermos melhor como essa ‘Sprite Origin’
funciona:

(Download desse projetinho está disponível na página do Curso)

Como podemos ver o ponto de origem é a ‘âncora’ da nossa sprite, então ela
altera a posição referente da sprite e também como ela rotaciona, normalmente,
iremos definir o ponto de origem para ser a parte central das nossas sprites, para isso
podemos fazer o seguinte:
 Podemos ver que temos várias opções de pontos de origem pré-definidos,
porém por enquanto iremos escolher o ‘Middle Center’ que se refere ao centro da
nossa sprite.
Então iremos fazer a mesma coisa para a sprite do nosso personagem:

Agora criaremos o nosso objeto para o projétil, da mesma maneira que fizemos
com o nosso personagem, e nomearemos esse objeto de ‘obj_projetil’ e colocaremos
essa sprite que acabamos de criar nesse objeto:
 Agora vamos programar para o nosso personagem criar esse projétil quando
clicarmos com o botão esquerdo do mouse OU com a tecla espaço, para isso
retornaremos ao ‘Step Event’ do nosso obj_personagem, e aqui faremos algo um
pouco diferente, no caso do nosso projétil nós temos 2 condições para criá-lo, com o
mouse e com o teclado, a função para criar com o mouse é:

(A função ‘mouse_check_button_pressed’ é utilizada para checar se estamos APERTANDO uma única

vez o botão do mouse referente, e no caso o botão ‘mb_left’ é o MouseButton_left, ou seja, o botão
esquerdo do nosso mouse)

E para criar com a barra de espaço do teclado é:

Então nós poderíamos criar 2 condições ‘if’ uma para o mouse e outra para a
tecla espaço que fariam exatamente a mesma coisa (Criar o projétil):

Porém quando temos 2 condições que fazem exatamente a mesma coisa,

podemos fazer da seguinte maneira:

Nós podemos usar a condição ‘or’ (que se traduz para ‘ou’ em português) para
unir as nossas 2 expressões, então se traduzirmos esse código ficaria algo como:
● “SE pressionarmos o botão esquerdo do mouse OU pressionarmos a tecla
espaço o código irá acontecer “

Então agora esse código possui 2 condições diferentes e se PELO MENOS UMA
FOR VERDADEIRA (true) o código irá acontecer.
Obs: Podemos escrever essa condição como ‘or’ ou ‘||’:
 Nós podemos fazer a mesma coisa com a nossa movimentação, no momento
estamos utilizando as setas, mas podemos ao mesmo tempo utilizar o “AWSD” para
isso podemos fazer o seguinte:

Quando queremos checar alguma letra do teclado, precisamos utilizar a função

‘ord()’ dentro da função ‘keyboard_check()’, e é importante que a letra esteja entre
aspas (“”), então será keyboard_check(ord(“tecla desejada”)).
Agora só precisamos fazer a mesma coisa para todas as teclas, e ficará assim:

Então agora já temos a codição para criar nosso projétil, e para criá-lo usamos a
seguinte função:

“instance_create_layer” é a função que usamos dentro do Game Maker, sempre

que queremos criar um objeto (na verdade é uma instância, mas falaremos mais sobre
isso depois) novo, porém ela é uma função que precisa de muitos argumentos,
diferente do que vimos até agora. Se clicarmos nessa função, abaixo podemos ver
todos os argumentos que são necessários para que ela possa funcionar de maneira
correta:

Então no caso da função ‘instance_create_layer’ precisamos definir 4

argumentos principais (ignoraremos o ‘var_struct’ por enquanto) e eles são:
● x: A posição X da nossa room que criaremos o objeto.
● y: A posição Y da nossa room que criaremos o objeto.
 ● layer_id_or_name: O nome da Layer que criaremos o objeto.
● obj: Qual objeto queremos criar.

Vamos definir um por um para entendermos melhor, então começando pelas

coordenadas x e y, quando criarmos nosso projétil, queremos que ele sempre saia do
nosso personagem, como a seguir:

Então as coordenadas x e y serão as mesmas das coordenadas x e y do nosso

personagem, ou seja, escreveremos apenas x e y:

Sempre que tivermos funções onde temos mais que um argumento, utilizamos
a vírgula (‘,’) para separá-los. Como a função está acontecendo dentro do nosso
‘obj_personagem’ se utilizarmos x e y ele pegará o x e o y atual do nosso personagem.
Agora o terceiro argumento que essa função pede é o nome da Layer que
queremos criar esse novo objeto, se acessarmos nossa room novamente, podemos
ver no canto esquerdo a lista dos nossos Layer (camadas):
 A Layer original que o Game Maker cria para todas as Rooms é chamada de
‘Instances’, e é nela que iremos criar o nosso projétil, então se retornarmos para o
nosso código, ele irá ficar dessa forma:

É MUITO IMPORTANTE percebermos que o nome da nossa camada está entra

aspas (“”), sempre que escrevermos o nome de alguma camada, ela tem que ser do
tipo String, então sempre prestem atenção para adicionar as aspas.
E por fim, precisamos definir qual objeto queremos criar, e esse é bem simples,
pois será o ‘obj_projetil’, então pasta adicioná-lo e a função final ficará da seguinte
maneira:

Agora se executarmos nosso jogo para testar, e pressionarmos o mouse

esquerdo OU a tecla espaço nosso personagem criará um ‘obj_projetil’ EMBAIXO dele.

Então é assim que criamos novos objetos (instâncias) dentro do Game Maker,
porém nós estamos criando um projétil e no momento ele não se mexe para nenhuma
direção, então agora iremos programar o que é importante para que ele funcione, para
isso, vamos agora acessar o ‘obj_projetil’, no momento ele não possui nenhum evento,
então começaremos adicionar o ‘Create’:

Dentro do Game Maker, existe o que chamamos de “Built-in Variable”, que se

traduz para algo como “Variável Pré-Programadas”, ou seja, são variáveis que já
existem no Game Maker e podem executar ações já programadas, nós iremos utilizar 2
no momento: ‘speed’ (velocidade) e ‘direction’ (direção), então se colocarmos o
seguinte:

E agora executarmos nosso jogo:

Podemos ver que nossos projéteis já estão se mexendo, porém eles sempre vão
na mesma direção, então agora precisamos resolver isso, para isso vamos entender
como funciona a direção do Game Maker:

(Representação das direções no Game Maobsker)

 No exemplo acima, a direção representada é do nosso personagem para o
mouse, e também vemos que a direção é represetada em graus de um círculo, podendo
ser um valor de 0 até 359, existe uma função que podemos usar que irá retornar a
direção que definirmos, ela é a seguinte:

Essa função pede 4 argumentos, o x e o y de origem e o x e o y da direção que

desejamos ir, então igual fizemos do exemplo anterior, a origem é o x e o y do nosso
personagem e o destino é o x e o y do mouse.
Para sabermos o x e o y do nosso mouse, podemos utilizar outras ‘Built-in
Varible’ do Game Maker chamadas: ‘mouse_x’ e ‘mouse_y’, então nossa função fica da
seguinte maneira:

Agora só precisamos atribuir essa função para a nossa ‘direction’:

E se executarmos nosso jogo agora temos nosso personagem disparando

projéteis em direção ao nosso mouse:
 Agora vamos criar um inimigo para nosso projétil colidir com, então faremos
novamente o que fizemos para os outros objetos, primeiro criamos uma SPRITE que
chamarei de ‘spr_inimigo’ e depois o seu objeto ‘obj_inimigo’. Dessa vez pularei essa
parte e deixo com vocês como um teste para ver se lembram com criar a sprite e o
objeto (Dica: Não se esqueçam de colocar o ponto de origem da sprite do inimigo para
ser o centro).
Com isso coloquei 3 desses inimigos dentro da nossa room:

Por enquanto não iremos programar nada para o nosso inimigo, vamos retornar
para o nosso ‘obj_projetil’ e adicionar um novo evento:

(Add Event -> Collision -> Objects -> obj_inimigo)

 Nesse evento ‘Collision’ o código que colocarmos dentro dele SÓ IRÁ
ACONTECER QUANDO O NOSSO OBJETO COLIDIR COM O OUTRO OBJETO DEFINIDO
(No caso ‘obj_projetil’ colidir com o ‘obj_inimigo’).
Então algo bem simples que podemos fazer para entender melhor como
funcionna o evento, é dentro dele simplesmente escrever a função ‘instance_destroy()’

Essa função é utilizada para destruirmos algum objeto/instância que

desejarmos, se não definirmos como argumento nenhum objeto/instância ele irá
destruir o objeto no qual o código está sendo usado, no nosso caso o ‘obj_projetil’.

(O código de se destruir só acontece quando o ‘obj_projetil’ colide com o inimigo)

Bom, com isso nosso projétil está meio que funcionando já, a gente pode criar,
ele assume uma direção e uma velocidade, e quando colide com o inimigo, se destrói,
acho que é isso então, acabamos por aqui :).
 Mentira, não podemos deixar esses inimigos a solta, olha como eles são bravos,
pra isso precisamos que nossos projéteis causem dano neles e quando a vida chegar
a 0 eles sumam. Então, qual é a ideia da vida?
Vamos pensar o seguinte, podemos criar uma variável para esses inimigos que
represente a vida deles, então agora vamos abrir o nosso ‘obj_inimigo’ e adicionar um
evento ‘Create’:

Então ‘life’ será a variável que utilizaremos para controlar a vida do nosso
inimigo, porém só de criar essa variável não está acontecendo nada, precisamos
determinar alguma condição para que quando essa variável chegue a 0 (A vida do
nosso inimigo seja 0) o inimigo se destrua, então adicionaremos um evento ‘Step’ e
podemos colocar o seguinte código (Antes de olhar a resposta recomendo você tentar
fazer essa parte sem minha ajuda, posso dizer que utilizamos o operador para checar
se algo é menor):

Agora se a variável ‘life’ do nosso inimigo for um valor MENOR OU IGUAL a 0,

ele irá se destruir. Vale notar que eu utilizei o operador <= (Menor ou igual), nós
também poderíamos utilizar o ‘==’ (Igual), porém nesses casos, é melhor garantirmos
que os valores -1, -2, -3, também destruam o inimigo pois as vezes é possível que
algum bug ocorra e o valor de ‘life’ não passe pelo 0, então o operador ‘==’ nunca
aconteceria.
 Bom, para finalizarmos precisamos fazer com que o nosso projétil cause dano
no nosso inimigo, para isso vamos retornar para o ‘obj_projetil’ e para o evento
‘Collision’. Então a ideia do nosso projétil é ele fazer com que a variável ‘life’ do nosso
inimigo, seja subtraído por 1, para isso vamos utilizar o seguinte código:

Quando utilizamos esse evento ‘Collision’ (APENAS NESSE EVENTO) podemos

usar a palavra-chave other e ela se refere ao OUTRO com quem o objeto está colidindo,
por exemplo, nesse caso definimos o evento ‘Collision’ para checar a colisão com o
‘obj_inimigo’, então other, vai se referir ao ‘obj_inimigo’ que o ‘obj_projetil’ está
colidindo.
É muito importante sabermos o seguinte: quando falamos de Objeto, é referente
ao que criamos FORA do jogo, onde colocamos nosso código, quando executamos o
jogo, o que vemos são INSTÂNCIAS desse objeto, a seguir veremos alguns exemplos
para entendermos melhor esse conceito que é MUITO IMPORTANTE MESMO.

Nesse caso acima, temos 3 inimigos, os 3 são obj_inimigo porém cada um é

uma instância diferente que possui um ID, porém se eu usasse a função
‘instance_destroy(obj_inimigo)’, TODOS os 3 seriam destruídos, caso a gente quisesse
destruir apenas 1 específico, nós precisamos utilizar a ID específica dele.
 Então no caso da palavra chave ‘other’, ela irá pegar a ID específica daquele
inimigo com que o projétil está colidindo. Depois utilizamos o ponto final (“.”) para
ACESSAR aquela instância, no caso acessamos a instância que o projétil colidiu com,
e definimos para que a variável ‘life’ dela seja subtraída por 1. Com isso, estamos
causando dano naquele inimigo específico!!
Agora se executarmos nosso jogo, já podemos destruir o inimigo:

Com isso nós completamos o básico de programação, ainda temos MUITO para
falar, quando digo o básico é introduzir a ideia geral da programação.

Movimentação Melhorada e Colisão Perfeita

Agora vamos fazer algo um pouco mais complexo, que é a colisão com uma
parede, para começar vamos criar uma nova sprite e um novo objeto para a nossa
parede, então ‘spr_parede’ e ‘obj_parede’.

Antes de escrevendo qualquer código, vamos colocar algumas dessas paredes

dentro da nossa room, você pode montar como quiser:
 Agora vamos voltar para o nosso ‘obj_personagem’ para programar a colisão,
pra começar vamos precisa alterar como a nossa movimentação funciona, a
movimentação que fizemos anteriormente funciona, porém não temos muito controle
sobre ela, e ela tem um problema que talvez vocês tenham percebido que quando
andamos na diagonal, vamos mais rápido, porque ele soma a velocidade do x com o y,
então nosso personagem fica 2 vezes mais rápido.
Antes de alteramos o código da movimentação em si, vamos fazer uma pequena
mudança nas nossas teclas de movimento, o que eu gosto de fazer é criar 4 variáveis
no evento ‘Create’, uma para cada tecla que utilizamos, então fica da seguinte maneira:

Obs: Quando criamos variáveis que terão seu valor alterado em sequência, costumamos atribuir
-1 apenas porque é necessário declarar algum valor.

Agora no evento ‘Step’, vamos atribuir para cada variável a tecla correspondente,
então ficará da seguinte maneira:

Agora nós podemos alterar as nossas teclas em nossas condições pelas

variáveis correspondentes:
 Dessa forma nosso código fica muito mais organizado e podemos utilizar as
variáveis de nossas teclas quando for necessário.

Agora, para alterarmos como a nossa movimentação funciona, precisamos

mudar a maneira como abordamos o movimento, então começaremos com a seguinte
pergunta: Como que funciona o movimento na vida real?
Podemos resumir se movimentar com: “Sair de um ponto A e irmos para um
ponto B”.

Bem simples até então, mas o que precisamos fazer para conseguir sair de um
ponto (A) e chegar ao outro (B)? A resposta são 2 coisas, velocidade e direção, então
se escolhermos uma direção para ir, e começarmos a andar, estamos nos movendo.

(Download desse projetinho está disponível na página do Curso)

 Agora precisamos transformar essa ideia de direção e velocidade em código de
programação, porém não será tão complicado pois o Game Maker possui duas
funções que fazem exatamente isso, que são chamadas de 'lengthdir_x()' e
‘lengthdir_y()’.
É muito importante entender que quando utilizamos essas funções, estamos
dividindo a nossa velocidade em duas: uma velocidade horizontal e uma vertical, e
nossa velocidade real (a velocidade que o nosso personagem se move) é um cálculo
resultante dessas 2 velocidades.

Podemos ver acima que os argumentos que essas funções pedem são os
mesmos, agora vamos entender exatamente o que é o ‘len’ e o ‘dir’:
Como já falamos nos projéteis, as direções no Game Maker são represetadas
pelos graus de uma circunferência:

O que essas funções fazem, é calcular qual é essa distância para chegarmos a
esse ponto, e elas fazem isso da seguinte maneira:
 É importante perceber que só conseguiremos chegar ao ponto desejado, se
sormarmos o ‘lengthdir_x’ com o ‘lengthdir_y.

Agora vamos aplicar essa ideia em nosso código de movimentação, então para
começar, vamos criar 3 variáveis, hspd (para a velocidade horizontal), vspd (para a
velocidade vertical) e dir (para a direção).

E no nosso evento ‘Step’ nós podemos denifir essas 3 variáveis utilizando as

funções que comentamos anteriormente.
Então vamos começar pela direção:
 O ponto x e y para qual queremos ir dependerá das nossas teclas pressionadas,
então precisamos criar uma relação entre as teclas e a direção, o código não é muito
complicado, mas precisamos entender com bastante calma:

Para começar, vamos entender primeiro do que se trata o ‘var’, existem alguns
tipos diferentes de variáveis que podemos criar no Game Maker:
● ‘Instance Variables’: a variável que utilizamos até agora (por exemplo: direita,
esquerda, baixo, etc…), que pode ser utilizada em qualquer lugar do objeto.
● ‘Local Variables’: a variável local é criada utilizando o ‘var’ e ela pode APENAS
ser utilizada no evento em que ela é declarada, e no final de todo frame, ela é
destruída (liberada da memória), e criada novamente se necessário no próximo
frame, utilizamos esse tipo de variável quando ela será utilizada APENAS no
evento específico em que é criada.
Obs: para diferenciar essa variável das ‘Instances Variables’, eu gosto de colocar um
underline (_) antes do nome.
○ Exemplo: var _xx = 2; var _numero = 5;
● ‘Global Variables’: as variáveis globais podem ser criadas e utilizadas em
QUALQUER objeto.
○ Exemplo: global.numero = 5; global.exemplo = ‘numero’;

Agora vamos entender o que estamos fazendo na lógica ‘direita - esquerda’,

quando criamos as variáveis para cada tecla, associamos as funções que checam as
respectivas teclas a cada uma destas variáveis, é importante entender que estas
variáveis retornam um valor que é armazenado, e esse valor vai ser TRUE ou FALSE
dependendo se ESTAMOS PRESSIONANDO A TECLA (True) OU NÃO (False), e como já
falamos anteriormente, True e False são representados pelos número 1 e 0.
True = 1
False = 0
Então vamos retornar ao direita - esquerda, se não estamos pressionando
nenhuma das 2 teclas, temos:
0 - 0 = 0 (as duas variáveis são false).

Porém se estamos apenas pressionando a tecla para direita, temos:

1 - 0 = 1 (apenas a variável direita é true)

E se estamos apertando apenas a tecla para a esquerda, temos:

0 - 1 = -1 (apenas a variável esquerda é true)
 Para facilitar, vamos ver o gif a seguir:

Agora se colocarmos essas 2 variáveis que estamos usando para pegar a

direção das setas na nossa função ‘point_direction()’ temos:

Então estamos indo para as seguintes direções:

Com isso já temos a direção para o nosso personagem seguir, agora só falta a
velocidade, mas isso nós também já temos!! A variável ‘spd’ que criamos no início,
então vamos aplicar essas 2 variáveis ‘dir’ e ‘spd’ nas funções ‘lengthdir_x’ e
‘lengthdir_y’, então ficará da seguinte maneira:

Então temos a nossa velocidade horizontal (hspd) e nossa velocidade vertical

(vspd) separadas, agora só precisamos utilizá-las para somar no nosso x e y, então
podemos apagar todo esse código:
 E substituir por:

Agora se executarmos o nosso jogo, veremos que ainda tem um problema,

nosso personagem nunca fica parado, isso porque nossa variável ‘spd’ sempre tem o
valor de 2, então a velocidade nunca fica 0, para isso podemos fazer algo muito
simples:

O que fizemos aqui é apenas colocar uma condição que checa se estamos
apertando qualquer tecla de movimento, ou seja, se qualquer tecla tiver valor de 1
(true) a nossa variável ‘spd = 2’ e se não estamos apertando nenhuma tecla, todas elas
tem o valor 0 (false) a nossa variável ‘spd = 0’

Agora a última coisa que precisamos fazer para finalizar essa movimentação é
alterar como fazemos nosso personagem correr, porque se você testar, verá que nosso
‘Shift’ não funciona mais para alterar a velocidade do personagem.
Para começar vamos apagar nosso código anterior:
 E adicionar nosso novo código:

Aqui utilizamos uma nova condição ‘else’, então vamos “traduzir” esse código
para português:
“Se (if) estamos segurando a tecla Shift (keyboard_check(vk_shift)), nossa
variável spd é igual a 5 (spd = 5), caso contrário (else), a variável spd é igual a 0 (spd =
0)”
Se pegarmos apenas o que está dentro do parênteses temos:
if keyboard_check(vk_shift){
spd = 5;
}else{
spd = 0;
}
Então utilizamos a condição else, se queremos atribuir uma condição caso a
expressão seja verdadeira (true) ou false (false), nesse caso é VERDADEIRA SE
ESTAMOS PRESSIONANDO SHIFT e FALSA SE NÃO ESTAMOS (Lembrem-se de
utilizar as chaves (‘{}’))
Agora temos o seguinte em nosso jogo:
 Podemos ver que ainda não temos colisão com a parede, mas isso é a próxima
etapa, também é possível ver que nosso personagem não se move mais rápido quando
andamos na diagonal.
Obs: O download desse projeto (tudo que fizemos até aqui) está disponível na página do curso,
se quiser checar os códigos é possível por esse arquivo.

Muito bem, esse é nosso primeiro código que utiliza uma lógica um pouco mais
complexa, se você conseguiu entender tudo até aqui é ótimo, porém se estiver com
dificuldades vá com calma, tente entender cada parte separada e depois ir unindo as
ideias, o começo da programação é a parte mais difícil, continue se esforçando que
tudo fará sentido.

Agora vamos falar sobre colisão, para começar vamos ver o seguinte código:

Esse é basicamente o código que precisamos para fazer a nossa colisão

acontecer, então vamos entender por partes, para começar, vamos falar sobre a função
‘place_meeting()’:

Essa função é utilizada para checar se 2 duas instâncias estão colidindo, ou

seja, se as duas acupam o mesmo espaço:
 Então precisamos dar 3 argumentos para que essa função funcione:
● x: a posição x usada para checar se está acontecendo uma colisão
● y: a posição y usada para checar se está acontecendo uma colisão
● obj: o objeto que queremos checar se estamos colidindo

Toda sprite no Game Maker tem uma ‘Collision Mask’ que pode ser alterada no
editor da sprite:

Podemos descrever essa ‘Collision Mask’ como a “área que a sprite ocupa”, e é
ela que é utilizada para checar a colisão nesse nosso caso.
Agora entendendo o que a função ‘place_meeting’ faz vamos rever o código de
colisão:

É importante perceber que dividimos nossa colisão em duas, uma para a

horizontal (hspd) e outra para a vertical (vspd), isso porque temos 2 velocidades, e
quando colidimos na horizontal queremos ter a opção de nos mover na vertical.
Então vamos utilizar a colisão na horizontal como nosso exemplo, nós
escrevemos
● if place_meeting(x + hspd, y, obj_parede)
 E precisamos entender o porque de somarmos em nosso x o hspd, então vamos
ver o gif a seguir:

Neste primeiro exemplo, a nossa função está sem a adição do hspd, então
temos (A área em vermelho na direita do nosso personagem representa o nosso
próximo movimento):

Dessa forma, a colisão é checada quando já estamos dentro da parede, ou seja,

o hspd será 0 para sempre, e consequentemente, o vspd também, pois estamos
colidindo com a parede, então nosso personagem fica preso e não pode mais se
mover.
O que queremos é PREVINIR que o nosso personagem colida, ou seja, SE ELE
FOR COLIDIR (Entrar na parede) ELE NÃO VAI PODER SE MEXER, então não estamos
checando a nossa posição atual e sim a do próximo movimento, então se
adicionarmos o hspd, estamos checando PARA ONDE ESTAMOS INDO.
Então vamos ver esse próximo gif onde estamos somando o hspd ao nosso x:
 Nesse caso podemos perceber que nós nunca colidimos com a parede, sempre
ficará o espaço para o próximo movimento, que se ocorresse, aí sim entraríamos na
parede.
É muito importante também percebermos que utilizamos o hspd somado no x
para a colisão na horizontal e o vspd somado no y na colisão vertical:

Também é importante perceber que esse código está ABAIXO do código de

movimentação, pois nós redefinimos o valor do hspd e do vspd caso haja colisão.
Bom essa é a ideia principal da colisão, o que faremos a seguir é uma escolha,
será algo um pouco mais complicado, mas recomendo que você ao menos tente
implementar em seu jogo, como está no nome do tópico, estamos falando de COLISÃO
PERFEITA, isso quer dizer uma colisão onde não fique nenhum espaço (Nenhum pixel)
entre o nosso personagem e a parade, que é o que está acontecendo atualmente:

Para resolvermos isso, vamos utilizar algo chamado ‘Loops’, loops são
condições do Game Maker (como if e else que vimos até agora) que se repetem
determinados números de vezes enquanto a condição for verdadeira (true). Existem 3
tipos de loops principais (for, repeat e while), no caso da nossa colisão vamos utilizar
o while e mais pra frente veremos os outros 2.
Antes de tudo, é muito importante entender que os loops são executados em
UM ÚNICO FRAME, vamos ver a imagem a seguir:
 Então vamos usar um exemplo em códigos agora, podemos traduzir while para
‘enquanto’, então vamos ver o exemplo a seguir:

Mais uma vez, vamos ‘traduzir’ esse código para português, então seria algo
como:
● “Enquanto (while) a nossa variável número (numero) for menor ou igual a 20
(<=), vamos adicionar +1 na variável número (numero++)”, agora se pegarmos
apenas o que está em parênteses:
while numero <= 20{
numero++;
}

Então o que está acontecendo no código de loop é o seguinte, primeiro ele entra
no loop e se pergunta “A variável numero é menor ou igual a 20?” se a resposta for sim
(se essa expressão for true) ele irá somar +1 na variável, e ele vai retornar e se
perguntar a mesma coisa novamente: “A variável numero é menor ou igual a 20?”, e
ele irá repetir até que essa variável número, seja um valor maior que 20.
Usaremos muito loops durante todo o nosso curso, então é muito importante
entendermos muito bem como funciona.
MUITO IMPORTANTE: O loop while é muito perigoso pois é muito fácil criarmos
um loop infinito, e nosso jogo irá travar, então por exemplo, vamos utilizar o seguinte
exemplo:
 Neste caso, nós criamos um loop ‘while’ que irá acontecer ENQUANTO a nossa
variável numero for maior ou igual (>=) a 0, porém ela será PARA SEMPRE, pois
estamos adicionando +1 nesta variável, então esse loop NUNCA ACABARÁ, e isso fará
nosso jogo travar, pois ele nunca sairá do loop e consequentemente NUNCA IREMOS
PARA O PRÓXIMO FRAME. Então é muito importante sempre ter certeza que nosso
loop ‘while’ possui o que chamamos de CONDIÇÃO DE SAÍDA, ou seja, garantir que o
nosso loop ‘while’ termine.

Agora vamos aplicar esse loop em nosso sistema de colisão, para isso, o código
ficará da seguinte maneira:

Pode parecer muita coisa a princípio mas vamos entender aos poucos esse
código, para começar, como sempre, vamos “traduzir” esse código para o português:
● Enquanto (while) NÃO (!) estiver havendo colisão (place_meeting) na frente do
nosso personagem (x + sign(hspd)) com a parede (obj_parede), nos
aproximaremos mais da parede (x += sign(hspd)).

Temos muitas coisas que ainda não utilizamos anteriormente nesse código,
então vamos começar, o sign é uma função do Game Maker que vai converter
qualquer valor que colocarmos como argumento, para -1, 0 ou 1, dependendo se for
um valor negativo, zero ou positivo.
● Exemplos:
○ sign(5) = 1
○ sign(100) = 1
○ sign(-3) = -1
○ sign(-277) = -1
○ sign(0) = 0

Então vamos usar a imagem a seguir:

 Nesse caso tem 5 pixels de distância entre o nosso personagem e a parede, e
vamos supor que nossa velocidade é 7, então se nos movermos mais uma vez,
entraremos 2 pixels na parede (7 - 5 = 2), havendo colisão, então a função a seguir é
verdadeira e será executada:

Agora o código entra no loop while:

Aqui utilizamos o place_meeting para checar se NÃO (!) existe um obj_parede

há 1 pixel de distância do nosso personagem.

IMPORATENTE: O ponto de exclamação antes de uma função significa uma negação,

ou seja, se a função ‘place_meeting()’ normalmente é verdadeira se estamos
colidindo, se adicionarmos o ‘!’ ela irá ser verdadeira quando NÃO estivermos
colidindo.

Então se estamos andando para a direita, e o hspd é 7, o sign(hspd) será 1,

caso estivermos indo para a esquerda, e o hspd é -7, o sign(hspd) será -1,
basicamente o personagem está se perguntando: “Se eu andar mais um pixel pra
direção que eu estou indo, eu vou colidir com a parede?” se a resposta para essa
pergunta for não, ele irá ir MAIS UM PIXEL naquela direção, então:
● x += sign(hspd)

Mas caso a resposta seja sim, então se o nosso personagem andar MAIS UM
PIXEL na direção que está indo e for colidir com a parede, ele sairá do loop e não irá
executar mais, então ficará parado.

Esse é o código que utilizamos para a colisão perfeita, porém nesse caso
estamos checando apenas a colisão na HORIZONTAL, então precisamos fazer a
mesma coisa para a vertical:

É muito importante percebermos que no caso da colisão vertical, utilizamos o

‘vspd’ (velocidade vertical) e não o ‘hspd’ (velocidade horizontal), então nós também
precisamos checar o Y do nosso personagem, não o X.
 No final, nosso código ficará da seguinte maneira:

Esse é um código muito mais complexo do que o que vimos anteriormente, não
se preocupe em entender tudo o que está acontecendo no momento, o importante
dessa parte de colisão perfeita é entender o porque de fazer o código desta maneira, a
lógica que utilizamos, então se você conseguiu entender que ESTAMOS CHECANDO
SE EXISTE PELO MENOS UM PIXEL SOBRANDO ENTRE O PERSONAGEM E A PAREDE
E EXECUTAMOS O LOOP PARA NOS APROXIMARMOS UM PIXEL POR VEZ ATÉ NÃO
HAVER MAIS ESPAÇO, isso é o que importa no momento. Também tenha calma, aos
poucos as coisas irão fazer sentido, eu mesmo tive que escrever e testar esse código
muitas vezes até entendê-lo por completo quando estava aprendendo!!