EXPERIÊNCIA CRIATIVA:

PRODUÇÃO DE JOGOS
COM GAMEMAKER

Gabriel Fonseca Silva

Criação inicial de
jogos com GameMaker
Language (GML)
Objetivos de aprendizagem
Ao final deste texto, você deve apresentar os seguintes aprendizados:

„„ Analisar a estrutura básica do código e suas funções.

„„ Diferenciar scripts, comentários e palavras-chave reservadas.
„„ Explorar variáveis, endereçamento e outras instâncias.

Introdução
A GameMaker Language (GML) oferece uma variedade de recursos para a
criação do código de um jogo. Alguns recursos podem ser utilizados para
organização, como comentários e indentação do código, ao passo que
outros podem ser utilizados para acelerar o desenvolvimento e permitir
a reutilização de código, como scripts. No entanto, esses elementos da
linguagem devem seguir um conjunto de regras de sintaxe para que a
engine possa interpretar as instruções corretamente.
Neste capítulo, você estudará sobre a estrutura de um código GML
e algumas de suas regras de sintaxe. Além disso, conhecerá o uso de
funções e scripts e seus argumentos, bem como os elementos necessários
para a configuração de eventos e scripts, como comentários e palavras-
-chave. Por fim, verá os diferentes tipos de variáveis, seus escopos e como
acessá-las em outras instâncias.
2 Criação inicial de jogos com GameMaker Language (GML)

1 Estrutura e sintaxe da GameMaker Language

A GameMaker Language (GML) possui uma estrutura semelhante a muitas
linguagens de programação quando à maneira de se organizar conjuntos
de instruções e blocos de código. Um código simples é composto por uma
sequência de instruções, podendo ser, principalmente, atribuições de valores
ou chamadas de funções. Embora não seja necessário, é altamente recomen-
dado que cada linha seja digitada em uma linha individual, para facilitar a
legibilidade do código.
Na Figura 1, pode-se observar que as instruções são encerradas com o
símbolo de ponto e vírgula (;). Essa marcação avisa a game engine que a
instrução foi finalizada e que uma nova será iniciada. A GML permite algumas
liberdades com a sintaxe da linguagem, como permitir que o desenvolvedor
não utilize ponto e vírgula após uma instrução. No entanto, isso não é reco-
mendado, pois o ; garante que a uma instrução não influenciará na próxima.
Além disso, segundo a YoYo Games (2019), a linguagem encontra erros de
sintaxe com mais facilidade quando o símbolo é utilizado.

Figura 1. Estrutura e indentação da GameMaker Language.

 Criação inicial de jogos com GameMaker Language (GML) 3

As instruções também podem ser agrupadas em blocos de código, limitados

por um par de chaves ({}). Em geral, esses blocos são utilizados em conjunto
com estruturas condicionais (If-Else) ou de repetição (For). Sempre que
se monta um If, a condição é válida apenas para a instrução que estiver a
seguir da estrutura. Como isso não é muito restritivo, pode-se colocar um par
de chaves após o If, o que faz todo o conjunto ser considerado uma instrução.
É importante ressaltar que esses tipos de estruturas são os únicos casos em
que não se deve adicionar o ;, pois seu uso encerra o efeito das instruções
antes mesmo de elas iniciarem.
Na GML, assim como em muitas outras linguagens, as chaves são cumu-
lativas, permitindo abrir um número indefinido de blocos, contanto que todos
sejam corretamente fechados. Por padrão, deve-se indentar o código que está
dentro de um código para que ele possa ser corretamente identificado pelo
desenvolvedor. Para cada nova camada de blocos, indenta-se o código ainda
mais, como visto na Figura 1 (linhas 11 e 15).

Utilizando funções
Segundo a YoYo Games (2019), a definição geral de uma função na GML seria
semelhante a uma função que possui uma entrada (input) e uma saída (output),
e sua saída está relacionada, de alguma forma, com a entrada. Quando se
utiliza funções, é comum que suas entradas sejam chamadas de parâmetros
(Parameters) ou argumentos (Arguments), e suas saídas, de retornos (Return).
Na GML, as funções são utilizadas para realizar as principais ações do jogo,
como criar e destruir instâncias, alterar a room atual, renderizar textos na tela
e realizar cálculos matemáticos.
Para executar uma função da GML, deve-se seguir um padrão. Primeiro,
deve-se adicionar o seu nome, que é composto por um ou mais termos, separa-
dos pelo símbolo de sublinhado. Depois, deve-se utilizar um par de parênteses
(). Os argumentos dessa função devem ser adicionados entre os parênteses e
separados por vírgulas. Por fim, deve-se encerrar a instrução com um símbolo
de ;, como nas demais instruções. Um exemplo de uso de funções pode ser
visto na Figura 2 (linha 2). Considere que esse é o código de um evento do
obj_code. Observe que nem todas as funções necessitam de argumentos
ou retornam algum valor.
4 Criação inicial de jogos com GameMaker Language (GML)

Figura 2. Uso de funções na GameMaker Language.

A função instance_nearest(x, y, obj) é utilizada para encontrar

a instância do objeto obj mais próxima do ponto x, y. Os três argumentos
devem ser preenchidos de forma correta, com x e y recebendo valores nu-
méricos, e obj, uma referência a um dos objects do projeto. O retorno dessa
função será uma referência para a instância mais próxima. É possível utilizar
variáveis tanto como argumentos quanto como uma maneira para se salvar
o retorno de uma função. Além disso, o retorno de instance_nearest é
salvo em uma variável para ser utilizado no restante do código.
A função instance_destroy, por sua vez, pode receber argumentos.
Se nenhum parâmetro for utilizado, ela apenas destruirá a instância que está
executando o código. No caso da Figura 2 (linha 12), a instância do obj_code
será destruída. Contudo, pode-se incluir alguns argumentos opcionais na fun-
ção. O primeiro é uma referência para uma instância (id), e o segundo, uma
booleana de chamada de evento (execute_event_flag). Se algum valor
for adicionado para o parâmetro id, a instância referenciada será destruída,
em vez do obj_code. No caso do execute_event_flag, pode-se utilizar
o valor false, para que o evento Destroy da instância destruída não seja
executado. Na linha 7, a instância mais próxima do obj_wall é destruída
sem executar seu evento de Destroy, visto que, independentemente do número
de argumentos utilizados, a função não retorna nenhum valor (N/A).
Durante a digitação de um trecho de código, a GameMaker tentará “adi-
vinhar” o que se está tentando utilizar através do Auto-Complete. No caso de
funções, pode-se observar os argumentos necessários para a sua execução na
Figura 3. Os argumentos com um asterisco (*) após o seu nome são conside-
rados opcionais, como os da função instance_destroy.
 Criação inicial de jogos com GameMaker Language (GML) 5

Figura 3. Auto-Complete da GameMaker Studio.

A GML oferece uma grande variedade de funções prontas para o acesso do desenvol-
vedor. No entanto, é altamente recomendado que se utilize o manual da GameMaker
Studio durante a programação do jogo, pois, além de informações sobre o uso da engine,
ele possui especificações sobre cada função, seus argumentos e exemplos de uso.
O manual pode ser acessado pelo menu Help > Open Manual ou pelo atalho F1.
Uma maneira rápida de se encontrar informações sobre uma função específica é
pela aba de Index. Em segundo caso, também é possível utilizar a aba de Search para
pesquisar termos específicos.

2 Configuração de eventos e scripts

A GML oferece alguns recursos para aumentar o controle dos programadores
sobre o código, como scripts, comentários e keywords. Os scripts podem
ser utilizados para compartilhar trechos de códigos entre diferentes objetos.
Já os comentários são utilizados para fornecer informações aos demais de-
senvolvedores e organizar o código. Por fim, as keywords são utilizadas para
referenciar outros conjuntos de instâncias e controlá-los ao mesmo tempo.
6 Criação inicial de jogos com GameMaker Language (GML)

Segundo a YoYo Games (2019), os scripts são, essencialmente, funções

criadas pelo desenvolvedor que podem resolver expressões, retornar valores
ou realizar qualquer ação que a linguagem permita. O uso de scripts é reco-
mendado para códigos que são utilizados por diferentes objetos do projeto.
Isso porque é possível programá-los em apenas um local e acessar o código
em qualquer outro local do projeto. Os scripts também podem ser utilizados
para separar um código extenso em pedaços menores.
Para criar um script, pode-se acessar a janela de Resources da GameMaker
ou utilizar o atalho Alt + C. A janela de edição de um script é idêntica à de
um evento, com a exceção de que ele não está associado a nenhum object.
Assim como as funções, os scripts possuem o seu conjunto de argumentos,
cada um podendo ter até 16 no total. Para cada script criado, a GameMaker
disponibilizará variáveis com os nomes argument0 até argument15, que
podem ser utilizadas ao longo do código.
Além disso, pode-se utilizar os argumentos em forma de vetor, pela variável
argument[n], onde n é o índice do argumento desejado (a partir de 0).
Ao utilizar esse método, é possível utilizar a variável argument_count,
que informa quantos argumentos foram enviados para o script. Observe que
se deve optar por um dos dois modos de acesso a argumentos, pois a GML
não aceitará uma mistura de ambos.
Para retornar algum valor do script, deve-se utilizar o termo return. Sempre
que um termo de retorno é alcançado, a execução do script será encerrada,
independentemente da quantidade de scripts no código. A Figura 4a apresenta
um exemplo de script, chamado scr_example, que recebe dois argumentos.
O seu resultado é simples: ele retornará a soma do primeiro parâmetro elevado
ao quadrado com o segundo parâmetro elevado ao cubo. Nas linhas 6 a 9,
verifica-se se os valores enviados são números reais. Caso algum não seja
(!is_real), o valor 0 será retornado, e a execução, encerrada. Se o código
passar pelas condicionais, ele retornará a soma correta. A função power
eleva o primeiro argumento na potência definida pelo segundo. Observe que
não é preciso utilizar as chaves nas condicionais, pois cada uma delas está
relacionada a apenas uma instrução.
A Figura 4b apresenta um exemplo de execução do script. Esse código
está presente em um evento de um objeto, mas pode-se utilizar scripts dentro
de outros scripts livremente. Ele deve ser chamado pelo nome do recurso, e
os argumentos devem ser utilizados como funções. O retorno do script será
salvo na variável sum. Após o fim da execução do script, o evento verificará
seu resultado. A função show_debug_message exibe uma mensagem na
 Criação inicial de jogos com GameMaker Language (GML) 7

janela de Output da GameMaker Studio enquanto o projeto está em execução,

permitindo exibir informações do jogo para debugging do código. Como
argumento, ela pede uma string, mas também é possível utilizar uma variável
para exibir seu valor, como a velocidade ou a posição de um personagem.

(a)

(b)

Figura 4. Acessando e utilizando um instance_name. (a) Código do script scr_exam-

ple; (b) executando o script através de um evento.

Comments
Segundo a YoYo Games (2019), quando se trabalha em colaboração com outras
pessoas, quando se lida com projetos grandes, ou apenas para referência própria,
deixar comentários (comments) pelo código é uma atividade muito importante.
Comentários são anotações ao longo do código, interpretados e executados pela
engine, funcionando como textos e marcações. A GameMaker Studio oferece
algumas opções para se comentar o código em scripts e eventos, permitindo
que o desenvolvedor detalhe o funcionamento de um trecho, os argumentos
necessários para uma função, os resultados esperados para um statement ou
as instruções para os colegas da equipe de desenvolvimento.
8 Criação inicial de jogos com GameMaker Language (GML)

Na GML, o comentário mais simples é definido utilizando-se duas barras

(//). Esse comentário cobrirá apenas a linha atual, a partir do ponto onde as
barras foram inseridas. Dessa forma, pode-se adicionar um statement e, ao
seu lado, um comentário, embora não seja uma prática muito comum. Um uso
frequente desse tipo de comentário é para demarcar algo em comum entre as
próximas instruções, como a definição de variáveis, ou para resumir a função
de um trecho de código (Figura 5).

Figura 5. Exemplos de comentários.

A GML também permite a criação de comentários multilinha. A sequên-

cia de linhas de comentário é iniciada pelos símbolos /* e encerrada pelos
símbolos */. Assim, tudo que estiver entre essas marcações será considerado
um comentário. Os comentários multilinha são normalmente utilizados para
descrever os argumentos de um script, com uma linha dedicada para cada
um (Figura 4). Eles também podem ser utilizados para desativar um bloco de
código durante sessões de debug, a fim de permitir que o desenvolvedor teste
conjuntos de comportamentos aos poucos.
O atalho Ctrl + K pode ser utilizado para comentar as linhas selecionadas
com o símbolo //. O comentário cobre cada linha completamente, mesmo
que apenas uma parte tenha sido selecionada. Já o atalho Ctrl + Shift + K pode
ser utilizado para remover o comentário das linhas selecionadas.
 Criação inicial de jogos com GameMaker Language (GML) 9

Comentários multilinha não funcionam cumulativamente. Se a sequência de símbolos

/*, /*, */, */ for adicionada em quatro linhas individuais, a GameMaker indicará um
erro no código. Isso acontece porque o segundo /* será considerado um comentário,
e não uma marcação. Dessa forma, o comentário multilinha será formado entre as linhas
1 e 3, e a última marcação será considerada “incompleta”, por não encontrar um /*.

Keywords
Segundo a YoYo Games (2019), para facilitar certas programações, a Game-
Maker Studio oferece um conjunto de palavras-chave (keywords) para ser
utilizado em scripts e eventos. O principal uso das keywords é para identificar
um determinado conjunto (possivelmente vazio) de instâncias, sendo elas:
self; other; all; noone.
O self é utilizado para identificar a instância que está executando o código
atual, o que pode variar ao longo de um evento; o uso dessa keyword pode
ser observado na Figura 6. Considere que esse código está em um evento do
objeto obj_code, por exemplo. Nas linhas 1 e 2, o self indicará o próprio
obj_code, modificando os valores de suas variáveis. Nesse caso, o uso do
self não é necessário, pois essas instruções não estão dentro de nenhum
bloco que modifique a sua referência.
Na linha 3, a função instance_create_layer criará uma instância
do obj_example na posição 0,0. Como essa função retorna uma referência
para a instância criada, o with está representando que “o trecho a seguir
será executado pela instância criada”. Dessa forma, os self das linhas 5 e 6
indicarão a instância criada, alterando suas variáveis.

Figura 6. Keyword self.

10 Criação inicial de jogos com GameMaker Language (GML)

O other é utilizado de duas formas: em eventos de colisão ou em trechos

de um with. Eventos de colisão são disparados quando duas instâncias,
normalmente de objetos distintos, entram em contato. Dentro desses eventos,
o other será uma referência direta à instância com a qual se colide, pois se
tem acesso normal à instância atual.
Considere que o código exibido na Figura 7, semelhante ao anterior, pertence
ao obj_code e que este é um evento de colisão com o obj_collision,
por exemplo. Nesse caso, os other das linhas 1 e 2 serão uma referência
para o obj_collision, por ser a instância que colidiu com o obj_code.
O código pertencente ao with continuará sendo executado pelo obj_exam-
ple, porém os other das linhas 5 e 6 indicarão o obj_code. Isso ocorre
porque a instância que executou o with foi o obj_code.

Figura 7. Keyword other.

O all é utilizado para referenciar todas as instâncias da room atual.

Observe que as instâncias desativadas não são incluídas. Quando utilizado
em conjunto com um with, o código será executado por todas as instâncias
ativas. A Figura 8 apresenta um código que destruirá toda e qualquer instância
que estiver em uma posição Y maior que 150. Isso pode ser utilizado para
criar uma área de destruição, por exemplo, de modo que nenhum objeto pode
passar por ela ou será removido do jogo.
O all também pode ser utilizado em funções que solicitam algum objeto
como parâmetro. A função instance_position (x, y, obj), por
exemplo, verifica se há alguma instância de determinado objeto (obj) na
posição definida. Ao utilizar o all como terceiro parâmetro, verifica-se se
qualquer instância de qualquer objeto está naquele ponto.
 Criação inicial de jogos com GameMaker Language (GML) 11

Figura 8. Keyword all.

O noone é utilizado para indicar que não há nenhuma instância refe-

renciada, além de ser utilizado como retorno de funções que normalmente
retornam uma instância, mas não encontraram uma compatível. A função
instance_nearest (x, y, obj), por exemplo, retorna a instância
do objeto obj que estiver mais próximo do ponto indicado. Caso nenhuma
instância seja encontrada, por estarem desativadas ou não existir nenhuma
na sala, a função retornará o valor noone. Dessa forma, pode-se utilizar o
noone em condicionais para saber se uma referência foi encontrada ou não.
A Figura 9 apresenta um exemplo de um código que procura a instância do
obj_example mais próximo da instância que está executando o código.
Se uma instância for encontrada, ou seja, o valor não for noone (!= no-
one), sua posição será modificada.

Figura 9. Keyword noone.

12 Criação inicial de jogos com GameMaker Language (GML)

3 Uso de variáveis
Segundo a YoYo Games (2019), a GML utiliza, assim como qualquer linguagem
de programação, variáveis como uma unidade básica para a maioria de suas
instruções. As variáveis armazenam informações do jogo e do projeto na
memória do hardware que está sendo executado. Essas informações podem ser
utilizadas futuramente por uma ou mais instâncias, dependendo de seu escopo.
A GML oferece vários tipos de valores para serem armazenados em uma
variável. Todas as funções que solicitam argumentos devem receber os tipos
corretos de informação, para que a engine não sinalize um erro. Os tipos de
informações mais utilizados são: valores numéricos, reais (Real) ou inteiros
(Integer); valores textuais (String), como palavras e frases; valores
binários (Boolean), com apenas true ou false; referências a um recurso
(Resource); e vetores (Array), utilizados para armazenar informações
em sequências indexadas.
O uso de variáveis oferece uma grande vantagem, principalmente na ma-
nutenção do código. Se, durante o processo de desenvolvimento, algum valor
for alterado, como a velocidade máxima do jogador, pode-se apenas ajustar
o valor dessa variável no objeto. Sem ela, seria necessário encontrar todos os
locais do código onde esse valor é utilizado e modificá-lo.
Cada variável deve possuir um nome para identificá-la, seguindo algumas
regras. O nome deve começar com uma letra ou o símbolo de underscore/
sublinhado ( _ ). Ao longo do restante do nome, podem ser utilizados apenas
letras, números e underscores. O nome deve ser definido em um texto contínuo,
ou seja, sem espaços, caso contrário, a GameMaker interpretará que são dois
termos individuais. A GameMaker possui quatro tipos principais de variáveis
disponíveis: Instance Variables; Local Variables; Global
Variables; e Built-in Variables.
Instance Variables são variáveis criadas dentro de uma instância
de objeto. Seu valor é único para cada instância, permitindo que diferentes
cópias de um objeto possam funcionar individualmente. Um uso comum
de variáveis de instância é a definição da vida de um personagem. Dessa
forma, cada instância pode sofrer danos em diferentes momentos do jogo
e ser destruídas quando seu valor for menor ou igual a 0, por exemplo. Se
o valor fosse compartilhado entre as instâncias e um personagem sofresse
dano, todas as outras cópias também sofreriam o mesmo dando, sendo todas
destruídas em conjunto.
 Criação inicial de jogos com GameMaker Language (GML) 13

Para criar uma nova variável de instância, basta utilizar uma expressão
de atribuição com o seguinte formato: nome_da_variável = valor;.
Quando uma atribuição é feita, define-se o valor de uma variável. Se não
existir até o momento, ela será criada com o valor escolhido. Variáveis locais
são destacadas, por padrão, com a cor azul, com um toque de roxo.
A Figura 10 apresenta exemplos de criação de variáveis de instância com
valores numéricos, de string e booleanos. Na linha 7, pode-se observar que
a variable_sum terá o resultado de uma soma como valor final. Nesse
caso, o resultado será 200, pois o valor de variable_number é 100.
Se variable_number não tivesse sido definida até o momento da execução
desta linha, a GameMaker detectaria um erro, interrompendo a execução do
projeto. Por isso, deve-se ter cuidado para garantir que todas as variáveis de
instância sejam criadas antes de serem utilizadas. Uma prática comum é criá-
-las a partir da janela Variable Definitions, ou no evento de Create.

Figura 10. Variáveis de instância.

Local Variables são variáveis que têm o seu escopo limitado pelo
evento atual (ou script atual). As variáveis locais também costumam ser
chamadas de variáveis temporárias (Temporary ou Temp). Ao criar uma
variável local, ela funcionará como uma variável de instância comum durante
o evento/script. Todavia, no momento em que o evento encerrar, ela será
removida da memória do programa, sendo efetivamente deletada. Como as
variáveis locais pertencem ao evento/script atual, elas podem ser utilizadas
em blocos de código criados ao longo do evento, como dentro de um with.
14 Criação inicial de jogos com GameMaker Language (GML)

Segundo Habgood e Overmars (2006), essas variáveis são importantes para

manter o uso da memória sobre controle, pois é comum encontrar cenários
onde centenas de instâncias de um objeto utilizam um grande conjunto de
variáveis temporárias ao longo da execução do jogo. Segundo Habgood et al.
(2010), as variáveis locais também podem ser utilizadas para facilitar a leitura
(readability) do código, principalmente em expressões longas. Além disso,
pode-se salvar resultados intermediários de contas matemáticas em variáveis
temporárias e combiná-las em um resultado apenas utilizando suas referências.
Para que uma variável temporária seja definida no lugar de uma variável
de instância, deve-se utilizar o termo var antes de seu nome. O var será
destacado com a cor laranja, em negrito, e qualquer referência da variável terá
a cor amarela. Após a declaração, não é necessário utilizar o var novamente.
A Figura 11 apresenta um código do obj_code que faz o uso de variáveis
locais. Elas podem armazenar valores e expressões, assim como qualquer variá-
vel de instância. Como a função instance_create_layer retorna uma
referência para a instância criada, pode-se salvar a referência em uma variável,
como na linha 6. Lembre-se de que apenas a variável que está referenciando
a instância será deletada após a conclusão do evento, não a instância em si.
Dessa forma, o obj_code perderá o acesso à instância de obj_example,
enquanto ela funciona normalmente.

Figura 11. Variáveis temporárias.

Global Variables são variáveis que pertencem diretamente ao projeto.

Elas podem ser declaradas e acessadas por qualquer instância (menos quando
alguma restrição é estabelecida) do projeto, porém há apenas uma “cópia” dessa
variável. Segundo Rogers (2010), as variáveis globais são extremamente úteis
para a criação de valores compartilhados entre diferentes elementos do projeto,
 Criação inicial de jogos com GameMaker Language (GML) 15

como pontuações, o nome da fase atual e munições e armas disponíveis para

o jogador. É importante ressaltar que as variáveis globais mantêm seu valor
quando a room atual é trocada, diferentemente de variáveis de instâncias. Isso
ocorre porque as instâncias são destruídas quando uma nova room é carregada,
a menos que elas sejam marcadas como Persistent.
Na GameMaker Studio, é preciso declarar variáveis globais com o prefixo
global., como em global.points. O termo global será destacado em
vermelho, por ser um valor já definido internamente pela engine, ao passo que
o nome da variável terá a cor magenta. Ao contrário das variáveis locais, as
referências futuras de variáveis globais precisam, obrigatoriamente, do prefixo
global., pois essas variáveis pertencem a um objeto chamado global,
que tem suas informações acessadas. Sem esse prefixo, se estaria tentando
acessar uma variável de instância (ou local) que possua o mesmo nome, o que
é possível, mas não é recomendado. A Figura 12 apresenta um exemplo de
código que utiliza variáveis globais. Observe que a instrução da linha 6 está
definindo (e criando) o valor de uma variável de instância chamada points,
em vez de modificar o valor da variável global. A variável global terá o valor
10 ao fim do evento.

Figura 12. Variáveis globais.

Built-in Variables são variáveis definidas pela própria GameMaker

para uma variedade de recursos, principalmente objects e rooms. As variáveis
built-in podem ser de instância ou globais, mas nunca locais, pois não
é possível criar novas variáveis desse tipo. Elas são utilizadas com muita
frequência ao longo do projeto, devido ao fato de possuírem informações
relacionadas a posição, velocidade e sprite de uma instância. Por padrão, as
variáveis desse tipo são representadas pela cor verde-clara (Figura 11).
16 Criação inicial de jogos com GameMaker Language (GML)

São exemplos de variáveis built-in de instância: x e y para posicio-

namento; speed, hspeed, vspeed e direction para movimentação;
sprite_index, sprite_width, sprite_height e image_speed
para sprites e animações. São exemplos de variáveis built-in globais:
GM_version, que retorna a versão atual como string; e view_xport, que
indica a posição X da view escolhida (como view_xport[2]).
Segundo a YoYo Games (2019), as variáveis built-in, em sua grande
maioria, podem ter seus valores alterados, como qualquer outra variável, porém
não é necessário definir um valor inicial para elas. Além disso, a GameMaker
possui conjuntos de códigos funcionando internamente, principalmente para
as variáveis cujo valor pode ser alterado. Por exemplo, as variáveis de x, y,
xprevious e yprevious são atualizadas automaticamente pela engine a
cada game step, e o mesmo vale para o image_index.

Acessando variáveis em outras instâncias

Modificar variáveis de instâncias diferentes das que se está programando é
uma necessidade muito frequente durante a programação de eventos. Isso
pode ocorrer em situações em que um inimigo ataca e é preciso saber quanto
dano ele irá causar, ou quando algum item é coletado e é preciso saber seu
nome, por exemplo.
A maneira mais simples de se modificar uma variável é por meio da refe-
rência ao recurso desejado, normalmente objects. Quando um recurso é criado,
é preciso definir um nome para ele, como obj_example. Esse nome pode
ser utilizado na programação sempre que se desejar modificar alguma variável
desse objeto, utilizando o formato nome_do_objeto.nome_da_variá-
vel, como na linha 2 do código exibido na Figura 13. Lembre-se de que, se
houver mais de uma instância na room, todas serão afetadas pela instrução.
Isso pode ser muito útil para se ter acesso direto a objetos com apenas uma
instância, como os controladores e o jogador. Nesse tipo de acesso, não é
possível utilizar a keyword all para modificar ou definir uma variável de
todas as instâncias (linha 4), mas pode-se utilizar o with, como pode ser
visto nas linhas 6 a 9.
 Criação inicial de jogos com GameMaker Language (GML) 17

Figura 13. Acessando variáveis de instâncias.

Outra maneira de acessar variáveis de uma instância é por meio do seu

nome de instância (instance_name). Sempre que uma instância do editor
de room for posicionada, será possível encontrar seu nome pela janela de
propriedades da layer (Figura 14a). No entanto, para layers com muitas ins-
tâncias repetidas, pode ser um processo trabalhoso encontrar a correta. Nesses
casos, é possível abrir a janela de edição de instâncias com um Double Click
do mouse e encontrar o nome (Figura 14b). O nome da instância sempre será
composto por inst_, seguido por oito dígitos hexadecimais. Com o nome
da instância encontrado, basta utilizá-lo no lugar do nome do objeto, como
pode ser visto na Figura 14c (linha 2).
Além disso, é possível acessar outras instâncias por meio de variáveis que
tenham como valor um ID (identifier) válido de alguma instância. Funções
como instance_create_layer e instance_position retornam
uma referência para uma instância através de seu ID. Dessa forma, pode-se
salvar seu retorno em uma variável e utilizá-lo ao longo do código. Lembre-se
de que algumas dessas funções podem não retornar um valor, mas a keyword
noone, por isso, deve-se checar se a instância é válida com a função ins-
tance_exists. A keyword other funciona de maneira semelhante.
Em eventos de colisão, ela será uma referência direta ao ID da instância com
a qual se colide, e, com o uso do with, ela será uma referência para o ID na
instância que o está executando.
18 Criação inicial de jogos com GameMaker Language (GML)

(a) (b)

(c)

Figura 14. Acessando e utilizando um Instance Name. (a) Janela de propriedades de

uma layer; (b) informações de uma instância; (c) utilizando o Instance Name no código.

A GML oferece uma variedade de recursos para a criação do código,

porém é necessário praticar para utilizá-las corretamente e de maneira efetiva.
Muitas de suas funções, principalmente as relacionadas a instâncias, como
instance_create_layer e instance_destroy são utilizadas com
muita frequência ao longo do código. Adquirir experiência com essas funções
acelerará o processo de desenvolvimento. Lembre-se também de sempre ter o
manual da GML aberto, uma vez que, mesmo com experiência, é comum que
algum detalhe seja esquecido, como quais argumentos utilizar.

HABGOOD, J. et al. The game maker's companion. Berkeley: Apress, 2010.

HABGOOD, J.; OVERMARS, M. The game maker's apprentice: game development for
beginners. Berkeley: Apress, 2006.
 Criação inicial de jogos com GameMaker Language (GML) 19

ROGERS, S. Level up! The guide to great video game design. 2nd ed. Hoboken: John
Wiley & Sons, 2010.
YOYO GAMES. GameMaker Studio: user manual. [2019]. Disponível em: http://docs2.
yoyogames.com/. Acesso em: 01 fev. 2020.

Os links para sites da Web fornecidos neste capítulo foram todos testados, e seu fun-
cionamento foi comprovado no momento da publicação do material. No entanto, a
rede é extremamente dinâmica; suas páginas estão constantemente mudando de
local e conteúdo. Assim, os editores declaram não ter qualquer responsabilidade
sobre qualidade, precisão ou integralidade das informações referidas em tais links.