Apostila Game Maker PDF

Apostila Livre
GAME MAKER
Versão 1.0
ESCRITORES
fUzEnRaD
Idealizador e editor
fonetico
F. Nizzio
Suadao
Kabeção
matheus.reis
Copyright (C) Apostila Livre :: Game Maker ::

2010
Está apostila está sob a licença GNU GPL 3: Você pode
redistribuir e modificar o conteúdo com a autorização dos
Índice
• Apostila Livre - Game Maker :: 2010
1. Principais Eventos
2. Variáveis globais
I. Onde usar?
II. Nomeando variáveis globais
3. Introdução ao Draw
I. Modificando cores
II. Draw Point
III. Draw Line
IV. Draw Rectangle
V. Draw Circle
VI. Draw Triangle
VII. Draw Text
4. Introdução aos loops

I. For
II. While
III. Do Until
5. Movimentação básica em plataforma
6. Movimentação básica em TopDown

I. Introdução
II. Desenhando um carrinho básico
III. Criando o objeto do carro
IV. Criando pistas por tiles
7. Recursos externos
I. Arquivos de som
II. Imagens/backgrounds
III. Sprites
8. Janelas Dinâmicas
I. Janelas com Informações
II. Adicionando o efeito fade in/out
III. Janela com botões
IV. Inserir dados
V. Efeitos com janelas
VI. Janela móvel
VII. Efeito Fade In/Out
VIII.Movimento horizontal
9. Pausando o jogo
Índice
10.GM3D - Primeiros passos

I. O que pode ser feito em 3D no Game Maker
II. A terceira dimensão!
III. Construindo uma Engine
11. GM3D – Projeção e Movimento da Câmera

I. A função d3d_set_projection_ext
II. A função d3d_set_projection_ortho
III. Movimentando a câmera
12. GM3D – Usando Transformações

I. Transformações
II. Continuando a engine
III. Rotação e Escalação
IV. Movimentação
13. Licença de uso, modificação e distribuição

I. GNU GPL 3
Legendas:
- Possui código fonte para Game Maker 8 (arquivo indicado em azul).
- Capítulo em revisão.
- Capítulo testado e revisado.
Iniciante
Intermediário
Avançado
Códigos:
1. Objetos (pode ser também sprites, sons, fundos etc)
2. Comandos (qualquer comando ou variável padrão do GM)
3. Dados (número ou texto)
4. Variáveis
5. Funções
6. Comentários (parte ignorada pelo programa)
1. Principais eventos
O Game Maker possui muitos eventos, alguns podem ser substituídos por códigos, outros
não, falarei sobre os principais eventos, o básico que será usado por nós, nessa apostila.
As funções que serão citadas aqui são:
Os botões Delete e Change, apagam e substituem o evento selecionado respectivamente,

o Add Event, mostra toda a relação de eventos disponíveis, todas as opções possíveis,
separadas em outras sub-categorias, são elas:
Algumas opções abrem uma lista com novas opções, por exemplo o evento “Mouse”, essas
são variações desse evento:
Mas não nos aprofundaremos nessas sub-categorias de funções, somente em algumas

delas, as quais usaremos com mais freqüência.
Create – Usado para iniciar as variáveis, todas as variáveis que serão usadas pelo objeto
ao longo do jogo, devem ser indicadas nesse evento para evitar problemas futuros.
Destroy – Quando o objeto for destruído executa um conjunto de funções.
Alarm – Indica que determinadas funções serão ativadas em algum momento do jogo, no
Game Maker 8 (versão que trabalhamos nessa apostila) existe 12 eventos Alarm, para
ativar um dele, tem o comando:
Alarm[n]=frames
Onde n é o número correspondente ao Alarm e o frames é a quantidade de frames até ele

acontecer, room_speed equivale a 1 segundo.
Step – Executa constantemente as funções adicionadas a ele, cuidados com as funções

adicionadas nele, pode ter resultados insatisfatórios.
Outside Room – Aciona as funções quando o objeto sair da room, quando não for mais
visível na janela do jogo.
Game Start – Ao iniciar o jogo, só será executado 1 vez na execução do jogo.

Game End – Ao sair do jogo, nesse evento comumente usamos funções para apagar
arquivos ou adicionar informações a ele.
Room Start – Quando a room iniciar, executa as funções, esse evento pode acontecer
mais de uma vez no jogo.
Room End – Ao sair da room, é acionado as funções inseridas nele.
Draw – Funções de desenho (Ver o capítulo Introdução ao Draw)
Press – Quando uma tecla for pressionada, esse commando tem 3 variações, Keyboard,
executa enquanto a tecla estiver pressionada, Keyboard Press, executa somente 1 vez
quando uma tecla for pressionada, Keyboard Released, executa quando uma tecla for
solta.
2. Variáveis globais
Variáveis globais guardam informações que o usuario escolhe. Essas informações são
salvas, podendo serem usadas em qualquer outra room. Por exemplo, o usuario escolhe
um personagem para jogar(é sobre isso que iremos trabalhar), ele clica no personagem, a
informação do personagem escolhido é guardado, e o personagem escolhido é usado em
outra room.
2.1 Onde usar?
Como é possível guardar informações escolhidas, é muito importante usá-las em seleções

de personagens, mudança dos controles de um jogo, criação de contas de usuário (mas
para isso é necessário também guardar as informações em arquivos INI, eu acho), entre
muitas outras coisas. Com isso é possível perceber como as Variáveis Globais são
poderosas tanto na criação de um jogo quanto na de um programa.
2.2 Nomeando variáveis globais
As variáveis globais sempre são nomeadas assim:
global.variavel
Crie um objeto. Chame-o de "pers_1". Crie o evento Other > Game Start. Agora digite o
seguinte código:
global.pers = 0;
Esse código irá setar a opção "defalt". (é tipo o que está selecionado antes do usuário
escolher)
Agora crie outro evento. O evento Mouse > Left Button. Digite o mesmo código citado
acima. Isso irá alterar o personagem selecionado para ele, se o outro estiver selecionado.
No mesmo evento, digite mais um código:
room_goto_next()
Crie outro objeto, e nomeie-o como "pers_2". Coloque o evento Mouse > Left Button,
coloque o seguinte código:
global.pers = 1;
Isso irá alterar o personagem selecionado para ele, se o outro estiver selecionado.
room_goto_next()
Coloque um sprite diferente para cada um desses objetos.
Crie dois objetos: o sel_1 e o sel_2. O sprite do sel_1 deve ser o sprite do pers_1, o sprite
do sel_2 deve ser do pers_2.
Crie outro objeto, chame-o de selecionador. nele digite o seguinte código:
if global.pers = 0 {
instance_create(1,1,sel_1) }
if global.pers = 1 {
instance_create(1,1,sel_2) }
Se a variável global (o item selecionado) for 0, criar objeto sel_1.

Se a variável global (o item selecionado) for 1, criar objeto sel_2.
Com isso ao escolher um personagem, ele será criado na room ao iniciar o jogo.
3. Introdução ao Draw
Sempre que usarmos alguma função desse grupo, devemos inseri-los dentro do evento
Draw, caso algum dessas funções sejam inseridas em outro evento, simplesmente não
funcionará. É bem parecido com a inicialização de variáveis, onde é preciso que ela seja
criada no evento create para depois ser modificada nos outros eventos.
Atenção: Ao iniciar um evento no Draw, a sprite aplicada ao objeto não será mostrada.
Veremos como resolver isso mais adiante.
As funções de desenho se iniciam sempre com “Draw_”, é possível fazer diversas coisas,
como desenhar um retângulo, uma linha, um triângulo, entre vários outros.
draw_point(x1,y1)
draw_rectangle(x1,y1,x2,y2,linha)
draw_triangle(x1,y1,x2,y2,x3,y3,linha)
draw_circle(x1,y1,raio,linha)
//Entre outros
3.1 Modificando cores
Quando trabalhamos com o draw, é possível modificar as cor de qualquer coisa que
tenhamos desenhado na tela, seja ele um texto, um triângulo ou um ponto! E é fácil, para
isso, usamos o código abaixo antes de escrever qualquer código de draw:
draw_set_color(cor)
Por padrão do Game Maker, se não for indicado esse comando, a cor dos elementos
desenhados na tela será preta. Para personalizar você pode colocar por exemplo uma
constante ou uma cor em hexadecimal. As cores pré-definidas são:
c_aqua //Azul piscina

c_black //Preto
c_blue //Azul
c_dkgray //Cinza escuro
c_fuchsia //Fúcsia
c_gray //Cinza
c_green //Verde
c_lime //verde limão
c_ltgray //Cinza Claro
c_maroon //Marrom
c_olive //Oliva
c_orange //Laranja
c_purple //Roxo
c_red //Vermelho
c_silver //Prata
c_teal //Azul
c_white //Branco
c_yellow //Amarelo
3.2 Draw Point
Esse comando é o mais básico do draw e não tem segredos. A estrutura do código é
basicamente essa:
draw_point(x,y)
No x colocamos sua posição horizontal e no y sua posição vertical. Esse comando só

desenha um ponto na tela, exatamente do tamanho de um pixel.
Como já foi citado, existe o comando draw_set_color que muda a cor dos comandos de
draw abaixo deste, estão, vamos fazer um teste, para que o ponto fique visível:
background_color=c_black
// muda a cor do background para preto
draw_set_color(c_white)
//muda para cor branca
draw_point(320,200)
//desenha um ponto na posição 320, 200
Agora coloque este código no evento draw de um objeto, insera-o na room e execute o
jogo, você perceberá um minúsculo ponto branco no centro da tela.
3.3 draw_line
Como o próprio nome sugere, serve para desenhar linhas com espessura equivalente a um
pixel.
draw_line(x1,y1,x2,y2)
Para entendermos como desenhar a linha exatamente no lugar onde queremos, é

necessário saber como os códigos funcionam. Em todos os códigos do draw, exceto o
draw_point, é preciso especificar duas extremidades. O draw_line é o mais fácil de
compreender, porque só precisamos "dizer" ao GM, as duas extremidades da linha e ele
faz o resto. Para isso é necessário saber como as coordenadas X e Y funcionam. Para
explicar melhor, abaixo uma esquematização:
Como mostrado na imagem, os dois primeiros argumentos do script x1 e y1 representam a

posição x e y da primeira extremidade da linha, o mesmo com x2 e y2, que representam o
x e y da segunda extremidade da linha.
Existe também, uma versão mais avançada dessa função, o draw_line_color, onde são
informados também, duas cores, aplicando em suas extremidades.
É possível configurar a largura da linha, mas não com uma função padrão do Game Maker,
o seguinte código expressa o que acontece (o comando For será explicado mais a frente)
for (linha=0;linha<3;linha+=1) {
draw_line_color(mouse_x+linha,mouse_y+linha,10+linha,10+linha,
c_red,c_green) }
/*linha com a espessura 3 do ponto (10,10) ate o mouse com a
gradação da cor vermelha ate a verde*/
O resultado será uma linha assim:
3.4 Draw Rectangle
O draw_rectangle, desenha um retângulo e seu funcionamento é muito parecido com o da

linha. Assim como a maior parte das funções do draw, nesta definiremos 2 coordenadas.
Esses pontos correspondem às duas extremidades do retângulo.
draw_rectangle(x1,y1,x2,y2,linha)
Os argumentos x1 e y1 servem para colocarmos as coordenadas da extremidade superior

esquerda e os argumentos x2 e y2 servem para colocarmos as coordenadas da
extremidade inferior direita do retângulo.
Dentre os dois pontos (extremidades) que colocamos no código, o Game Maker

desenhará, interligando-as em ou retângulo. O argumento linha indica se você quer
desenhar somente a linha externa (True ou 1) ou se quer que seja preenchido (False ou 0)
draw_rectangle(10,10,110,110,1)
draw_rectangle(24,48,84,108,1)
Nesse caso o resultado será:
É possível mudar a cor dessa linha, colocando-se o draw_set_color(cor) antes do código.

No entanto, existe uma função mais avançada do draw_rectangle que o permite customizá-
lo mais, preenchendo com 4 cores juntas.
draw_rectangle_color(10,10,110,110,cor1,cor2,cor3,cor4,1)
Cada argumento cor representa uma ponta do retângulo:
cor1: Ponta superior esquerda

cor2: Ponta superior direita
cor3: Ponta inferior direita
cor4: Ponta inferior esquerda
Por exemplo:
//Exemplo 1
draw_rectangle_color(0,0,150,150,c_red,c_white,c_green,c_purple,0)
//Exemplo 2
draw_rectangle_color(0,0,150,150,c_red,c_white,c_green,c_purple,1)
Exemplo 1 Exemplo 2
3.5 Draw Circle
draw_circle(x,y,raio,linha)
draw_ellipse(x1,y1,x2,y2,linha)
draw_set_circle_precision(precisao)
O draw_circle é o mais fácil de se compreender. Esse, por sua vez, desenha um círculo
perfeito, nada de algo oval como uma elipse.
x - Posição vertical do centro do círculo;

y - Posição vertical do centro do círculo;
raio - O raio do círculo em pixels;
linha - Determina se o círculo será preenchido ou não.
Por exemplo:
draw_circle(100,100,10,0)
Resultado:
O draw_ellipse é um pouco mais complicado, mas nem tanto, basicamente, você desenha
um retângulo invisível, e o GM por sua vez, desenha a elipse coerente com as laterais
desse retângulo. E já sabemos como desenhar um retângulo:
E finalmente o draw_set_circle_precision, essa função é muito interessante. Ela serve para

nos mostrar o quão preciso será a resolução do círculo. Um número menor, como 0 por
exemplo, torna o círculo um retângulo, quanto maior esse número, por exemplo 100, mais
redondo o círculo ficará. Deve-se colocar essa função antes de desenhar um círculo e
colocar o valor de precisão em precision.
Veja a diferença entre o valor 10 e o valor 100:

//Exemplo 1
draw_set_circle_precision(10)
//Exemplo 2
Exemplo 1 Exemplo 2
Como a maioria das funções do draw, o draw_circle e o draw_ellipse possuem também

versões para inserir cores, é o draw_circle_color e o draw_ellipse_color, são muito
semelhantes aos outros exemplos com cores:
draw_circle_color(100,100,10,c_green,c_red,0)
4. Introdução aos loops

Em algumas situações, vemos a necessidade de usar funções repetitivas, seja pra
desenhar uma lista ou pra verificar objetos na tela e em algumas dessas não é possível
fazer utilizando-se de comandos simples, como o popular IF. Visando dar uma base para
novas tentativas, pretendo explicar como funcionam os principais comandos de repetição:
For, While e Do Until (Para, Enquanto e Faça Até Que).
4.1 For
É mais usado quando sabemos a quantidade exata de vezes que será executado, é
recomendado pra variáveis seqüênciais, responsável por localização na tela, mudança de
variáveis entre outros.
O for comporta-se da seguinte maneira:

for (inicio; condição; inclemento) { comando }
Você inicia uma variável em início, como pos=1, condição é responsável por garantir que o
loop continue (pode ser pos<=10), se for uma condição verdadeira (true) o for continua e
inclementa (pos+=1), porém se for falso (false), não faz nada e reinicia a variável de início
(pos=1).
No exemplo, vou desenhar na tela uma tabela com os 10 nomes do highscore:
for (pos=1; pos<=10; pos+=1) {

draw_text(x,y+pos*20,string(pos)+". "+highscore_name(pos))}
Comentando:
Aqui foi indicado que cada a posição vertical do texto varie conforme o valor de pos,
evitando que o texto fique sobreposto.

Parte responsável por inserir a posição na lista, cada posição terá sua indicação, ficaria
assim: "1.", "2.", "3." etc.

E finalmente aqui, o nome de cada posição é colocado na frente da sua respectiva

colocação. O resultado final será uma tabela com os nomes dos 10 melhores jogadores em
ordem e numerado de 1 a 10.
4.2 While
É bastante usado pra repetições grandes, ou até infinitas, usado para executar comandos
enquanto uma determinada condição for verdadeira. O comando while não é muito
recomendável quando se quer controle, como posição.
O comando While pode ser resumido com:

while condição { comando }
Por exemplo:
while instance_number(obj_inimigo)<100 {
instance_create(random(room_width),random(room_height),obj_inimigo)
}
Nesse exemplo, sempre haverá 100 inimigos na room.
4.3 Do Until
É bastante similar ao comando While, porém funciona de forma diferente, ele executa
funções até que a condição seja verdadeira.
Sua sintax é:
do {
comando
}
until condição
Por exemplo, eu tenho um jogo, onde a vida do meu personagem se regenera sozinha,
porém, bastante lenta, eu poderia resolver com o Do, assim:
do {
vida+=0.01;
}
until vida<100
Nesse exemplo, será executado "vida+=0.01" até que a condição "vida<100" seja falsa.
5. Movimentação básica em plataforma

Primeiramente, deveremos criar a nossa gravidade, para isso abra o objeto do
personagem, crie um evento Step e coloque o seguinte código:
if place_free(x,y+2) gravity=1
//Se estiver livre de colisoes 2 pixels abaixo, a gravidade sera 1
else //caso contrario
gravity=0 //a gravidade será 0
Agora sim começaremos a movimentação, primeiramente faremos o personagem andar

para a direita caso a tecla "direita" seja pressionada, para isso abra novamente nosso
código Step do objeto do personagem, e adicione o seguinte:
if keyboard_check(vk_right) //Se a tecla direita for pressionada

{
if place_free(x+5,y){ x+=5 } /*e se estiver livre de colisoes 5
pixels a frente, andara 5 pixels para frente*/
sprite_index=spr_player_dir
} //o sprite mudara para spr_player_dir
Agora faremos com que o personagem ao andar para a esquerda caso a tecla "esquerda"
seja pressionada, para isso adicione isso ao código do Step do nosso personagem:
if keyboard_check(vk_left) //Se a tecla esquerda for pressionada

{
if place_free(x-5,y){ x-=5 } /*e se estiver livre de colisões 5
pixels atras, voltara 5 pixels*/
sprite_index=spr_player_esq
} //e o sprite mudará para spr_player_esq
Pronto, agora nosso personagem já anda para a direita e esquerda, agora faremos com
que nosso personagem pule, no evento Step do nosso personagem:
if keyboard_check_pressed(vk_up) //Se a tecla cima for pressionada

{ if !place_free(x,y+2){ vspeed=-12 }}
Nossa movimentação está feita! Agora para o personagem não passar pelos blocos, no
objeto do bloco marque a opção "Solid" e no objeto do personagem, no evento Collision >
objeto do bloco adicione o código:
move_contact_solid(direction,12)
speed=0
Para maiores informações, veja a engine desse capítulo, arquivo mov_plataforma.gmk.

6. Movimentação básica em TopDown

6.1 Introdução
TopDown é um estilo bem comum de jogos, a tradução é ‘visão para baixo’, ou seja a
câmera fica de cima, visualizando os objeto, compondo o cenário como um todo, jogos
nesse estilo são bem usuais pois permitem trabalhar com uma infinidade de jogos além de
fazer efeitos e usar recursos que tornam o jogo bem divertido.
6.2 Desenhando um carrinho básico
A primeira coisa que faremos é desenhar um carrinho, que é muito simples, até porque, em
jogos Top-Down não há necessidade de desenhar gráficos para todas as posições do
carro. Primeiramente crie um sprite, nomeie-o como quiser, depois clique em Edit Sprite,
crie uma nova imagem com 24x16, como a seguir:
Agora clique duas vezes na imagem e abrirá o editor, ponha Zoom 800% e siga os
templates:
1. Faça um retângulo
2. Faça o desenho das rodas
3. Dentro dele faça outros dois, na vertical, que são os vidros do carro
Para seu carro ficar menos "quadradão", faça como nas imagens abaixo:
1. Tire as pontas
2. Ponha fárois
3. Pinte-o como preferir
Resultado:
6.3 Criando o objeto do carro
Crie o objeto do carro, ponha como sprite o que você criou, no evento Create, arraste o
Execute Code para as ações, dentro dela coloque o seguinte:
vel_maxima = 6
Define qual a velocidade máxima que o carro poderá atingir.
aceleracao = 0.2
Define a aceleração do carro, quanto maior, menos tempo levará para alcançar a
velocidade máxima.
freio = 0.2
Define a força do freio do carro, quanto maior, menos tempo ele levará para atingir 0
quando estiver freiando.
curva = 2.5
Define a curva do carro, quão maior, mais rápido ele curvará.

friction = 0.07
Define quanto tempo ele levará para atingir velocidade 0 quando não estiver acelerando.
No todo ficará assim:
vel_maxima = 6
aceleracao = 0.2
freio = 0.2
curva = 2.5
friction = 0.07
Você pode modificar e deixar como quiser.
Para que as váriaveis criadas acima tenham utilidade, você deve criar o script principal,
para isso, no evento Step, arraste o Execute Code para as ações. Dentro dele deve-se
colocar isso:
if keyboard_check(vk_left) && speed != 0

{image_angle += curva}
O que simplesmente fizemos foi, checar se a tecla esquerda (vk_left) foi pressionada e a
velocidade (speed) do carro é diferente de 0 (Pois um carro não pode virar parado), se sim,
o ângulo da imagem (image_angle) aumentará pela var curva do carro, que definimos no
create.
if keyboard_check(vk_right) && speed != 0 {

image_angle -= curva}
Aqui o o contrário, verificamos se a tecla direita foi pressionada e o speed diferente de 0,

se sim, image angle é subtraído pela curva do carro.
direction = image_angle
Sem isso, o ângulo da imagem mudará, mas o carro continuará andando na mesma
direção.
if keyboard_check(vk_up)
{if speed < vel_maxima{speed += aceleracao}}
Agora checamos se a tecla pra cima foi pressionada, se sim, checamos se a var speed é
menor que a var velocidade máxima (Assim, impedindo que passe do limite), se sim,
aumentamos a var speed pela var aceleração.
if keyboard_check(vk_down)
{if speed > vel_maxima*-1/2{speed -= freio}}
Agora checamos se a tecla baixo foi pressionada, se sim, checamos se a var speed é
maior que a var velocidade máxima multiplicada por -1 dividida por 2 (Se no caso,
velocidade máxima é 6, a negativa é -3), se sim, a var speed é subtraída pela var freio.
Tudo junto:
if keyboard_check(vk_left) && speed != 0

{image_angle += curva}
if keyboard_check(vk_right) && speed != 0
{image_angle -= curva}
if keyboard_check(vk_up)
{if speed < vel_maxima{speed += aceleracao}}
if keyboard_check(vk_down)
{if speed > vel_maxima*-1/2{speed -= freio}}
6.4 Criando pistas por tiles
Agora, faremos uma pista usando tiles, para criar um tile é simples, mas antes criaremos o
background (o chão da room). Vá em Background e crie uma grama, se não souber como,
baixe a imagem abaixo:
Clique em Load Background e escolha o gráfico da grama. Não se esqueça de deixar a

caixa Use as tile set desmarcada.
Nossa pista terá medida de 128x128. Abra o Paint (ou qualquer programa do tipo) e crie
uma imagem, seu tamanho deverá ser de 128x128, como abaixo:
Vá em Resize e dobre o tamanho, para 256x256, agora crie um círculo na imagem, com as
cores que deseja para a pista:
Salve-o, o nome pode ser qualquer um, por exemplo, curvas.
Agora vamos às retas, crie imagens de 128x16 e 16x128, recomendo baixar as de baixo:
Agora no seu projeto, crie um Background, carregue a imagem do círculo, tire o fundo
branco em Image > Erase a Color, e marque a opção Use as tile set, e divida por 4, como
abaixo:
Resultado final:
7. Recursos externos
É relativamente fácil usar recursos externos em seus jogos, fazendo-os de forma mais
profissional e dinâmica.
Observação: Ao usar recursos externos lembre-se que mudanças externas podem ser
feitas por qualquer um, entretanto jogos com a possibilidade de modificação de alguns
recursos, podem fazer surgir layouts personalizados, playlist de músicas a escolha do
jogador entre outros.
As principais funções para manipulação de arquivos externos são:
//Musica e efeitos sonoros

sound_add()
sound_replace()
sound_delete()
//Backgrounds e imagens fixas

background_add()
background_replace()
background_delete()
//Sprites
sprite_add()
sprite_replace()
sprite_delete()
Eu recomendo usar o comando _add() para uso geral, no qual não existe a imagem no
source, dependendo exclusivamente do arquivo externo, o _replace() é recomendado
quando se tem uma imagem padrão caso não exista o arquivo e _delete() pra liberar a
memória do jogo, fazendo-o assim ficar mais rápido. Em geral dominar essas funções com
perfeição e harmonia requer estudo, tentativas e principalmente dedicação.
Esses comandos são muito bons para arquivos grandes, como músicas no formato mp3 ou
wav, imagens de fundo etc.
7.1 Arquivos de som
Pra começar vou carregar uma música apartir de um arquivo e então executá-la. No evento
Create (deve ser nesse evento, caso constrário o arquivo seria carregado eternamente,
travando o jogo):
dir_mus1=working_directory+"\musica.mp3"
if file_exists(dir_mus1) {
musica1=sound_add(dir_mus1,3,1)
if !sound_isplaying(musica1) sound_play(musica1)}
Nesse caso o jogo carrega o som na variável musica1 somente se o arquivo existir e toca
somente se a música já não está. O 3 representa o tipo de som, deve ter muito cuidado,
pois dependendo do formato, não funcionará corretamente. Os tipos são:
0 Sons normais (como explosões, clicks, pulos etc) geralmente no formato .wav
1 Música de fundo, formatos mid
2 Sons 3D (outro tipo de configuração)
3 Reprodução externa (como o mmplayer), formatos wma e mp3
sound_replace(snd_musica1,dir_mus1,3,1)
Tem a mesma finalidade da função anterior, porém agora será substituído o som
snd_musica1 pelo arquivo no diretório.
Em um evento qualquer, você pode indicar para liberar a memória desse arquivo, por
exemplo, Alarm[0], colocando:
if !sound_isplaying(musica1) sound_delete(musica1)
7.2 Imagens/backgrounds
Muito útil quando você pretende lançar diferentes layouts pro jogo, mudando muitas vezes
somente o background, isso abre uma enorme ramificação de possibilidades.
Seu funcionamento é muito semelhante aos sons, porém requer um pouco mais de
atenção, já que as imagens devem ter o tamanho da tela e "encaixar" no designer do jogo,
do contrário você terá um resultado "feio" visualmente.
dir_fnd1=working_directory+"\fundo.png"
if file_exists(dir_fnd1)
fundo1=background_add(dir_fnd1,0,1)
background_index[0]=fundo1
Eu indiquei um background para o jogo apartir de um arquivo (lembre-se de ativar o "Visible

when room starts" em "Background 0" nas configurações da room).
Para descartar um background, você pode indicar uma mudança de room, fica a critério,
basta inserir:
background_delete(fundo1)
7.3 Sprites
dir_sp1=working_directory+"\sprite.png"
if file_exists(dir_sp1)
sprite1=sprite_add(dir_sp1,0,0,0,0,0)
sprite_index=sprite1
Trabalha somente no objeto em que o código está, no caso será adicionado uma nova
sprite e a anterior (caso exista) será descartada.
Cuidado ao descartar uma sprite (sprite_delete), você deve indicar uma nova caso
contrário não será mostrado nada.
8. Janelas Dinâmicas
8.1 Janelas com Informações
Várias vezes, durante o desenvolvimento de um jogo, nos deparamos com um problema,

as janelas do jogo, é possível usar a função do Game Maker show_message ou
get_integer, só que por mais customizável que elas são, não fica bom, eu evito
particularmente evito usar essas funções por quase nunca combinarem com o jogo. É
possível fazer essas janelas com GML, assim abrindo uma imensa gama de possibilidades,
como efeitos, opções, customização etc, basta saber aproveitá-las.
É até simples trabalhar com janelas dinâmicas, em geral é saber posicionamento e
configurar corretamente a coordenada da origem das sprites.
Pra começar, é sempre bom saber o que você pretende fazer, a posição das janelas etc,
pra quem estar iniciando, é recomendável fazer efeitos simples, mais "quadrados", pois
ajuda a respeitar a posição, mas com o tempo você vai posicionar no olho.
Essa é a área que eu vou trabalhar, é uma imagem de 324x191 pixels, separada em
pequenos quadrados de 10 pixels.
A segunda parte é determinar a área das informações que serão adicionadas nessa janela,
como feito na imagem abaixo:
Feito isso, você atribui algum efeito, imagem de fundo, colorização, enfim, essa parte vai
da criatividade de cada um, nesse caso eu fiz uma montagem bem simples, no próprio
editor de sprites do Game Maker, embora simples, ficou bem agradável.
Se você quiser adicionar textos na janela, fica mais fácil pro jogador identificar o que está
contido nas regiões, no meu caso eu vou colocar só "Informações", "Dragão" e
"Personagem", que vai mostrar informações de um RPG (um exemplo):
Informações
Você está no reino de Dacrons. Encontre o treinador do centro da cidade para que ele te
ajude a treinar seu novo dragão.
Personagem
Dragão Glacial
XP: 278/350
Dragão
(Poderia ser uma imagem fixa, mas no caso o dragão será mudada ao passar do jogo, por
isso tem que ser uma imagem separada)
Finalizamos então a parte gráfica da janela, entra agora a programação. Será usado
somente 1 objeto, assim fica mais fácil atribuir efeitos de movimento, fade, ou qualquer
outro.
No evento Create do objeto, temos que identificar as variáveis que será usada na janela,
no caso são:
tahoma=font_add("Tahoma",8,0,0,32,127)
tahoma_n=font_add("Tahoma",8,1,0,32,127)
//As fontes da janela
nome_dragao="Dragao Glacial"
exper_atual=278
exper_max=350
img_dragao=sp_glacial
//Personagem
some=0
msg_missao_atual="Voce esta no reino de #Dacrons.##Encontre o

treinador do #centro da cidade para que #ele te ajude a treinar
seu #novo dragao."
//Missao atual
Essas variáveis são fixas, mas em um jogo elas devem se direcionadas para ler as
informações ao decorrer do jogo. Mudando a missão, a experiencia etc.
Com as variáveis já fixadas, vamos para o evento Draw, que é onde toda a "mágica" é
feita, primeiro vamos mostrar a janela do jogo (é uma sprite chamada sp_janela).
draw_sprite_ext(sp_janela,0,x,y,1,1,0,c_white,image_alpha)
//será mostrada na posição que for colocada na tela
draw_sprite_ext(img_dragao,0,x+209,y+19,1,1,0,c_white,image_alpha)
//agora a imagem do dragão, na área que ele deve aparecer
Atenção: Com o tempo vai ser muito mais fácil determinar a posição dos itens na janela,
uma solução fácil e rápida, é você colocar a janela na posição 0x0 dentro da room e usar
uma função no mouse, pra mostrar a posição X e Y atual:
draw_text(mouse_x,mouse_y,"x="+string(mouse_x) + " y=" +

string(mouse_y))
Com isso você sabe o valor que deve ser adicionado a X e Y da janela para que fique no
lugar correto.
Falta agora as informações em texto:
draw_set_font(tahoma)
draw_set_halign(0)
draw_text_color(x+26,y+24,msg_missao_atual,c_white,c_silver,c_white,
c_ltgray,image_alpha)
//As informações sobre a fase
draw_set_font(tahoma_n)
draw_text_color(x+217,y+138,nome_dragao + "#XP: " +
string(exper_atual)+ "/" +
string(exper_max),c_white,c_silver,c_white,c_ltgray,image_alpha)
//As informações do personagem
8.2 Adicionando o efeito fade in/out
No evento create eu coloquei uma variável (some=0) que eu não havia explicado pra que
seria usada, pois bem, ela entra agora.
No evento Step:
if keyboard_check_pressed(ord('S')) some=1
if keyboard_check_pressed(ord('A')) some=0
if image_alpha<1 and some=0 image_alpha+=0.05
if image_alpha>0 and some=1 image_alpha-=0.05
Esse código fará com que ao pressionar a letra S do teclado, a janela desaparece e ao
apertar A ela reaparece, é um efeito bem simples, mas bem ocasional, pode ser usado em
diversos tipos de jogos.
Por fim, o resultado final será:
Você pode ver a engine desse tutorial, o arquivo é jan_dinamica.gmk.
8.3 Janela com botões
Agora vou mostrar como posicionar botões de opção, bem parecido com o esquema
padrão do Windows. Um janela com Ok, Ok/Cancelar e Sim/Não.
Antes de tudo, vamos criar a janela, o esquema é o mesmo do outro, fazer primeiramente
um layout, só pra posicionar corretamente os itens nela.
Esse é o espaço que será usado para criar a janela, existem diversos programas
especializados para edição e criação de imagens como GIMP e Photoshop, mas é possível
fazer no próprio editor de imagens do Game Maker.
O próximo passo é determinar a região onde será disposto o texto e os botões.
Feito isso e usando seu editor de imagens preferido, crie uma janela com alguma imagem
de fundo, com algum efeito, sombra, iluminação, enfim, aqui a sua imaginação manda.
Nesse exemplo eu fiz um efeito bem simples de metal, com uma textura bem leve, combina
com vários tipos de jogos. O espaço da mensagem da janela eu destaquei para diferenciar
das outras áreas, mas fica a critério de cada um, eu particularmente gosto de efeitos assim,
são simples, mas muito agradáveis.
A mesma coisa foi feita com os botões, colocando o mesmo efeito, mas em um tom
diferente, a terceira imagem é a segunda invertida horizontalmente e verticalmente (textura
aplicada depois).
Ao enviá-las para o Game Maker, configure a região de origem dessas sprites, do botão
para 29x10 e da Janela para 133x46, como mostrado nas imagens abaixo:
Como exemplo, as 3 janelas que serão criadas nesse tutorial são:
Botão: Ok
Texto: "Para que as configurações sejem aceitas, é necessário reiniciar o Jogo."
Botão: Ok/Cancelar
Texto: "Você tem certeza que deseja encerrar o aplicativo? Seu jogo será perdido."
Botão: Sim/Não
Texto: "O arquivo selecionado já existe. Deseja substituir?"
Terminado a parte gráfica, vamos agora para a programação.
Em um novo objeto, chamado botao_ok, será configurado as opções da sprites no Mouse

Left Pressed, Mouse Left Released, Mouse Enter e Mouse Leave, pra respectivamente
image_single=2, image_single=1, image_single=1 e image_single=0. E no evento create
será indicado somente:
image_single=0
//Faz com que o objeto inicie com a sprite parada
//Seta a fonte usada no objeto
No evento Draw inserimos:
//Chama a fonte tahoma_n
draw_set_halign(1)
//Alinhamento horizontal no centro (1)
draw_set_valign(1)
//Alinhamento vertical no centro (1)
draw_sprite_ext(sprite_index,image_single,x,y,1,1,0,c_white,
image_alpha)
//Mostra a sprite do botao
draw_text_color(x+1,y,"Ok",c_gray,c_silver,c_gray,c_silver,
image_alpha)
draw_text_color(x,y-1,"Ok",c_black,c_dkgray,c_black,c_black,
image_alpha)
//Mostra "Ok" em preto com uma sombra cinza
O mesmo com os botões Cancelar, Sim e Não, no Gm é possível duplicar um objeto, o que
ajuda bastante, mas lembre-se de alterar o texto que será mostrado no Botão, substituindo
por "Cancelar", "Sim" e "Nao" respectivamente.
É necessário agora fazer um novo objeto, com a sprite da janela para controlar os botões e
posicioná-los corretamente.
No evento Create desse novo objeto:
instance_create(x,y,botao_ok)
//Cria o botao iniciar
instance_create(x,y,botao_cancelar)
//Cria o botão Cancelar
//Seta a fonte do objeto
mensagem="Voce tem certeza que deseja#encerrar o aplicativo?##Seu

jogo sera perdido."
//Determina a mensagem a ser mostrada
Ao criar os botões eles serão posicionados na posição X e Y da janela, mas não estão
alinhados, isso será feito no evento Step desse objeto:
with instance_nearest(x,y,botao_ok) {
x=other.x-80
y=other.y+61 }
/*Com o objeto botao_ok mais próximo, posicione
em -80 e +61.*/
with instance_nearest(x,y,botao_cancelar) {
x=other.x+80
y=other.y+61 }
/*Com o objeto botao_cancelar mais proximo,
posicione em +80 e +61.*/
E no evento Draw quase a mesma coisa do objeto botão:
//Define a fonte
draw_set_halign(1)
draw_set_valign(1)
//Alinhamento horizontal e vertical no centro (1)
draw_sprite_ext(sprite_index,image_single,x,y,1,1,0,c_white,
image_alpha)
//Desenha a sprite da janela
draw_text_color(x,y,mensagem,c_black,c_dkgray,c_black,c_black,
image_alpha)
//Desenha o texto na janela
Pra posicionar um botão no centro:
with instance_nearest(x,y,botao_ok) {
x=other.x
y=other.y+61 }
As outras janelas são exatamente a mesma coisa, só muda o texto e o botão delas, é
possível fazer algum efeito de movimento ou de Fade in/out (como feito no tutorial anterior),
tornando-as mais profissional. O grande diferencial dessas janelas é que elas não
interferem no funcionamento do jogo e é possível atribuir uma grande gama de
possibilidades.
E finalmente o resultado será:

Veja jan_dinamicas2.gmk para entender melhor essa parte do tutorial.
Observação: A engine tem as 3 janelas concluídas, separadas em rooms diferentes, ajuda

no estudo, pra colocar as funções desejadas, basta inserí-las no evento "Mouse Released",
como game_end(), room_goto_next(), depende da situação.
8.4 Inserir Dados
Essa parte do tutorial será a mais usada provavelmente, pode ser usada quando o jogador
perde, para adicionar no Highscore do jogo, ou em um jogo multiplayer onde é necessário
inserir dados como Nick, IP etc. Ou até mesmo para usar em um chat em um jogo online,
tem diversas utilidades.
Atenção: É essencial seguir esse tutorial com a engine aberta, algumas funções será mais
bem entendidas se for feito um acompanhamento (jan_dinamicas3.gmk).
Novamente vamos usar a grade separada em pequenos quadrados, nesse exemplo eu vou
fazer uma janela para conexão de um jogo multiplayer, haverá 3 áreas para inserir dados
(Nick, Seu IP e Conectar ao IP) e 3 botões (Conectar e Cancelar), sobre os botões, foi visto
no exemplo anterior (Janelas com botões), por tanto não vou me aprofundar tanto nessa
parte do tutorial.
O padrão é o mesmo, distribuindo regularmente a posição das regiões em uma área

quadriculada, impede os erros de simetria e alinhamento.
Pra finalizar eu usei uma textura de rochas e as áreas de dados um prateado bem discreto
e na janela um sombreamento bem claro (feito no editor do Game Maker), nesse exemplo
eu inseri os botões direto na janela, diferente do exemplo anterior, onde eram sprites, isso
facilita um pouco, mas impede que os botões sejem modificados de posição mais tarde.
Barra para inserir dados
Os botões
Em relação ao exemplo anterior, sobre os botões, esse terá novas características, o

funcionamento é o mesmo, usando os eventos Left Pressed, Mouse Enter etc, no caso o
botão Conectar vai acender verde quando apontar para ele e o botão Cancelar vermelho, é
um efeito bem discreto, mas que fica muito bom.
O draw do objeto botão Cancelar:
if image_single=0
draw_text_color(jan_mplayer.x+208,jan_mplayer.x+107,"Cancelar",
c_black,c_dkgray,c_black,c_black,image_alpha)
else
draw_text_color(jan_mplayer.x+208,jan_mplayer.x+107,"Cancelar",
c_red,c_red,c_black,c_red,image_alpha)
E do botão Conectar:
if image_single=0
draw_text_color(jan_mplayer.x+208,jan_mplayer.x+68,"Conectar",
else
draw_text_color(jan_mplayer.x+208,jan_mplayer.x+68,"Conectar",
c_lime,c_green,c_black,c_green,image_alpha)
Traduzindo, se o mouse estiver em cima do botão (image_single diferente de 0) a cor do

texto será vermelho (ou verde, se for o botão conectar).
A localização dos pontos foram feitas de forma diferente, nesse exemplo eu criei um objeto,
e no evento draw dele eu coloquei uma função para mostrar a localização do pontos X e Y,
então eu os posicionei no lugar correto, onde deverão aparecer, facilitou bem mais do que
a técnica anterior, onde a função para mostrar a coordenada era inserida no mouse_x e
mouse_y, o resultado foi esse:
Com a origem da janela em 0x0 e na posição 0x0 na room, esse é o valor que eu terei que
somar ao x e y da janela, para posicionar corretamente. Os valores seguidos no tutorial são
esses ai.
No evento Create do objeto jan_mplayer, foi indicado várias variáveis, as globais são o
texto que estamos modificando, são: o nick, o ip e o ip para conectar, no caso eu coloquei
uma função para detectar o ip da máquina, esse número você indica ao seu amigo para
jogar em modo multiplayer e o outro ip, é um string fixa, com o ip zero da máquina
(127.0.0.1).
instance_create(x,y,botao_conectar)
instance_create(x,y,botao_cancelar)
instance_create(x,y,barra1)
//Cria os botoes e as regioes do texto
lucida=font_add("Lucida Console",8,0,0,32,127)
global.nick="Fuzenrad"
global.seuip=mplay_ipaddress()
global.conectar="127.0.0.1"
maximo=15
//Quantidade maxima de caracteres
cursor="|"
t=1
alarm[0]=5
escolhe=0
Eu optei por substituir a fonte pela Lucida Console, pois é uma fonte em que o tamanho
físico que cada letra ocupa é indiferente de que letra seja (W ou l), isso possibilita alinhar
corretamente e determinar o espaço para o número de caracteres.
Para permitir a edição de um texto, eu criei o seguinte código:
if keyboard_check_pressed(vk_backspace)
global.nick=string_delete(global.nick,string_length(global.nick),1)
if maximo-string_length(global.nick)>0 {
if keyboard_string!="" {
global.nick=string_insert(keyboard_string,global.nick,string_length(
global.nick)+1)
keyboard_string="" }} else
keyboard_string=""
É muito simples, ele só apaga o texto (com a tecla Backspace), ou insere, não é possível
copiar, colar ou selecionar, eu poderia ter me baseado em algum exemplo por ai, mas é
bastante extenso as funções para realizar isso, e acredito que para um tutorial, somente a
função básica de edição de texto já é muito útil (que é apagar e escrever).
Nos 3 objetos da área para inserir texto, ao clica, ele altera o valor da variável jan_mplayer
escolher, para assim selecionar qual janela o cursor irá editar (caso contrário, teríamos um
resultado indesejado).
O evento draw do objeto jan_mplayer é responsável por mostrar todos os itens da janela,
organizando-os de forma mais fácil.
draw_set_font(lucida)
draw_set_halign(0)
draw_set_valign(1)
draw_sprite_ext(sprite_index,image_single,x,y,1,1,0,c_white,image_al
pha)
if escolhe=1 {
mostra_nick=global.nick+cursor } else
mostra_nick=global.nick
if escolhe=2 {
mostra_ip=global.seuip+cursor } else
mostra_ip=global.seuip
if escolhe=3 {
mostra_conectar=global.conectar+cursor } else
mostra_conectar=global.conectar
draw_text_color(jan_mplayer.x+28,jan_mplayer.y+30,mostra_nick,
draw_text_color(jan_mplayer.x+28,jan_mplayer.y+68,mostra_ip,
draw_text_color(jan_mplayer.x+28,jan_mplayer.y+108,mostra_conectar,
No caso da variável cursor, o evento Alarm é responsável por alterar entre "|" e "" (vazio),
se código é:
switch t=0
{
case 0:{cursor="|" t=0} break;
case 1:{cursor="" t=1} break;
}
alarm[0]=5
Ele alterna a variável t, e para o resultado 0, mostra o cursor, para o resultado 1, oculta.
E por fim, o evento Destroy, é responsável por destruir todos os objetos relacionados a
janela, evitando problemas futuros.
with instance_nearest(x,y,botao_conectar) {
instance_destroy()}
with instance_nearest(x,y,botao_conectar) {
instance_destroy()}
with instance_nearest(x,y,barra1) {
instance_destroy()}
instance_destroy()}
instance_destroy()}
O resultado final, creio eu, foi o melhor dos outros 2 exemplos, o botão ficou bem
personalizado com coloração, com esse sistema é possível fazer, como eu já citei, a área
onde será inserido o nome do jogador para adicionar em um highscore, ou no menu
principal, uma janela pro jogador informar o nome, não sei, fica a critério.
8.5 Efeitos com janelas
Para não estender muito essa parte do apostila, vou pular uma parte da criação das
janelas, pode ser visto em Janelas com botões.
O resultado final foi esse:
O efeito do texto do botão pode ser visto em Draw Text.
8.5.1 Janela móvel
É um recurso muito legal, não só para janelas, mas para objetos em geral do jogo,
dependendo claro do fundamento do jogo, entretanto mover um objeto não é apenas
atribuir x=mouse_y e y=mouse_y no evento Left Button, isso faz com que o objeto "salte"
para a posição do mouse e deve ser evitado.
Para mover de forma correta, é preciso criar uma variável com a posição "relativa" do
objeto ao mouse, onde a diferença das posições é que será adicionada ao objeto quando
este for clicado, dessa forma, seja qual for a área do objeto que você clicar, ele move
considerando-o como ponto de origem.
Só explicando, posição relativa é a diferença entre a posição do objeto e a posição a qual

comparamos, no caso mouse_x e mouse_y:
x_relativo=x-mouse_x
y_relativo=y-mouse_y
Atribuimos isso ao evento Step, para que seja uma variável atualizada.
Agora em um evento do mouse, por exemplo Left Buttom:
x=x_relativo+mouse_x
y=y_relativo+mouse_y
Para mover vários objetos ao mesmo tempo, temos que usar a função with, que controla
outros objetos:
with instance_nearest(x,y,botao1) {
x=other.x-80
y=other.y+75 }
Com o objeto botao1 mais próximo, mova-o, ao mesmo tempo que o botão é corretamente
posicionado na janela.
Veja jan_movel1.gmk.
8.5.2 Efeito Fade In/Out
É um efeito simples, mas bem usual, para aplicá-lo, basta controlarmos a variável
image_alpha e atribuí-la a todos os objetos envolvidos ao objeto.
No evento Create indicamos:
image_alpha=-0.5
apaga=0
A variável image_alpha inicia em -0.5 para que tenha uma diferença entre a criação e o
surgimento dela na tela, bem mínima, milisegundos. E iniciamos a variável apaga, que
usaremos mais adiante.
Do mesmo modo que fizemos no exemplo anterior, controlando objetos com o with, mas
desta vez com o image_alpha:
if image_alpha<1.5 and !apaga{

image_alpha+=0.05
with instance_nearest(x,y,botao1) image_alpha=other.image_alpha}
if image_alpha>0 and apaga{

image_alpha-=0.05
with instance_nearest(x,y,botao1) image_alpha=other.image_alpha}
Quando a variável apaga for true (ou 1) e image_single for maior que zero ou quando
apaga for false (ou 0) e image_single for menor que 1.5, a janela desaparecerá e
aparecerá respectivamente.
No evento Left Released do objeto botao1, adicionamos:
jan_movel.apaga=1
Para indicar que ao ser pressionado a janela desapareça.
Confira a engine jan_fadeinout.gmk.
8.5.3 Movimento horizontal
Faz a janela surgir da esquerda até estar na posição que ela foi criada.
Seu funcionamento é igualmente semelhante ao fade, mas variando a posição x do objeto,

no evento Create deve indicar qual era a posição inicial, guardando-a em uma variável para
então mové-la para uma posição não visível na janela:
x_antigo=x
move=1
x=room_width+150
Lembrando que room_width é a largura da room e 150 é aproximadamente a metade da

largura do objeto, assim o objeto salta para uma posição fora da janela, para então se
mover.
Para finalmente mover a janela, no evento Step usamos:
if x>x_antigo and move=1

x-=10 else move=0
if x<=x_antigo and move=1

x=x_antigo
Isso indica que enquanto a posição atual do objeto não for menor ou igual a posição inicial
do objeto (associada à x_antigo) será subtraído 10 pixels a cada frame.
Para maiores informações veja a engine jan_movel2.gmk.

9. Pausando o jogo
Em quase todos os estilos de jogos, é necessário ter um Pause, muitas vezes pelo Game
Maker não ter uma função pré-definida pra isso, fica um pouco difícil fazer com outras
funções. Embora não de forma prática, o Game Maker possui uma maneira para
"Travar/Pausar" o jogo:
screen_refresh()
keyboard_wait()
io_clear()
Cada uma individualmente, desempenha funções específicas, não necessariamente

ligadas a um sistema de Pause.
O screen_refresh atualiza a janela do jogo. keyboard_wait faz com que tenha uma
espera do teclado e nenhuma tecla pressionada seja considerada. E por último io_clear,
IO quer dizer Input/Output (Entrada/Saída) e tem a função de zerar a variável de tecla ou
mouse informado anteriormente.
Basicamente, basta adicionar o código acima citado, em um evento do tipo Keyboard (Veja
capítulo 1), preferencialmente P para que ao ser executado, o jogo pause. Para teste,
vamos fazer aparecer uma imagem com a mensagem "Pause", quando o jogo estiver
pausado.
Primeiro criamos um evento qualquer, com algum movimento, apenas para representar que
o jogo está em andamento, pode ser um movimento circular, uma sprite com várias sub-
imagens etc, nesse exemplo eu usei no evento Step o código:
image_angle+=21
direction+=5
speed=3
Isso faz com que o ângulo da imagem aumente constantemente 25º, a direção 5 e o speed
seja constantemente 5, gerando um movimento circular regular.
Em um outro objeto, ob_pause, por exemplo, indicamos algumas coisas:
x=room_width/2
y=room_height/2
mostra=0
Centraliza o objeto na room e inicia a variável mostra.

No evento Step:
if keyboard_check(ord('P')) {
mostra=1
draw_sprite(sprite_index,0,x,y)
screen_refresh()
keyboard_wait()
io_clear()}
else mostra=0
Fazendo com que ao pressionar a letra P, mostre tenha agora o valor 1, mostre a sprite e
finalmente pause o jogo, ao soltar a tecla P, mostra volta ao seu valor inicial, que é 0.
E finalmente no evento Draw:
if mostra draw_sprite(sprite_index,0,x,y)
O jogo será pausado com a letra P, sem interferir nos objetos e sem complicações, a
imagem pode ser custumizada, pode ser usado em qualquer tipo de jogo, não trás
problemas de execução.
Confira a engine desse capítulo: pause.gmk.

10. GM3D - Primeiros passos

10.1 O que pode ser feito em 3D no Game Maker
O 3D no Game Maker ainda é bem limitado e falta muitas ferramentas que por padrão
deveriam estar disponíveis. Embora tudo isso possa ser contornado com uso de DLLs e
scripts que tem aos montes feitos pelos próprios usuários do programa, você precisara
sempre pesquisar para expandir o que pode ser feito em seu jogo.
O computador do programador deve ter pelo menos uma boa placa de vídeo pois o uso de
muitas texturas de tamanho grande podem não funcionar causando o famoso erro
“Unexpected error occurred when running the game” que na maioria das vezes é
causado porque o jogo está usando um recurso da placa de vídeo que não existe ou
usando mais memória do computador do que ele realmente tem.
Considerando também que não vamos fazer uma obra de arte que custará milhões e
centenas de pessoas para ser feita em três anos... É como dizem: “O limite e a criatividade
do criador.”
10.2 A terceira dimensão!
Existem muitos tipos de conceitos para explicar o 3D, mas falarei apenas do mais usado.
A visão da tela apenas com o X e Y aparenta estar de pé, onde X vai para os lados e Y
para cima ou para baixo.
Mas ao inserir a terceira dimensão percebemos que na verdade a visão esta deitada, pois
Z representa a profundidade.
Quanto maior o Z mais alto o ponto vai estar e quanto menor mais baixo ou profundo o
ponto.
A terceira dimensão não tem nada de complicado. Basta lembrar que ela é a profundidade,
volume ou altura enquanto as outras duas são a largura e o comprimento.
10.3 Construindo uma Engine
Agora vamos iniciar uma engine. A cada aula diferente você ira completá-la cada vez mais
até que o resultado final seja algo parecido com um jogo de corrida.
Por enquanto vamos só aprender a desenhar um cubo na tela.
Abra o GM e vamos começar!
Todo jogo precisa de algo que controle o que o jogador irá ver.
Crie um novo objeto e nomeio como objCamera.
Agora temos que ativar o modo 3D e definir as configurações iniciais.
No evento Create do objCamera coloque:
d3d_start();
Isso inicia o modo 3D do Game Maker
d3d_set_perspective(true);
Ativa a visualização em perspectiva. Isso realça a noção de profundidade dos objetos.
d3d_set_hidden(true);
Esse é muito útil pois fará com que todos as superfícies desenhadas atrás de outro objeto
não apareçam.
d3d_set_fog(true,c_white,1,1200);
Fog é uma espécie de neblina. Todo que estiver a 1200 pixels da visão do jogador será
escondido por ela.
d3d_set_culling(false);
O culling faz a parte de dentro dos objetos, ou seja, o lado de trás das textura não serem
desenhados. Se a câmera olhar de dentro de um cubo, as paredes do cubo ficam
invisíveis.
d3d_set_shading(false);
Shading significa sombreamento. Ele melhora a qualidade do efeito da luz nos objetos mas
como não usar iluminação nesse exemplo deixe-o como false.
texture_set_interpolation(true);
Melhora a qualidade das texturas.
draw_set_color(c_white)
Defina a cor de desenho como branco (c_white).
z=48;
Todos os objetos tem uma variável x e y por padrão. Mas o z terá sempre que ser criado
manualmente. Defina como 48 porque a câmera ficara um pouco acima do chão.
Agora é preciso definir como o jogo vai ser visualizado.

No evento Draw digite:
d3d_set_projection(x,y,z,obj1.x,obj1.y,obj1.z,0,0,1);
Vou explicar essa função de um jeito mais completo na próxima aula pois o objetivo aqui é
apenas ensinar a desenhar um cubo na tela.
Agora crie um novo background. Ele vai ser a textura do objeto.

Desenhe qualquer coisa. Servira apenas para visualizar melhor os lados do cubo.
Eu fiz este:
Agora crie outro objeto. Ele será o cubo. Nomeio como obj1.
No evento Create defina:
z = 0;
A variável z.
tex = background_get_texture(background0);
Essa função retorna o lugar na memória do computador onde a textura do background0

está armazenada.
Agora no evento Draw:
d3d_draw_block(x-16,y-16,z-16,x+16,y+16,z+16,tex,1,1)
Com isso desenho cada lado com 32 pixels, defino a textura dele e os dois últimos valores
são quantas vezes a textura vai se repetir nas paredes do cubo.
Pronto! Coloque o jogo pra rodar e veja o resultado.
Veja a engine desse capítulo, arquivo GM3D 01.gmk.

11. GM3D – Projeção e Movimento da Câmera

Assim como os olhos dos seres vivos projetam o ambiente para o cérebro, o jogo também
deve ter algo que projete o espaço virtual ao jogador.
Nessa aula vou explicar como criar uma câmera que se movimenta com o mouse.
Essa parte é complicada tanto para aprender quanto para explicar.
Fiquem atentos.
11.1 A função d3d_set_projection_ext
Existem duas funções que usamos para definir como o mundo será visto:
d3d_set_projection(xfrom,yfrom,zfrom,xto,yto,zto,xup,yup,zup);
d3d_set_projection_ext(xfrom,yfrom,zfrom,xto,yto,zto,xup,yup,zup,ang
le,aspect,znear,zfar);
A primeira á a forma simples e a segunda é a forma estendida da função. Iremos usar

apenas a segunda.
Fazer com que entendam cada argumento será bem complicado, mas eu gosto que tudo
seja explicado então prestem bastante atenção e façam testes com cada parâmetro..
d3d_set_projection_ext(xfrom,yfrom,zfrom,xto,yto,zto,xup,yup,zup,ang
le,aspect,znear,zfar)
xfrom,yfrom,zfrom,xto,yto,zto – from significa “de” e to “para”. Os três primeiros

argumentos são os pontos da câmera, ou seja, o lugar de onde se olha e os três últimos o
lugar para onde esta se olhando. Por exemplo:
Você esta no quarto olhando para o computador. A posição dos seus olhos representam
“xfrom,yfrom,zfrom” e a posição do computador representa “xto,yto,zto”.
xup,yup,zup – esses argumentos são definidos apenas como false ou true. Neles você
especifica o eixo em que a projeção gira. Exemplo:
Você ainda está olhando para o computador.
Levante ou abaixe a cabeça. Pronto! Você acabou de girar a visão em torno do eixo y.
Agora mexa a cabeça para direita ou para a esquerda. Pronto! Você acabou de girar a
visão em torno do eixo z.
Girar em torno do eixo x seria como rodar a cabeça em torno de si mesma olhando sempre
pra fentre.
Marque como true os eixos que a câmera vai gira.

O padrão usado é “0,0,1”, ou seja, ira girar em torno do eixo z.
angle – este não tem nada a ver com o ângulo da visão e muita gente se confundi com ele.
Aqui você deve definir a largura da câmera em graus. Exemplo:
As lentes dos óculos são medidas em graus lembra? Quanto maior o grau, mas as
imagens são aumentadas.
Você já viu aquelas câmera que quanto se gira a lente o zoom aumenta ou diminui? Então!
O efeito desse argumento é o mesmo.
Quanto maior o valor de angle, maior vai ser o zoom “natural” da projeção.
Um padrão razoável é 45° mas eu estou usando 90° em meus projetos.
aspect – defini o aspecto da tela. Não há muito o que explicar...

Se você esta usando uma dimensão de tela padrão (640x480, 1024x768...), qualquer valor
sem ser a divisão desses tamanho causara distorção na imagem.
Defini-o como 640/480 ou simplesmente 1.3.
znear,zfar – de znear a zfar é a região que será desenhada pela câmera. Por exemplo:
znear é 1 e zfar é 10000. Tudo que estiver entre o pixel 1 e o pixel 10000 da projeção será
desenhado. Tudo que estiver fora dessas coordenadas não será desenhando.
Nessa figura a primeira linha vertical representa o znear e a segunda linha vertical o zfar.
Tudo o que há na parte azul será desenhado e tudo o que há na parte cinza não será
desenhando.
O padrão é znear = 1 e zfar = 32000.
11.2 A função d3d_set_projection_ortho
Se você quer desenhar coisas bidimensionais em modo 3D?

Então terá que usar isso.
Visão ortogonal nada mais é do que a projeção das imagens ignorando a profundidade
delas, ou seja, o valor z.
Seria como desenhar um modelo 3D com todas as suas coordenadas z iguais a zero. Ele
ficaria achatado. Sem profundidade.
Essa função é extremamente útil, pois podemos desenhar textos e imagens na tela sem
dificuldades.
d3d_set_projection_ortho(x,y,w,h,angle)
x,y,w,h – essa é a região ou tamanho da tela. Note que se for diferente do tamanho da
view o que for desenhado na tela vai se esticar em relação a view.
angle – gira o que for desenhado. O ponto de origem é por padrão o meio da area que
você definiu.
Para desenhar um texto na tela você pode fazer da seguinte forma:
draw_set_color(c_black);
d3d_set_projection_ortho(0,0,view_width,view_height,0);
d3d_set_hidden(false);
draw_text(10,10,'FPS: ' + string(fps));
d3d_set_hidden(true);
Essa função deve vir sempre antes de d3d_set_projection_ext ou a cena não será
desenhada direito.
11.3 Movimentando a câmera
Agora é hora de aprender como movimentar a câmera no mundo.

Vamos adicionar um exemplo de visão em terceira pessoa onde o personagem é
totalmente enquadrado pela câmera no projeto da aula anterior. Depois explicarei como
adaptar isso para primeira pessoa que é ver o mundo como se estiver com os olhos do
personagem.
Abra a engine que começamos na aula 1. Você também pode baixar o source clicando
aqui.
Crie um novo background que será a textura do chão.
Abra o obj1 e defina outra variável para a textura do chão:
tex2 = background_get_texture(background1);
No evento Draw:
d3d_draw_floor(0,0,0-16,room_width,room_height,0-16,tex2,5,5);
Isso vai desenhar um chão do tamanho da room e embaixo do cubo.
Agora abra o objCamera e vamos definir todos as variáveis necessários para controlar o
movimento no evento Create:
// Movimento da camera
z = 0; // ponto z
dx = 0; // armazena movimento x da câmera
dy = 0; // armazena movimento y da câmera
dz = 0; // armazena movimento z da câmera
px = 0; // ponto x para onde se esta olhando
py = 0; // ponto y para onde se esta olhando
pz = 0; // ponto z para onde se esta olhando
zoom = 400;
zang = 0; // angulo horizontal da camera
yang = 0; // angulo vertical da camera
// Definir posição do mouse
window_mouse_set(200,200);
// Sem cursor
window_set_cursor(cr_none);
Agora crie um evento Step e:

Primeiro deve-se achar os ângulos da câmera. É o movimento do mouse que vai modar os
ângulos então precisamos saber o quanto e para onde ele esta se movendo.
// Definindo angulos a partir do mouse

zang-=(window_mouse_get_x()-200)/8;
yang-=(window_mouse_get_y()-200)/8;
yang=median(yang,-89,89);
zang é igual a posição x do mouse -200 dividido por 8. Isso retorna quantos pixels o mouse
se moveu em x.
yang é igual a posição y do mouse -200 dividido por 8. Isso retorna quantos pixels o mouse
se moveu em y.
O valor 8 é a sensibilidade do mouse. Quanto menor mais rápido o movimento vai ficar.
A função window_mouse_set defini a posição do mouse novamente depois de já achar os
ângulos.
A ultima linha de código faz com que yang nunca passe de -89 a 89, ou seja, quanto a
câmera estiver em cima ou embaixo do objeto seu ângulo vertical não mudará mais.
Já temos os ângulos vertical e horizontal definidos. Agora precisamos saber o quanto os

pontos x,y e z da câmera teriam que mudar para que possa girar em torno do personagem.
// Animação da camera
// calculando movimento dos vetores da camera

dx=cos(degtorad(zang));
dy=-sin(degtorad(zang));
dz=tan(degtorad(yang));
// normalizar vetores
// torna movimento da camera totalmente esferico.
m=sqrt(sqr(dx)+sqr(dy)+sqr(dz));
dx/=m;
dy/=m;
dz/=m;
Coseno, seno e tangente são operações matemáticas para achar pontos de acordo com
um ângulo.
Convertemos os graus em radianos com a função degtorad(ang).
cos retorna quantos pixels o x terá que se mover para estar naquele ângulo.
sin retorna quantos pixels o y terá que se mover para estar no mesmo ângulo que x (ângulo
vertical).
E tan retorna quantos pixels o z terá que se mover para estar de acordo com o ângulo
vertical.
Por ultimo em tenho que normalizar dx, dy e dz para que o movimento gire de forma
perfeitamente esférica em torno do personagem.
Não tem muito o que explicar disso. Aquilo é uma operação para não deixar que o zoom
mude automaticamente dependendo do ângulo.
Agora é só definir as novas coordenadas da câmera de acordo com dx, dy e dz.
// Calculando posição da camera no mundo

x = obj1.x+dx*zoom;
y = obj1.y+dy*zoom;
z = obj1.z+dz*zoom;
// Zoom
if keyboard_check(vk_add) zoom += 4;
if keyboard_check(vk_subtract) zoom -= 4;
Ao multiplicar os valores que acho com cos, sin e tan eu estou adicionando uma distancia
ao movimento. Essa distancia é o zoom que vale 400 pixels. A câmera ficará a 400 pixels
do personagem.
Adicionei também algo para aumentar e diminuir o zoom apertando “+” ou “-“ no teclado.
Finalize o código do evento Step definindo o lugar para onde o câmera vai olhar que no
caso é a posição do obj1.
// Movimento no personagem
px = obj1.x;
py = obj1.y;
pz = obj1.z;
Abra o evento Draw do objCamera, apague o código lá e defina uma nova projeção:
d3d_set_projection_ext(x,y,z,px,py,pz,0,0,1,90,1.3,1,32000);
Adicione um movimento simples para o obj1. Crie um evento Step nele:
if keyboard_check(ord('W')) y -= 4;
if keyboard_check(ord('S')) y += 4;
if keyboard_check(ord('A')) x -= 4;
if keyboard_check(ord('D')) x += 4;
Pra finalizar defina a velocidade da room como 60.
Se você quiser fazer um visão em terceira pessoa é simples.

Basta inverter os pontos xfrom, yfrom, zfrom, xto, yto, zto
d3d_set_projection_ext(px,py,pz,x,y,z,0,0,1,90,1.3,1,32000);
Não se esqueça de tirar o código que desenha o cubo porque senão a visão vai ficar
tampada pela parte de dentro do cubo.

12. GM3D – Usando Transformações

As transformações em D3D são usadas para rotacionar um modelo no jogo. Há também a
possibilidade de escalar o objeto aumento ou diminuindo seu tamanho mas isso não é
aconselhável se você usar iluminação no jogo porque tem um bug no GM que calcula as
normais (projeção da textura) erradas fazendo o modelo escurecer cada vez que é
aumentado.
12.1 Transformações
Para rotacionar ou escalar um objeto você precisara usar as transformação D3D. Todas as
suas funções começam com a expressão “d3d_transform_”.
Primeiro você precisa definir o que será transformado senão os efeitos serão aplicados no
mundo todo.
Para isso existe uma função que identifica o que esta sendo desenhado e aplica os efeitos
apenas neles. Ela é a “d3d_transform_set_identity()”.
Outra coisa importante é que as transformação são aplicadas usando o ponto de origem da
room (que é 0,0,0 para x,y,z) e não o do objeto, ou seja, quanto você rodar um modelo ele
vai girar em torno do ponto 0 da room e não em torno de si mesmo (como a Terra girando
em torno do Sol).
Para resolver isso alem de usar “d3d_transform_set_identity” você também usará a função
“d3d_transform_add_translation(x,y,z);” que defini que a transformação será aplicada em
torno dos argumentos x,y,z.
Veja um exemplo:
d3d_transform_set_identity();
d3d_transform_add_translation(x,y,z);
d3d_draw_model(modelo,0,0,0,textura);
d3d_transform_set_identity();
Explicando linha por linha:
d3d_transform_set_identity(); – identifica o que vai ser afetado. Note que há também um

no final do código, isso quer dizer que todo que esta entre essas funções será alterado.
d3d_transform_add_translation(x,y,z) – defini o ponto de origem das transformações. Os

modelos também serão desenhados a partir dele (é como se fossem os novos pontos x, y e
z do objeto).
d3d_draw_model(modelo,0,0,0,textura) – desenha o modelo. Note que os pontos x,y,z

são definidos como 0. Por que?
A resposta é simples. Quanto eu usei d3d_transform_add_translation(x,y,z) os argumentos
x,y,z dele se tornaram os novos pontos de origem do modelo. Tudo que for desenhado
entre os identificadores será relativo a esta nova origem.
Se o modelo fosse desenhado em 10,15,8:
d3d_draw_model(modelo,10,15,8,textura);
Seria o mesmo que desenhá-lo na posição x+10,y+15,z+8 na room.
d3d_transform_set_identity(); – por último outro identificador. Lembrando que tudo que

estiver entre ele e o primeiro será afetado.
Uma coisa interessante é que as transformações funcionam em qualquer tipo de desenho

do GM. Você também pode usá-las na hora de desenhar uma sprite, background ou texto!
12.2 Continuando a engine
Abra a engine que fez seguindo as outras aulas ou baixe por este link.
Antes de continuar com as explicações vamos resolver um bug nessa engine.

O movimenta da câmera não esta seguindo direito o movimento do personagem. Quanto
nós movimentamos o objeto a câmera puxa pros lados.
Para resolver isso apague as linhas de código abaixo no evento Step e coloque-os no
evento Draw antes da função de projeção no objCamera:

x = obj1.x+dx*zoom;
y = obj1.y+dy*zoom;
z = obj1.z+dz*zoom;
px = obj1.x;
py = obj1.y;
pz = obj1.z;
O evento Step ficará assim:
// Definindo angulos a partir do mouse

zang-=(window_mouse_get_x()-200)/8;
yang-=(window_mouse_get_y()-200)/8;
yang=median(yang,-89,89);
// Animação da camera
// calculando movimento dos vetores da camera

dx=cos(degtorad(zang));
dy=-sin(degtorad(zang));
dz=tan(degtorad(yang));
/* normalizar vetores torna movimento da camera totalmente

esferico. */
m=sqrt(sqr(dx)+sqr(dy)+sqr(dz));
dx/=m;
dy/=m;
dz/=m;
// Zoom
if keyboard_check(vk_add) zoom += 4;
if keyboard_check(vk_subtract) zoom -= 4;
E o evento Draw assim:

x = obj1.x+dx*zoom;
y = obj1.y+dy*zoom;
z = obj1.z+dz*zoom;
px = obj1.x;
py = obj1.y;
pz = obj1.z;
d3d_set_projection_ext(x,y,z,px,py,pz,0,0,1,90,1.3,1,32000);
Agora sim a câmera está ótima.
Mude o desenho do cubo para uma forma mais achatada para dar uma impressão de ser
um carro.
Troque os valores no código que desenha o cubo no evento Draw do obj1:
d3d_draw_block(-16,-32,-10,16,32,10,tex,1,1);
Agora está tudo pronto para a próxima explicação.
12.3 Rotação e Escalação
As funções seguintes podem ser usadas para rotacionar e escalar os objetos:
d3d_transform_add_rotation_x(angle) – Gira o objeto em torno do eixo x.

d3d_transform_add_rotation_y(angle) – Gira o objeto em torno do eixo y.
d3d_transform_add_rotation_z(angle) – Gira o objeto em torno do eixo z.
d3d_transform_add_scaling(xs,ys,zs) – Altera a escala nos eixos x, y e z.
Vamos fazer um teste na nossa engine para entender o funcionamento.

Crie variaveis rx, ry e rz no evento Create do obj1:
rx = 0;
ry = 0;
rz = 0;
Ela será o valor do ângulo das rotações.
No evento Step adicione isso para mudar os ângulos com os números do teclado numérico:
if keyboard_check(vk_numpad1) rx += 1;
if keyboard_check(vk_numpad4) rx -= 1;
if keyboard_check(vk_numpad2) ry += 1;
if keyboard_check(vk_numpad5) ry -= 1;
if keyboard_check(vk_numpad6) rz += 1;
if keyboard_check(vk_numpad3) rz -= 1;
No evento Draw vamos adicionar a função de rotação dos eixos.

Elas devem estar sempre antes da função d3d_transform_add_translation.
A parte que desenha o cubo ficará assim:
d3d_transform_set_identity()
d3d_transform_add_rotation_x(rx);
d3d_transform_add_rotation_y(ry);
d3d_transform_add_rotation_z(rz);
d3d_draw_block(-16,-32,-10,16,32,10,tex,1,1);
Teste o jogo e aperte 1 e 4 para girar no eixo x, 2 e 5 para girar no eixo y e 3 e 6 para girar
no eixo z.
Notou a diferença entre eixo x, y e z?
Bom, agora é hora de testar as escalas.

No evento Create do obj1 adicione mais variáveis para cada escala:
sx = 1;
sy = 1;
sz = 1;
E no Step o código para mudar as escalar:

if keyboard_check(vk_delete) sx += 0.1;
if keyboard_check(vk_insert) sx -= 0.1;
if keyboard_check(vk_end) sy += 0.1;
if keyboard_check(vk_home) sy -= 0.1;
if keyboard_check(vk_pagedown) sz += 0.1;
if keyboard_check(vk_pageup) sz -= 0.1;
No evento Draw adicione a função para escalar o modelo também sempre antes de
d3d_transform_add_translation.
d3d_transform_add_rotation_x(rx);
d3d_transform_add_rotation_y(ry);
d3d_transform_add_rotation_z(rz);
d3d_transform_add_scaling(sx,sy,sz);
d3d_draw_block(-16,-32,-10,16,32,10,tex,1,1);
Teste e use Delete e Insert para mudar o eixo x, End e Home para o eixo y, Page Up e
Page Down para o eixo z.
12.4 Movimentação
A movimentação dessa engine será da seguinte forma:

As teclas A e D giram o objeto, W e S acelera e desacelera, C muda o modo da câmera.
Apague as novas variáveis que criamos e faça apenas uma para a rotação r, y_speed para
a velocidade e mude o valor z para 16.
Evento Create Completo:
z = 16;
tex = background_get_texture(background0);
tex2 = background_get_texture(background1);
x = 96;
y = 96;
r = 0; // rotação z
y_speed = 10; // velocidade
Apague todo o código no evento Step e coloque este para girar o carro para os lados:
if keyboard_check(ord('A')) r += 2;
if keyboard_check(ord('D')) r -= 2;
O carro tem que andar na direção que esta virado então temos que usar cos e sin para
achar x e y de acordo com o ângulo.
No evento Step adicione este código:
if keyboard_check(ord('W'))
{
x += cos(degtorad(r+90))*y_speed;
y -= sin(degtorad(r+90))*y_speed;
}
if keyboard_check(ord('S'))
{
x -= cos(degtorad(r+90))*y_speed;
y += sin(degtorad(r+90))*y_speed;
}
O “r+90” ajeita o ângulo de calculo para faze-lo correr na direção certa.
Por ultimo deixe o evento Draw desta forma:
d3d_transform_add_rotation_z(r);
d3d_draw_block(-16,-32,-10,16,32,10,tex,1,1);
d3d_draw_floor(0,0,0,room_width*3,room_height*3,0,tex2,10,10);
Isso muda a rotação do eixo z e aumento o tamanho do chão.

Teste o jogo é veja o resultado!

13. Licença de uso, modificação e distribuição

O conteúdo dessa apostila é de uso livre e gratuito, é permitido a alteração total ou parcial
do conteúdo e a divulgação, desde que seja autorizado pelos respectivos autores, segundo
a licença GNU General Public License 3.
13.1 GNU GPL 3
Leia abaixo uma versão compacta da GNU GPL 3 (em inglês):
GNU GENERAL PUBLIC LICENSE

Version 3, 29 June 2007
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public

License.
"Copyright" also means copyright-like laws that apply to other

kinds of works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under

this License. Each licensee is addressed as "you". "Licensees"
and "recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of

the work in a fashion requiring copyright permission, other than
the making of an exact copy. The resulting work is called a
"modified version" of the earlier work or a work "based on" the
earlier work.
A "covered work" means either the unmodified Program or a work

based on the Program.
To "propagate" a work means to do anything with it that, without

permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it
on a computer or modifying a private copy. Propagation includes
copying, distribution (with or without modification), making
available to the public, and in some countries other activities as
well.
To "convey" a work means any kind of propagation that enables

other parties to make or receive copies. Mere interaction with a
user through a computer network, with no transfer of a copy, is
not conveying.
1. Basic Permissions.
All rights granted under this License are granted for the term
of copyright on the Program, and are irrevocable provided the
stated conditions are met. This License explicitly affirms your

unlimited permission to run the unmodified Program. The output
from running a covered work is covered by this License only if the
output, given its content, constitutes a covered work. This
License acknowledges your rights of fair use or other equivalent,
as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise
remains in force. You may convey covered works to others for the
sole purpose of having them make modifications exclusively for
you, or provide you with facilities for running those works,
provided that you comply with the terms of this License in
conveying all material for which you do not control copyright.
Those thus making or running the covered works for you must do so
exclusively on your behalf, under your direction and control, on
terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely

under the conditions stated below. Sublicensing is not allowed;
section 10 makes it unnecessary.
2. Termination.
You may not propagate or modify a covered work except as

expressly provided under this License. Any attempt otherwise to
propagate or modify it is void, and will automatically terminate
your rights under this License (including any patent licenses
granted under the third paragraph of section 11).
However, if you cease all violation of this License, then your

license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly
and finally terminates your license, and (b) permanently, if the
copyright holder fails to notify you of the violation by some
reasonable means prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is

reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you
have received notice of violation of this License (for any work)
from that copyright holder, and you cure the violation prior to 30
days after your receipt of the notice.
Termination of your rights under this section does not terminate

the licenses of parties who have received copies or rights from
you under this License. If your rights have been terminated and
not permanently reinstated, you do not qualify to receive new
licenses for the same material under section 10.
3. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order,

agreement or otherwise) that contradict the conditions of this
License, they do not excuse you from the conditions of this
License. If you cannot convey a covered work so as to satisfy

simultaneously your obligations under this License and any other
pertinent obligations, then as a consequence you may not convey it
at all. For example, if you agree to terms that obligate you to
collect a royalty for further conveying from those to whom you
convey the Program, the only way you could satisfy both those
terms and this License would be to refrain entirely from conveying
the Program.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY

APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE
COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS"
WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED,
INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE
RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.
SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN

WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES
AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA
BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF
THE POSSIBILITY OF SUCH DAMAGES.
A versão completa da GNU GPL 3 se encontra no arquivo licença GLP.txt.

Apostila Game Maker PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apostila Game Maker PDF

Transféré par

Droits d'auteur :

Formats disponibles

Apostila Livre

Copyright (C) Apostila Livre :: Game Maker ::

4. Introdução aos loops

5. Movimentação básica em plataforma

6. Movimentação básica em TopDown

10.GM3D - Primeiros passos

11. GM3D – Projeção e Movimento da Câmera

12. GM3D – Usando Transformações

13. Licença de uso, modificação e distribuição

- Possui código fonte para Game Maker 8 (arquivo indicado em azul).

- Capítulo testado e revisado.

As funções que serão citadas aqui são:

Os botões Delete e Change, apagam e substituem o evento selecionado respectivamente,

Mas não nos aprofundaremos nessas sub-categorias de funções, somente em algumas

Destroy – Quando o objeto for destruído executa um conjunto de funções.

Onde n é o número correspondente ao Alarm e o frames é a quantidade de frames até ele

Step – Executa constantemente as funções adicionadas a ele, cuidados com as funções

Game Start – Ao iniciar o jogo, só será executado 1 vez na execução do jogo.

Room End – Ao sair da room, é acionado as funções inseridas nele.

Draw – Funções de desenho (Ver o capítulo Introdução ao Draw)

2.1 Onde usar?

Como é possível guardar informações escolhidas, é muito importante usá-las em seleções

2.2 Nomeando variáveis globais

As variáveis globais sempre são nomeadas assim:

No mesmo evento, digite mais um código:

Coloque um sprite diferente para cada um desses objetos.

Crie outro objeto, chame-o de selecionador. nele digite o seguinte código:

Se a variável global (o item selecionado) for 0, criar objeto sel_1.

3.1 Modificando cores

c_aqua //Azul piscina

3.2 Draw Point

No x colocamos sua posição horizontal e no y sua posição vertical. Esse comando só

Para entendermos como desenhar a linha exatamente no lugar onde queremos, é

Como mostrado na imagem, os dois primeiros argumentos do script x1 e y1 representam a

O resultado será uma linha assim:

3.4 Draw Rectangle

O draw_rectangle, desenha um retângulo e seu funcionamento é muito parecido com o da

Os argumentos x1 e y1 servem para colocarmos as coordenadas da extremidade superior

Dentre os dois pontos (extremidades) que colocamos no código, o Game Maker

Nesse caso o resultado será:

É possível mudar a cor dessa linha, colocando-se o draw_set_color(cor) antes do código.

Cada argumento cor representa uma ponta do retângulo:

cor1: Ponta superior esquerda

3.5 Draw Circle

x - Posição vertical do centro do círculo;

E finalmente o draw_set_circle_precision, essa função é muito interessante. Ela serve para

Veja a diferença entre o valor 10 e o valor 100:

Como a maioria das funções do draw, o draw_circle e o draw_ellipse possuem também

4. Introdução aos loops

O for comporta-se da seguinte maneira:

No exemplo, vou desenhar na tela uma tabela com os 10 nomes do highscore:

for (pos=1; pos<=10; pos+=1) {

for (pos=1; pos<=10; pos+=1) {

for (pos=1; pos<=10; pos+=1) {

E finalmente aqui, o nome de cada posição é colocado na frente da sua respectiva

O comando While pode ser resumido com:

Nesse exemplo, sempre haverá 100 inimigos na room.

5. Movimentação básica em plataforma

Agora sim começaremos a movimentação, primeiramente faremos o personagem andar

if keyboard_check(vk_right) //Se a tecla direita for pressionada

if keyboard_check(vk_left) //Se a tecla esquerda for pressionada

if keyboard_check_pressed(vk_up) //Se a tecla cima for pressionada

Para maiores informações, veja a engine desse capítulo, arquivo mov_plataforma.gmk.