Assine o DeepL Pro para traduzir arquivos maiores.

Mais informações em www.DeepL.com/pro.

Tutorial do Game Maker

Criação de jogos de
plataforma
Escrito por Mark Overmars

Copyright © 2007 YoYo Games Ltd

Última alteração: 26 de fevereiro de
2007
Usos: Game Maker7.0, Lite ou Pro Edition, Modo Avançado
Nível: Intermediário

Os jogos de plataforma são muito comuns, principalmente em dispositivos portáteis.

Em um jogo de plataforma, você olha a cena de lado. O jogador normalmente
controla um personagem que anda pelo mundo. Esse mundo consiste em plataformas.
O jogador pode andar sobre essas plataformas, pular ou cair de uma plataforma para
outra, usar escadas ou cordas para chegar a lugares diferentes etc. Nas plataformas, há
objetos para coletar, inimigos para evitar ou matar (geralmente atirando neles ou
pulando em cima deles), interruptores que podem ser pressionados para abrir
passagens etc. Além disso, o jogador normalmente precisa de habilidade para saltar
sobre áreas perigosas. Em alguns jogos de plataforma, você vê o nível inteiro de uma
só vez, mas na maioria você vê apenas uma parte ao redor do personagem. Nesse
caso, encontrar o caminho se torna um desafio adicional.

Criar um bom jogo de plataforma não é algo trivial, tampouco com o Game Maker.
Há três aspectos importantes a serem levados em conta:
• Criação de movimento natural para o personagem.
• Criar variação suficiente nos monstros, no plano de fundo, etc.
• Projetar cuidadosamente os níveis de modo que sejam divertidos
de jogar e se tornem cada vez mais difíceis.

Neste tutorial, você aprenderá a criar um jogo de plataforma simples no Game Maker.
Criaremos o jogo em várias etapas. As várias etapas estão disponíveis como jogos
editáveis na pasta Examples (Exemplos). Eles consistem em apenas um nível para
demonstrar algum aspecto específico. Você pode usá-los como base para seus
próprios jogos de plataforma.

O básico
Começaremos com o jogo de plataforma mais simples. Você pode encontrá-lo no
arquivo platform_1.gm6. Em cada jogo de plataforma, há dois objetos básicos: o
personagem que é controlado pelo jogador e um objeto de bloco que é usado para os
pisos (plataformas) sobre os quais o jogador pode andar. O mesmo bloco costuma ser
usado para as paredes pelas quais o jogador não pode passar. Precisamos de dois
sprites: um para o personagem e outro para o bloco. Para o personagem, usamos uma
bola simples. Para o bloco, usamos um quadrado preto (não transparente). Criamos
dois objetos. O objeto bloco é simplesmente um objeto sólido que não tem eventos ou
ações. Ele simplesmente fica lá. O objeto do personagem é muito mais complicado.

Movimento
1
O aspecto crucial que tratamos nesta primeira seção é como definir o movimento do
personagem. O problema é que o personagem deve andar sobre os pisos. Ele não deve
cruzar o piso. Se o personagem pular ou cair de uma plataforma, ele deverá aterrissar
corretamente na plataforma seguinte. Há várias maneiras diferentes de o personagem
andar, pular e cair. Diferentes jogos de plataforma usam modos diferentes.
Normalmente, nós apenas

2
use três teclas para controlar o movimento. A tecla de seta para a esquerda deve
mover o personagem para a esquerda, a tecla de seta para a direita deve movê-lo para
a direita e a tecla para cima ou a tecla de espaço o faz pular.

Vamos considerar primeiro o movimento para a esquerda e para a direita. A primeira

escolha a ser feita é se o jogador só pode mudar a direção do movimento quando
estiver em uma plataforma ou também no ar ao pular ou cair. Embora a segunda
opção não seja natural (é bastante difícil começar a se mover para a esquerda quando
se está caindo), decidimos optar pela primeira opção, ou seja, permitimos o
movimento horizontal onde quer que o personagem esteja. Isso tende a levar a um
jogo mais agradável e, na verdade, também é mais fácil de implementar.

A segunda opção é se o movimento tem velocidade constante ou se ele acelera

quando você mantém a tecla pressionada. Por motivos de simplicidade, optamos pela
primeira opção.
Permitir a aceleração, no entanto, normalmente proporciona um jogo mais agradável:
o jogador deve, por exemplo, iniciar uma corrida a uma certa distância para saltar
sobre um buraco largo.

Como você deve saber, há diferentes maneiras de permitir que um personagem se

mova. Podemos definir uma velocidade de movimento ou simplesmente mover o
personagem diretamente. Em jogos de plataforma, normalmente é mais fácil deixar
que o movimento vertical seja feito automaticamente (como veremos a seguir), mas
fazer o movimento horizontal por conta própria. Isso é bastante simples. No evento
do teclado para a tecla de seta para a esquerda, verificamos se a posição na posição
relativa (-4,0) está livre. Em caso afirmativo, deixamos o caractere saltar para essa
posição. Tratamos a tecla de seta para a direita de forma semelhante. Veja o exemplo
de jogo em anexo.

Saltos
Em seguida, precisamos do movimento vertical. Isso é mais difícil. Para que o
personagem caia, podemos usar a gravidade. Mas ele deve parar de se mover quando
atingirmos o chão. Além disso, você normalmente quer uma velocidade máxima de
queda, caso contrário, o personagem se moverá rápido demais. (Isso não é muito
agradável, mas também pode causar problemas na implementação. Por exemplo, o
personagem pode cair em um piso se ele se mover muito rápido). Para resolver esse
problema, no evento de passo do personagem, verificamos se a posição logo abaixo
do personagem está livre de colisão. Em caso afirmativo, o personagem está no ar e
definimos a gravidade como um valor positivo. Caso contrário, nós a definimos como
0. Também verificamos a variável vspeed, que indica a velocidade vertical. Se ela
for maior que 12, nós a definimos novamente como 12. Dessa forma, limitamos a
velocidade vertical a 12. Portanto, o evento tem a seguinte aparência:

3
Em seguida, temos que aterrissar corretamente no chão. Isso é mais difícil do que
parece. Isso ocorrerá quando o personagem colidir com o objeto de bloco. Nesse
evento de colisão, devemos definir o movimento vertical como 0. Mas isso pode
deixar o personagem um pouco suspenso no ar, acima do chão. (O motivo é que o
personagem é colocado de volta em sua posição anterior à colisão). Para isso,
queremos mover o personagem para o ponto exato onde ocorre a colisão. Felizmente,
há uma ação para isso no Game Maker:

Mover para contato

Com essa ação, é possível mover a instância em uma determinada direção até
que uma posição de contato com um objeto seja alcançada. Se já houver uma
colisão na posição atual, a instância não será movida. Caso contrário, a
instância será posicionada imediatamente antes da ocorrência de uma colisão.
Você pode especificar a direção e também uma distância máxima a ser
movida. Você também pode indicar se deseja considerar apenas um objeto
sólido ou todos os objetos.

Usamos essa ação. Como direção, indicamos a variável direction, que é a direção
atual de movimento da instância. Como distância máxima, especificamos 12 (embora
isso não seja realmente necessário aqui):

4
Portanto, o evento total de colisão com o bloco é o seguinte:

Você poderia argumentar que só devemos fazer isso quando atingirmos um piso
abaixo de nós. Mas, na verdade, também devemos nos mover para a posição de
contato se atingirmos um piso por baixo ou uma parede pela lateral. Há um aspecto
importante aqui que geralmente causa problemas: Presumimos que o personagem em
sua posição anterior está de fato livre de colisões. É de se esperar que isso aconteça,
mas nem sempre é o caso. Um erro que geralmente é cometido é que, quando o
personagem tem uma imagem animada, a máscara de colisão também muda a cada
etapa. Isso pode significar que a nova imagem no local anterior ainda causa uma
colisão. Portanto, é melhor certificar-se de que o personagem tenha uma máscara de
colisão (consulte também a próxima seção).

Por fim, temos de permitir que o personagem salte quando a tecla de seta para cima for
pressionada. Mas isso só deve acontecer quando o personagem estiver no chão.
Portanto, primeiro testamos se a posição abaixo do personagem cria uma colisão e, em
caso afirmativo, definimos a velocidade vertical
por exemplo, para -10. Talvez seja necessário brincar um pouco com o valor de 10
5
para a velocidade vertical e o valor de 0,5 para a gravidade para obter o movimento
desejado.

6
Agora a base para o jogo de plataforma está pronta. Projete um nível com alguns
pisos e paredes, construídos a partir de instâncias do objeto de bloco. Coloque uma
instância do personagem na sala e pronto.

Gráficos melhores
O jogo de plataforma básico que criamos na seção anterior funciona, mas tem uma
aparência bastante ruim. Há dois aspectos que queremos alterar: a aparência do
jogador e a aparência do plano de fundo. O jogo adaptado pode ser encontrado no
arquivo platform_2.gmk.

As imagens dos personagens

Vamos começar com os gráficos dos personagens. Usaremos dois sprites diferentes
(não animados): um para o personagem voltado para a esquerda e outro para o
personagem voltado para a direita. O mais fácil agora é colocar no evento da tecla de
seta para a esquerda uma ação para alterar o sprite para o que está voltado para a
esquerda. Da mesma forma, na tecla de seta para a direita, você muda para o sprite
com o personagem voltado para a direita. É muito importante que você desative a
verificação precisa de colisão para os dois sprites. Há vários motivos para isso. Em
primeiro lugar, isso evita que o sprite fique preso na metade da borda da plataforma.
Em segundo lugar, quando o sprite é alterado de virado para a esquerda para virado
para a direita, eles devem usar a mesma máscara de colisão, caso contrário o
personagem pode ficar preso. O mesmo é ainda mais importante ao usar sprites
animados. Pelo mesmo motivo, é melhor certificar-se de que as caixas delimitadoras
dos sprites sejam as mesmas. Você sempre pode usar caixas delimitadoras manuais
para isso. Portanto, ao adicionar os sprites, as configurações devem ser mais ou
menos assim:

Em jogos mais avançados, você provavelmente desejará usar sprites animados. Nesse
caso, você também precisará de um sprite para o personagem quando ele não estiver
se movendo. Além disso, talvez você queira adicionar sprites para o personagem
pular, cair, atirar etc. Nesse caso, você terá de alterar o sprite em vários locais nos
eventos. Em particular, no evento sem tecla Keyboard, você provavelmente desejará
definir o sprite como o que não está se movendo.
Como alternativa, você pode desenhar o sprite correto no evento Draw com base na
situação. Por exemplo, você pode verificar se xprevious<x para descobrir se o
personagem se moveu para a direita. Conforme indicado anteriormente, é melhor
7
certificar-se de que todos os sprites tenham a mesma caixa delimitadora e que não
haja verificação precisa de colisão.

8
As plataformas e paredes
Em segundo lugar, queremos melhorar o plano de fundo e as plataformas. Aqui
usamos uma técnica padrão. Em vez de usar objetos para todos os diferentes
elementos de parede e piso, usamos os chamados ladrilhos. Os ladrilhos são partes de
imagens de fundo desenhadas em determinados locais da sala. Eles não têm eventos
associados nem criam colisões. A parte boa é que eles são rápidos e usam pouca
memória. Portanto, você pode criar salas grandes sem a necessidade de imagens
grandes.

Para adicionar ladrilhos aos cômodos, primeiro você precisa de uma imagem de fundo
que contenha os ladrilhos. Os blocos em uma imagem de plano de fundo devem ter
um tamanho fixo e uma pequena borda (1 pixel) entre eles, de modo que possam ser
facilmente separados. Um pequeno conjunto de blocos é fornecido na pasta
Resources. Nós o adicionamos como um recurso de plano de fundo transparente
chamado back_tiles. Ao adicioná-lo ao jogo, nas propriedades do plano de fundo,
indique que ele deve ser usado como um conjunto de blocos e preencha o tamanho e a
separação corretos dos blocos, como segue:

Agora, ao criar uma sala, você pode clicar na guia azulejos. Você pode selecionar o
conjunto de blocos (ou seja, o recurso de plano de fundo apropriado). Agora você
pode desenhar blocos clicando no bloco apropriado e, em seguida, colocando-os na
sala, como faria com os objetos. O botão direito do mouse exclui as peças. Use sua
imaginação para criar salas desafiadoras. (Observe que você pode colocar blocos em
diferentes camadas de profundidade adicionando camadas. Por exemplo, você pode
criar uma camada de peças que ficam na frente dos personagens em movimento. Não
as usaremos aqui, mas elas são ótimas para dar um melhor efeito 3D).

9
No entanto, ainda há um problema. Conforme indicado acima, os blocos são apenas
gráficos bonitos. Eles não geram eventos ou colisões. Portanto, o personagem cairia
direto através deles. Para evitar isso, ainda precisamos dos objetos de bloco que
tínhamos antes. Colocamos os objetos de bloco nos locais apropriados em cima das
paredes e plataformas que você criou com os blocos no plano de fundo. Agora, ao
tornar os objetos de bloco invisíveis, você não verá os blocos pretos, mas os belos
ladrilhos. Mas os objetos de bloco estão realmente lá, portanto o personagem não
poderá passar pelas paredes e aterrissará nas plataformas.

10
Pode haver um problema aqui. Os objetos de bloco 16x16 serão muito grandes para
cobrir bem o plano de fundo. Portanto, queremos criar alguns outros objetos de bloco
de tamanho 16x8 e 8x16. Novamente, nós os tornamos sólidos. Para evitar ter de
especificar eventos de colisão com eles também, usamos o mecanismo pai. Esse é um
mecanismo muito poderoso que você deve aprender a usar. Se um objeto A for um pai
do objeto B, B se comportará como um caso especial de A. Ele herdará todo o
comportamento de A (a menos que você o substitua por outro comportamento). Além
disso, as colisões com B são tratadas da mesma forma que as colisões com A.
Portanto, para os blocos menores, definimos o pai como o bloco maior. Dessa forma,
eles serão tratados da mesma forma que o bloco maior.

Ameaças e guloseimas
Ficar pulando de plataforma em plataforma é um tanto entediante. Você
definitivamente precisa de mais desafios e objetivos. Nesta seção, tratamos de alguns
deles. Dê uma olhada no jogo platform_3.gmk para ver o resultado.

Monstros
Primeiro, vamos adicionar alguns monstros. Criaremos dois monstros, um que se
move para a esquerda e para a direita em uma plataforma e outro que voa para a
esquerda e para a direita no céu. Pular em cima dele pode esmagar o primeiro; o
segundo deve ser evitado o tempo todo.

Vamos começar com o monstro que se move sobre as plataformas. Precisamos de dois
sprites para ele, um com o monstro voltado para a esquerda e o outro com o monstro
voltado para a direita. Novamente, é melhor não usar a verificação precisa de colisão
pelos mesmos motivos indicados acima e escolher uma caixa delimitadora relevante.
Agora, criamos o objeto monstro. No evento de criação, deixamos que ele se mova
para a direita com uma velocidade específica. Sempre que atingir uma parede, ele
reverterá sua velocidade horizontal. Para definir o sprite correto para o monstro,
usamos o evento End Step. Esse evento ocorre logo antes de as instâncias serem
desenhadas. Nele, definimos o sprite correto com base no valor da variável hspeed
que indica a velocidade horizontal. Se ela for menor que 0, deixaremos o monstro
virado para a esquerda e, caso contrário, para a direita. (Se você tiver a Pro Edition do
Game Maker, também poderá usar a ação para espelhar a imagem. Nesse caso, você
precisará de apenas um sprite).

11
Para evitar que os monstros caiam das plataformas, introduzimos outro objeto, que
chamamos de marcador. Esse marcador será um bloco azul invisível. Sempre que um
monstro o tocar, ele inverterá a direção de seu movimento. Ter marcadores invisíveis
é um bom truque geral para permitir que as instâncias executem determinadas ações
em lugares específicos da sala. Além de mudar a direção, você pode usar marcadores
para atirar, colocar bombas etc.

Quando o personagem atinge um monstro, ele deve morrer. Mas, na verdade, como na
maioria dos jogos de plataforma, gostamos de possibilitar que o personagem pule em
cima do monstro e o esmague. Portanto, no evento de colisão do personagem com o
monstro, devemos verificar se atingimos o monstro de cima para esmagá-lo. Para
descobrir isso, realizamos o seguinte teste Para descobrir isso, realizamos o seguinte
teste:

vspeed > 0 && y < other.y+8

Isso é verdadeiro se vspeed for maior que 0, de modo que o personagem se move
para baixo, e o personagem está perto do topo do monstro, de modo que está de fato
atingindo-o de cima. (No exemplo, transformamos o monstro em um monstro morto
plano, que se destrói após algum tempo. Isso proporciona um efeito gráfico mais
agradável). Nesse jogo de plataforma simples, morrer para o personagem corresponde
a reiniciar o nível, o que pode ser feito por meio de algumas ações simples.

O monstro voador é ainda mais fácil. Procedemos exatamente da mesma forma. Só

que, no evento de colisão do personagem com o monstro voador, nenhum teste
precisa ser realizado porque não é possível esmagar um objeto voador.

Talvez você queira adicionar mais monstros, por exemplo, com velocidades
diferentes, para tornar as coisas mais difíceis. Você também pode criar um monstro
ou pedra que caia ou se mova para cima e para baixo. Basta usar sua própria
imaginação.

Poços
A maioria dos jogos de plataforma exige um timing cuidadoso dos saltos para evitar
cair em buracos. Cair em um poço normalmente mata o personagem. Para isso,
adicionamos um novo objeto, chamado morte. Esse objeto é um bloco vermelho que,
mais uma vez, não é visível. Você pode colocá-lo no fundo do poço. (Na sala de
azulejos, você pode colocar alguns espinhos ali.) No evento de colisão do
personagem com o objeto de morte, ele deve emitir um som, esperar um pouco e
reiniciar a sala. Você também pode criar poços que descem infinitamente. Nesse caso,
você deseja adicionar ações semelhantes no evento Outside Room (nos outros
eventos) do personagem, talvez incluindo um teste para verificar se y >
room_height para garantir que o personagem caiu, em vez de pular para fora do
campo de jogo.

Coleta de pontos
A maioria dos jogos de plataforma tem algum mecanismo pelo qual o jogador pode
acumular pontos. Normalmente, é preciso pegar determinados objetos ou apanhar
certas coisas. Em nosso exemplo, o jogador pode coletar cogumelos. Portanto,
criamos um objeto de cogumelo. Para variar um pouco, o sprite do cogumelo contém
10 subimagens de cogumelos diferentes. O objeto cogumelo escolhe uma delas
12
aleatoriamente ao ser criado usando a ação Change Sprite (Alterar sprite):

13
Definimos a subimagem como random(10). random(10) é uma chamada de
função. Ela retornará um número aleatório abaixo do argumento fornecido (portanto,
abaixo de 10 no nosso caso). Definimos a velocidade como 0 para parar de percorrer
as subimagens. No evento de colisão do personagem com o objeto cogumelo,
reproduzimos um som, destruímos o outro objeto (ou seja, o cogumelo) e
adicionamos 10 à pontuação.

Em alguns jogos de plataforma, coletar objetos tem uma função mais importante do
que apenas aumentar sua pontuação. Por exemplo, você pode ganhar uma vida extra
ao coletar objetos suficientes. Também pode haver objetos que restauram sua saúde
(supondo que os monstros não o matem, mas simplesmente o enfraqueçam), fazem
você se mover mais rápido, pular mais alto etc. Isso pode ser facilmente adicionado.

Próximo nível
É claro que deve haver uma maneira de terminar um nível, de modo que o jogador
possa passar para o próximo nível. Para isso, criamos um objeto obj_levelexit.
Quando o personagem chega lá, você é movido para o próximo nível. No exemplo,
isso é feito de forma bastante simples. Adicionamos uma ação de teste para verificar
se a próxima sala existe. Se esse teste for verdadeiro, passamos para a próxima sala.
Caso contrário, a lista de recordes é exibida e o jogo é reiniciado.

Você pode optar por fazer com que a saída do nível apareça somente quando, por
exemplo, todos os cogumelos tiverem sido coletados. Para isso, no evento de criação
do objeto obj_levelexit, mova-o para a posição -100,-100 (portanto, fora da tela).
Agora, no evento de etapa do objeto, verificamos se o número de objetos cogumelo é
igual a 0 (há uma ação para isso) e, em caso afirmativo, movemos o objeto de volta à
sua posição inicial (novamente, há uma ação para isso). Tudo muito simples.

Mais moções
Nosso jogo de plataforma atual tem apenas algumas possibilidades limitadas de
movimento. O personagem pode se mover para a esquerda e para a direita e pode
pular. Para tornar as coisas mais interessantes, vamos acrescentar algumas
possibilidades. O resultado pode ser encontrado no jogo platform_4.gmk.

14
Rampas
É bom que o jogador possa subir rampas inclinadas (a descida é automática por causa
da queda). Para isso, temos de substituir o código no evento da tecla de seta para a
esquerda. Colocamos lá o seguinte:

Em vez de apenas testar se a posição à esquerda está livre de colisão, também

testamos se uma posição 8 pixels acima está livre de colisão. Em caso afirmativo,
movemos o personagem para lá e usamos a ação de aterrissagem para movê-lo para a
posição de contato. Portanto, o evento terá a seguinte aparência:

A tecla de seta para a direita é tratada de forma semelhante.

Escadas
As pessoas sempre querem escadas em jogos de plataforma ao longo das quais o
personagem possa se mover de uma plataforma para outra. Isso requer um pouco de
trabalho. Uma escada será representada por um bloco vertical fino que é invisível (a
escada real, a videira ou o que quer que seja usado para escalar é desenhado
novamente usando ladrilhos) e não sólido. Quando o personagem não estiver em
contato com uma escada, o movimento deverá ser como antes. Mas quando ele
estiver em contato com a escada, as coisas devem ser diferentes. Em primeiro lugar, o
personagem não deve cair. Portanto, no evento de passo, temos de fazer uma
alteração nesse efeito, adicionando algumas ações que definem a velocidade vertical e
a gravidade como 0 quando em contato com uma escada. Além disso, definimos o
sprite para o sprite de escalada nesse caso.

A segunda coisa que precisa ser alterada é o evento da tecla para cima. Quando o
personagem está em uma escada, a tecla de seta para cima deve movê-lo para cima,
em vez de pular. Novamente, precisamos de algumas ações adicionais para isso.
Testamos se o personagem está em contato com uma escada e, em caso afirmativo, o
movemos um pouco para cima. Usamos ações semelhantes para a tecla para baixo.

Usando uma visualização

Até agora, sempre mostrávamos a sala inteira. Para muitos jogos de plataforma, isso
15
não é o que você deseja. Em vez disso, você quer ver apenas uma parte da sala, ao
redor do personagem

16
que você está controlando. Isso torna o jogo mais desafiador, pois o jogador deve
tentar detectar o caminho através das plataformas. Você também pode esconder
prêmios em locais de difícil acesso na sala.

Felizmente, isso é extremamente simples de ser feito no Game Maker. Ao projetar a

sala, clique na guia de visualizações. Clique na caixa de seleção Enable the use of
Views (Ativar o uso de visualizações) para começar a usar as visualizações.
Selecione a primeira visualização e marque a caixa Visible when room starts para
garantir que essa visualização possa ser vista. Dê a ela uma largura de 300 e uma
altura de 200 (ou algo mais que você queira). (Como vamos deixar a visualização
seguir o personagem, não há necessidade de especificar a posição esquerda e superior
da visualização na sala. Além disso, como usamos apenas uma visualização, não
precisamos especificar a posição x e y da porta na tela). Na parte inferior, podemos
indicar o objeto a ser seguido. Aqui, escolhemos o personagem. A visualização agora
se moverá automaticamente para manter o personagem em foco.
Não queremos que o caractere se aproxime muito da borda. Para isso, definimos os
valores de Hbor e Vbor como 64. Agora sempre haverá uma área de 64 pixels visível
ao redor do personagem. Por fim, para obter um movimento de visualização suave,
definimos a velocidade máxima de visualização como
4. (Isso também proporciona um efeito muito bom no início, pois o personagem
aparece lentamente). Portanto, as configurações serão as seguintes:

Ter a visualização é bom, mas torna a janela na qual as coisas acontecem bastante
pequena. Para evitar isso, nas Configurações globais do jogo, indicamos uma escala
fixa de 200%. É claro que você pode brincar com esses valores para obter o efeito
desejado.

17
Alguns toques adicionais
Atirando em monstros
A próxima etapa é permitir que o jogador atire nos monstros. Para tornar as coisas um
pouco mais interessantes, o jogador precisa primeiro encontrar alguma munição para
poder atirar. Para isso, introduzimos uma variável que chamamos de munição e que
indica a quantidade de munição que o jogador tem. No evento Create do personagem,
definimos esse valor como 0 usando a ação para definir uma variável. O objeto de
munição tem um sprite simples e não faz nada. Ele apenas espera ser pego pelo
jogador. Quando o personagem colide com o objeto de munição, adicionamos 10 à
variável munição (definindo-a como 10) e destruímos a instância de munição.

Em seguida, precisamos de um objeto de bala. Quando o jogador pressiona a tecla

<Space>, uma instância desse objeto deve ser criada, supondo que haja munição, e o
valor da variável munição é diminuído em 1. Mas há uma questão importante.
Gostaríamos que a bala disparasse na direção para a qual o personagem está voltado.
Para isso, verificamos o valor da variável sprite_index. Essa variável contém o
índice do sprite do objeto do personagem. Com base nele, criamos uma bala com a
direção correta de movimento. Quando estamos escalando, nenhuma bala é criada.
(Não é possível atirar enquanto se está escalando.) Portanto, o evento de espaço tem a
seguinte aparência:

Resta destruir a bala quando ela atingir uma parede ou quando sair da sala e matar o
monstro quando a bala o atingir. Tudo isso é fácil. Consulte o arquivo
platform_5.gmk para obter detalhes.

Um painel de pontuação
O jogador agora tem uma pontuação e munição. Também lhe daremos algumas
vidas. Atingir um monstro ou cair em um poço custará uma vida. Há um
mecanismo fácil para vidas no Game Maker. Vamos criar um objeto
obj_controller especial. Ele não precisa de um sprite. Em seu evento Create,
ele define o número de vidas como 3. Sempre que o jogador morre, diminuímos o
número de vidas. No evento No More Lives do controlador, mostramos a tabela de

18
recordes e reiniciamos o jogo.

19
Mas também seria bom se pudéssemos ver o número de vidas, a pontuação, a
munição etc. Para isso, vamos criar um pequeno painel com essas informações.
V a m o s desenhá-lo no evento Draw do objeto controlador. Mas há um problema
aqui. Onde devemos desenhá-lo? Não podemos desenhá-lo em um local fixo na sala
porque a visualização muda e queremos que o painel esteja sempre à vista.
Felizmente, podemos solicitar a posição da visualização. Isso é indicado pelas duas
variáveis view_xview e view_yview, que indicam a posição esquerda e a posição
superior da visualização, respectivamente. Assim, podemos desenhar o painel com as
informações relativas a essa posição. Esta é a aparência do evento de desenho do
objeto controlador:

Observe que também desenhamos uma imagem quando o jogador pode atirar. No
jogo, que pode ser encontrado no arquivo platform_5.gmk, o resultado é a seguinte
imagem:

20
E agora?
As seções acima explicaram alguns dos princípios básicos da criação de jogos de
plataforma. Agora é a sua vez. Você terá de usar essas técnicas e mais algumas ideias
suas para criar um jogo de plataforma realmente bom. Lembre-se de que a parte mais
importante dos jogos de plataforma é formada pelos níveis. Comece a criar níveis um
a um. Jogue-os até ficar satisfeito com eles. De vez em quando, introduza algum novo
aspecto de jogo. Aqui estão algumas ideias adicionais que você pode usar:

• monstros diferentes, por exemplo, bolas quicando e monstros que atiram

• chaves que você precisa encontrar para abrir portas
• minas que você pode colocar em algum lugar e que explodem quando
um monstro (ou você mesmo) pisa nelas
• água para nadar (isso mudará completamente os movimentos; não há mais
gravidade, ou há uma leve gravidade para cima até você chegar à superfície,
tempo limitado antes de ficar sem ar, bolhas de ar para agarrar, etc.)
• paredes e pisos que você pode destruir, por exemplo, atirando neles ou
pulando neles com força
• trampolins que fazem você pular mais alto
• plataformas que aparecem e desaparecem
• ruas de mão única
• plataformas móveis (isso não é fácil!)
• ...

Boa sorte.

Leitura adicional
Para ler mais sobre como criar jogos usando o Game Maker, recomendamos que você
compre nosso livro:

Jacob Habgood e Mark Overmars, The Game Maker's Apprentice: Game

Development for Beginners, Apress, 2006, ISBN 1-59059-615-3.

O livro apresenta uma introdução passo a passo a muitos aspectos do Game Maker e,
no processo, você cria nove belos jogos que também são divertidos de jogar.

21