01. Lógica e Programação Basica

Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 1
Sumário
1. Introdução a Lógica ................................................................................................ 03
2. Verdadeiro e Falso .................................................................................................. 03
3. Conectivo E e OU ................................................................................................... 03
4. Negação ................................................................................................................. 04
5. Introdução a Programação ..................................................................................... 04
6. Elementos Básicos de um Código Fonte ............................................................... 04
6.1 Palavras Reservadas .................................................................................................. 04
6.2 Comentários ................................................................................................................ 04
6.3 Operadores .................................................................................................................. 04
6.4 Atribuição ..................................................................................................................... 04
6.5 Constantes .................................................................................................................. 05
6.6 Variáveis ...................................................................................................................... 05
7. Arrays ...................................................................................................................... 06
7.1 Vetores ......................................................................................................................... 06
7.2 Matrizes ....................................................................................................................... 06
8. Expressões Lógicas e Aritméticas .......................................................................... 07
8.1 Operadores Aritméticos ............................................................................................... 07
8.2 Operadores Lógicos .................................................................................................... 07
8.3 Operadores Relacionais .............................................................................................. 07
8.4 Expressões Híbridas ................................................................................................... 07
8.5 Linearização de Expressões ....................................................................................... 08
9. Plano cartesiano do Game Maker .......................................................................... 08
10. Condicional IF e ELSE .......................................................................................... 09
11. Condicional SWITCH ............................................................................................. 10
12. Laço de Repetição FOR ........................................................................................ 11
13. Laço de Repetição WHILE .................................................................................... 12
14. Laço de Repetição DO-UNTIL ............................................................................... 12
15. Funções ................................................................................................................. 13
15.1 Funções sem Retorno ............................................................................................... 14
15.2 Funções com Retorno ............................................................................................... 15
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 2
1. INTRODUÇÃO A LÓGICA
Muita gente desconhece a Lógica Matemática, pois ela é uma ciência que
geralmente é ensinada no curso superior. Se baseia em cálculos diretos, onde não são
utilizados números, mas sim somente dois valores lógicos: VERDADEIRO ou FALSO.
As pessoas que trabalham com o Game Maker, porém desconhecem sobre a
linguagem de programação ou lógica, nem imaginam que ao mesmo tempo que estão se
divertindo, também estão aprendendo sobre os valores lógicos.
2. VERDADEIRO e FALSO
Não paramos para notar, mas os valores lógicos
estão em nosso cotidiano, em qualquer coisa que
falamos, ouvimos , lemos ou escrevemos. O simples
ato de aprovar ou negar algo, é um valor lógico.
Os valores lógicos são trabalhados em
linguagem de programação, onde um resultado será
sempre verdadeiro ou falso, veja na tabela a seguir, os
respectivos sinônimos desses valores nas linguagens,
outras literaturas e até mesmo em nosso cotidiano:
3. CONECTIVOS “OU” e “E”
Imaginemos que você tem 10 reais, e vai à uma loja de utilidades onde tem um
carrinho custando 10 reais e uma boneca também no mesmo valor. Com esse dinheiro
você somente poderá comprar o carrinho OU a boneca. Caso vá à loja com 20 reais,
poderá comprar o carrinho E a boneca.
Conectivo “E” (conjunção) - é utilizado sempre
para dar uma ideia de simultaneidade. Ou seja, enquanto um
dos valores ou os dois valores forem falsos, o resultado lógico
sempre será falso. Pode ser representado por and ou &&
Exemplo: João tem 20 anos (V) e não tem carteira de
motorista (F). João não pode dirigir (F).
Conectivo “OU” (disjunção) - é utilizado para dizer se
ocorrerá um evento ou outro, ou seja, se ocorrer um dos
eventos (verdadeiro) ou os dois eventos, o valor lógico será
verdadeiro. Somente será falso quando os dois eventos forem
falsos. Pode ser representado por or ou ||
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 3
Exemplo: A semana tem 8 dias (F) ou o Brasil é o país do futebol (V). O resultado dessa
disjunção é verdadeira (V), pois a segunda proposição é verdadeira.
4. NEGAÇÃO
A negação é utilizada para efetuar a inversão de valores, ou
seja, se o valor é verdadeiro ele fica falso e vice-versa.
Pode ser representado por não(x), ~x e !x, veja na tabela ao
lado.
5. INTRODUÇÃO A PROGRAMAÇÃO
Linguagem de programação é um conjunto finito de símbolos utilizados para
escrever programas de computador ou criar jogos.
No caso trabalharemos com códigos ligados a GML (Game Maker Language), que é
basicamente a união de algumas outras linguagens como C, C++ e Pascal.
Muitas pessoas acreditam que fazer um jogo no Game Maker é somente arrastar
botão e ver acontecer. Porém, na realidade, existe muita lógica e programação envolvidos,
e é isso que você verá a seguir.
6. ELEMENTOS BÁSICOS DE UM CÓDIGO-FONTE (SCRIPTS)
6.1 Palavras Reservadas: palavras que tem um significado especial no código, ou
seja, geralmente são aquelas palavras que executa algum comando e por isso não podem
ser usadas para outros fins, como nomear variáveis. Exemplos: if, else, break, continue,
then, etc...
6.2 Comentários: são palavras ou frases que não interferem no código, sua função
é apenas explicativa, não altera nada na sequência lógica do script. Para colocar um
comentário insira “//” (duas barras) seguido da frase, caso seja só uma linha ou também
coloque o texto entre /* e */ (asterisco e barra) se for mais de uma linha.
6.3 Operadores Aritméticos e Lógicos: no código fonte, os sinais matemáticos e
lógicos são representados por:
+ (mais)
- (menos)
* (asterisco)
/ (barra)
== (2 iguais)
→ Soma e concatenação
→ Subtração
→ Multiplicação
→ Divisão
→ Igualdade
! (exclamação)
true ou 1
false ou 0
> (maior)
< (menor)
→ Negação
→ Verdadeiro
→ Falso
→ Maior
→ Menor
6.4 Atribuição: uma das principais maneiras de armazenar uma informação numa
variável. O símbolo de atribuição é o igual (=), lembrado que = (atribuição) é diferente de ==
(Igualdade)
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 4
Sintaxe: <variavel> = <constante> ou <variavel> ou <expressao>
Exemplo: personagem = 1+2
6.5 Constantes: são valores fixos que não mudam no decorrer da execução,
geralmente é atribuído a alguma variável ou é utilizado diretamente num chamado. São
constantes números, strings, expressões e valores lógicos.
→ Strings são conjunto de caracteres, onde devem ser colocados entre 'e' (aspas simples)
ou entre “e” (aspas normal). O “+” (mais) entre duas strings faz a concatenação (fusão)
delas. Ex. de strings: “carro”, “Orkut”, etc... Concatenação: “carro”+”casa”=”carrocasa”
→ Inteiros são números naturais inteiros, seja ele negativo ou positivo. E não se utiliza
aspas para atribuí-los ou chama-los. Ex. de inteiros: -25, -52, 0, 78, 3, -1, 2, etc...
→ Flutuantes são números reais, ou seja, aqueles que não são exatos. E não se utiliza
aspas para atribuí-los ou chama-los. Ex. de flutuantes: 2.5, -1.2, 0.24, 4.87, -6.7, -8.1, etc.
→ Valores lógicos são condições verdadeiras ou falsas. No Game Maker podemos usar 1
(verdadeiro) e 0 (falso), mas para evitar erros e confusões com inteiros, o ideal é usar true
ou false.
→ Expressões são cálculos executados durante o processo, e pode obter resultado
aritmético, lógico ou híbrido. Ex.: 2+6, 25-4*6, 5<4>6, 5+8<9, etc. Veremos logo mais,
detalhadamente sobre as expressões.
6.6 Variáveis: são espaços na memória que guardam informações durante a
execução do jogo. Essas informações podem variar no decorrer da execução. Para
declarar o valor de uma variável, é necessário colocar nos eventos Create, Game Start ou
Room Start, utilizando um sinal de atribuição (=). Exemplo: carro = 1. O valor de “carro” no
início do jogo, será 1.
Para alterar o valor de uma variável no decorrer do jogo, basta que no evento, coloque a
variável seguida do sinal de atribuição e do novo valor: carro = 3. Agora, “carro” vale 3. Mas
se você quer acrescentar ou retirar valores da variável, basta colocar um sinal matemático
ao atribuir.
Exemplo: Digamos que casa = 2
casa = casa+3
→ Aqui, “casa” receberá ela mesmo mais 3, agora passa a valer 5;
casa = casa-1
→ Agora, “casa” recebe ela menos -1, passa a valer 4;
casa = 8
→ Aqui “casa” recebe 8, onde é seu novo valor;
casa = casa/2
→ Agora “casa” recebe ela dividido por dois, passa a valer 4;
casa = casa*3
→ Por fim, “casa” recebe ela multiplicado por 3, passando a valer 12.
Podemos resumir o código de atribuição, exemplo: Envés de barra = barra+2 podemos
usar barra += 2. Vale para qualquer cálculo aritmético: +=, -=, *= e /=.
Exemplos de como chamar uma variável com a função “Draw”:
draw_text(x,y,casa)
→ Mostrará na tela o valor 12 da variável “casa”.
draw_text(x,y,casa+15)
→ Mostrará na tela o valor 27 como resultado.
draw_text(x,y,casa+”carros”) → Mostrará na tela o valor 12carros como resultado.
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 5
7. ARRAYS (VARIÁVEIS COM SETORES)
7.1 Vetores: são variáveis que possuem vários setores em seu espaço de memória,
sendo assim, não é necessário declarar uma variável mais de uma vez, basta declarar uma
vez e depois alterar os índices atribuindo um valor diferente para cada um.
Sintaxe: <variavel>[<indice>]
Exemplo:
bloco = 0
→ Declaramos “bloco” com o valor 0;
bloco[0] = 2+1
→ O índice 0 de “bloco” recebe resultado da expressão 2+1;
bloco[1] = 20
→ O índice 1 de “bloco” recebe 20;
bloco[2] = false
→ O índice 2 de “bloco” recebe valor lógico falso;
bloco[3] = “texto” → O índice 3 de “bloco” recebe string “texto”;
bloco[4] += 2-5
→ O índice 3 de “bloco” recebe resultado de uma expressão.
Depois de atribuir um valor a um índice de um vetor, ao exibi-lo ou compara-lo, devese indicar o índice. Se por exemplo, declararmos o vetor “bloco” com 4 índices, ao usá-lo
(num evento “Draw” por exemplo), devemos indicar o valor do índice, exemplo: bloco[2],
caso contrário ele retornará o valor original da declaração e se colocar um índice
inexistente, dará erro na execução.
7.2 Matrizes: um Array também pode ser uma Matriz, ou seja, pode ter seus valores
guardados numa tabela. A declaração da variável é a mesma do vetor, poderem na
atribuição dos índices separamos as colunas e linhas por vírgula:
Sintaxe: <variavel>[<col>,<lin>]
Exemplo:
bloco = 0
→ Declaramos “bloco” com o valor 0;
bloco[1,0] = “frase” → Posição 1,0 de “bloco” recebe resultado da expressão 2+1;
bloco[2,0] = 20
→ Posição 2,0 de “bloco” recebe 20;
bloco[3,0] = false → Posição 3,0 de “bloco” recebe valor lógico falso;
bloco[1,1] = 3+5
→ Posição 1,1 de “bloco” recebe resultado da expressão;
bloco[3,1] = true
→ Posição 3,1 de “bloco” recebe valor lógico verdadeiro;
bloco[0,2] = “novo” → Posição 0,2 de “bloco” recebe string “novo”;
bloco[2,2] = 4*8-15 → Posição 2,2 de “bloco” recebe resultado da expressão.
Os espaços que sobram (em cinza escuro riscado), são chamados de “lixos”, isso
porque são espaços perdidos. Se chamássemos, por exemplo, o índice bloco[0,1] o Game
Maker retornará 0 (falso), se fosse num outro compilador de softwares (como DevC++), iria
aparecer um monte de símbolos sem sentido. Esses espaços perdidos também consomem
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 6
memória, por isso siga sempre essa dica: Nunca deixe espaços em branco num array, seja
ele um vetor ou uma matriz.
Exemplos de como chamar um array com a função “Draw”:
draw_text(x,y,bloco[1])
→ Mostrará na tela o valor 20 do vetor “bloco”
draw_text(x,y,bloco[3,1]) → Mostrará na tela o valor lógico 1 da matriz “bloco”.
8. EXPRESSÕES LÓGICAS E ARITMÉTICAS
Expressão é um conjunto de variáveis e/ou constantes que se relacionam por meio
de operadores e a sua avaliação gera um resultado.
Operadores são elementos que atual sobre operandos e produzem um resultado. De
acordo com o número de operandos, podem ser chamados de:
→ Binários: atuam sobre dois operandos como soma, subtração, divisão, etc...
→ Unários: atuam sobre um operando como sinal de negativo e negação.
8.1 Operadores Aritméticos: sempre irão retornar um valor numérico seja ele
inteiro ou flutuante, exemplos: 2+5=7, 2.5*2=5, 2-5=-3, etc...
8.2 Operadores Lógicos: sempre retorna um valor lógico, ou seja, verdadeiro ou
falso, exemplo: true or false = true
8.3 Operadores Relacionais: sempre retorna valores lógicos, ou seja, faz uma
comparação entre operandos, exemplos: 8<2=false, -52<50=true, 5!=5=false, etc...
8.4 Expressão Híbrida: pode ter operadores aritméticos, lógicos e relacionais,
porém sempre irá retornar um valor lógico. Exemplo: 5+3-5<45-10=true
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 7
8.5 Linearização de Expressões: é o ato de desmanchar uma expressão,
colocando-a numa linha só. Veja o exemplo a seguir:
Na linguagem de programação, não há como colocar essa fórmula no código fonte,
para isso devemos linearizar, respeitando os operadores e sua precedência. Assim:
(2+sqrt(4*2+8))/(2*2*2)
Como todos devem saber desde o ensino fundamental, numa expressão sem
parênteses, os operadores tem uma ordem de precedência que devemos seguir (tabelas
acima), onde que se errado o cálculo, o resultado pode ser diferente do esperado. Mas
para nossa felicidade, os compiladores em geral, executam respeitando essa precedência
automaticamente, basta inserirmos corretamente a expressão utilizando parênteses para
indicar a precedência exata e para ficar mais agradável visualmente.
Quanto a questão de raiz quadrada e exponenciação, o Game Maker já conta com
funções específicas para isso e para outros cálculos. Por exemplo: raiz quadrada de 16
sqrt(16) e a potência de 8 sqr(8).
9. PLANO CARTESIANO DO GAME MAKER
Todos estamos acostumados com aquele plano cartesiano que aprendemos quando
ainda estamos no ensino médio onde na linha x, positivo é à direita do zero e negativo à
direita e onde em y, positivo é para cima e negativo para baixo. Pois esqueça desse plano
cartesiano, porque o do Game Maker a linha do “y” é inversa, veja abaixo porque.
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 8
10. CONDICIONAL “IF” E “ELSE”
Basicamente a condicional “If” (em tradução livre “se”), trabalha com os valores
lógicos, verdadeiro e falso. Se não ocorre um evento, então ocorre outro. Veja o exemplo 1
a seguir logo mais leia a explicação:
EXEMPLO 1
Se João > 18 anos
então “Poderá dirigir”
Bom, caímos numa questão lógica, onde
João só poderá dirigir se tiver mais de 18
anos, caso contrário não poderá.
Nesse exemplo 2, utilizamos um “e”, onde
EXEMPLO 2
Maria só poderá se casar se tiver 21 anos e
Se (Maria == Solteira) && (Maria > 21 anos) estiver solteira. Caso somente um dos
então “Maria pode se casar”
eventos seja verdadeiro, ela não poderá se
casar.
EXEMPLO 3
Se (Paula > 0 reais) ou (Paula == 0 reais)
então “Paula ficará em casa”
No exemplo 3, Paula pode ou não ter
dinheiro que ficará em casa do mesmo jeito.
Mas como isso ficaria no Game Maker? Bom, no GM utilizamos no lugar de “se”, o
“if” e no lugar de “então”, usamos “{ }” (abre e fecha chaves).
EXEMPLO 4
If 5 > 3 {
draw_text(x,y,”maior”)
}
Se a condição for verdadeira, executará
tudo o que estiver entre chaves. Lembrando
que, se for só uma linha não é necessário o
uso da chaves, pode ser na mesma linha da
expressão: If 5 > 3 draw_text(x,y,”maior”)
Caso queira colocar mais uma condição caso ela seja falsa, aí entra em ação o “else” (que
em tradução livre é “senão”).
EXEMPLO 5
Se carro < 60Km/h
então “Não leva multa”
Senão “Ele é multado”
EXEMPLO 6
Se (5 == 5) && (5!=6)
então “É igual”
Senão “É diferente”
Para inserir essas condições no Game Maker, a sintaxe é bem parecida com a do Game
Maker, porém envés de “senão”, utilizamos “else”. Vamos fazer o exemplo 7 usando o 4:
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 9
EXEMPLO 7
If 5 > 3 {
draw_text(x,y,”maior”)
} else {
draw_text(x,y,”menor”)
}
Se o número 5 for maior que 3, escreva
“maior”, senão, escreva “menor”.
E além de constantes como inteiros,
flutuantes, lógicos e strings, também
podemos utilizar variáveis para comparar.
EXEMPLO 8
If carro < 60 {
draw_text(x,y,”Não é multado”)
} else {
draw_text(x,y,”É multado”)
}
Se o carro não ultrapassar 60 Km/h, ele não
será multado, porém caso ultrapasse, ele
será multado.
Bom, ainda existe um terceiro caso que podemos adicionar, veja no problema a seguir:
Faça um script onde escreva na tela se o numero digitado pelo usuário é maior, menor ou
igual a 5.
A questão é a seguinte, como podemos colocar essa terceira condição se só
obtemos duas? (If e Else)
A resposta é simples, porque podemos inserir sempre uma função dentro da outra, ou seja,
podemos colocar uma condicional dentro da outra, veja na resolução a seguir:
EXEMPLO 9
If numero > 5 {
draw_text(x,y,”Maior”)
} else {
if numero < 5 {
draw_text(x,y,”Menor”)
} else draw_text(x,y,”Igual)
}
“numero” é a variável onde ficará guardado
o valor que o usuário digitar. Se ele digitar
um número maior que 5, irá escrever na tela
“Maior”, senão, se colocar um número
menor, vai escrever “Menor”, senão,
escreverá “Igual”.
Lembrando que é bom sempre identar.
→ Identar é dar um recuo à direita na linha
inferior, para que a mesma fique
compreensível.
11. CONDICIONAL “SWITCH”
Na condicional “Switch” (“escolha”), é testada uma variável numa sequência de linhas até
que seja encontrada uma coincidência. Após ser encontrada, será encerrada a condição.
Veja o exemplo a seguir:
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 10
EXEMPLO 1
n=5
switch (n)
{
case 1:
draw_text(room_width/2, room_height/2, "Um")
break;
case 2:
draw_text(room_width/2, room_height/2, "Dois")
break;
default:
draw_text(room_width/2, room_height/2, "Nenhum");
}
EXEMPLO 2
switch (keyboard_key)
{
case vk_left:
case vk_numpad4:
x -= 4;
break;
case vk_right:
case vk_numpad6:
x += 4;
break;
}
O “n” vale 5, após entrar na
condição, será verificado em
cada caso qual é igual a variável.
Quando encontrar uma linha igual
ao valor da variável, ele saírá da
condição.
O “break” (“parar”), serve para
parar o teste ao encontrar a linha
verdadeira, não continuando a
verificação.
O “default” (“padrão”), é uma
linha onde é ativada quando
nenhuma das condições
anteriores é verdadeira.
O usuário irá pressionar uma
tecla, entrando na condição:
Caso essa tecla for “direcional
esquerdo” ou “numero 4” x
receberá -4 (ou ganhará 4 para a
esquerda). Caso seja “direcional
direito” ou “numero 6” x receberá
4 (ou ganhará 4 para a direita).
12. LAÇO DE REPETIÇÃO “FOR”
Comando “for” (“para” em tradução livre), é um conjunto de execuções com um
número pré determinado de repetições, ou seja, ele executará um loop até que a variável
final chegue. Exemplo:
EXEMPLO 1
Para M de 0 a 100 faça
(…)
fimpara
Nesse exemplo, ele executará o (…) até que
M chegue a 100 (de 1 em 1).
Agora veja como fica no Game Maker:
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 11
EXEMPLO 2
for (M=0; M==100; M+=1) {
(…)
}
A diferença para a linguagem do Game
Maker é que somente escrevemos o “for”
(“para”), e em seguida indicamos a variável
que começará, com o valor inicial, o valor
final e quando será acrescentado a cada
loop (separados por ponto-e-virgula).
EXEMPLO 3
for (i=0; i<=60; M+=1) {
carro+=2
}
No final da execução desse laço, o valor de i
será 60 e da variável carro será 120.
13. LAÇO DE REPETIÇÃO “WHILE”
O “While” (“Enquanto”), é um comando onde só tem fim quando a execução é falsa,
ou seja, só sai do loop quando a sequência de comandos for diferente da condição.
Exemplo:
EXEMPLO 1
m=1
while (m < 200)
{
m = m + 1;
draw_text(room_width/2, room_height/2, m)
}
Enquanto “m” for menor que 200, execute o
que está entre chaves.
Na chaves, “m” a cada loop, irá receber ele
e mais um e escreverá na tela..
Ao chegar em 200, sairá do loop, parando
de adicionar a “m”.
Características principais do “While”:
→ O comando pode ser vazio, simples ou bloco;
→ Ele é executado desde que a condição seja;
→ Testa a condição antes de executar o laço, ou seja, se a condição for falsa ele nem
executará o laço, enquanto o “Do-until” executa o laço para depois ver se a condição é
falsa ou verdadeira.
14. LAÇO DE REPETIÇÃO “DO-UNTIL”
Os programadores em geral, conhecem o “Do-while” (“Faça-enquanto”), porém a
linguagem do Game Maker utiliza o “Do-until” (“Faça-até que”) é quase o mesmo caso do
“While”, a diferença é que ele testa a condição depois de executar a sequência de
comandos, e só saíra do laço após a condição ser verdadeira. Vamos rever o exemplo
anterior usando o “Do-until”:
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 12
EXEMPLO 1
m=1
do {
m = m + 1;
draw_text(room_width/2, room_height/2, m)
} until (m == 200)
Execute o que está entre chaves, até que
“m” seja igual a 200.
Na chaves, “m” a cada loop, irá receber ele
e mais um e escreverá na tela..
Ao chegar em 200, sairá do loop, parando
de adicionar a “m”.
Veja um outro exemplo do “Do-until”:
EXEMPLO 2
do {
j += 1
draw_text(room_width/2, room_height/2,
"Não 500")
} until (j == 500)
Escreva a frase na tela e adicione 1 ao “j”
até que “j” seja igual a 500.
15. FUNÇÕES
Unidade autônoma no código, que executa uma tarefa particular. Além de deixar o
código mais organizado, ele pode ser utilizado em mais de um evento ou objeto, deixando o
jogo mais leve. Para isso usaremos também a pasta “Scripts” que se localiza na navegação
lateral do Game Maker. Veja o esquema a seguir:
→ 1. Pasta com Lista de Funções (ou Scripts),;
→ 2. Nome dada à função (que mais tarde será usada para chamá-la no objeto);
→ 3. Lista com as execuções da função, onde argument<num> é padrão;
→ 4. Lista contando seus objetos, onde podem ou não usar funções.
Sintaxe “Scripts”: <variavel> = argument<num>
Sintaxe “Objects”: <funcao>(arg0,arg1,arg2...)
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 13
15.1 Funções sem Retorno: é uma função que não utiliza um retorno de uma
execução específica. Retornando a última linha de comando, e se necessário acumulando
mais valores das anteriores.
EXEMPLO 1
Pasta “Objects”
draw_text(room_width/2, room_height/2,
teste(20))
Pasta “Scripts” nome “teste”
i = argument0
i += 30
EXEMPLO 2
Pasta “Objects”
draw_text(room_width/2, room_height/2,
outroteste(3,45))
Pasta “Scripts” nome “outroteste”
m = argument0
n = argument1
i = 6+3
k = m+n
Será desenhado na tela o valor executado
na função “teste”, onde argument0 é “20”.
No script, o argument0 foi atribuído para a
variavel “i”, onde em seguida foi adicionado
30 ao valor original, retornando 50 no
objeto.
Será desenhado na tela o valor executado
por “outroteste”, onde argument0 é “3” e
argument1 é “45”.
No script, o argument0 foi atribuído para “m”
e argument1 para “n”.
Logo em seguida foi calculado em “i” a
expressão “6+3” e no fim foi somado “m”
com “n” e atribuído para “k”.
Mas como diz na explicação acima, ele
somente retorna a última linha, então a linha
“i = 6+3” não tem valor significativo para o
objeto.
15.2 Funções com Retorno: é uma função que utiliza um retorno para colocar no
objeto a expressão ou variável. Veja os exemplos a seguir:
EXEMPLO 1
Pasta “Objects”
draw_text(room_width/2, room_height/2,
reto(15))
Pasta “Scripts” nome “reto”
p = argument0
p += 10
return p+23
EXEMPLO 2
Pasta “Objects”
draw_text(room_width/2, room_height/2,
reto2(4,55))
Será desenhado na tela o valor executado
na função “reto”, onde argument0 é “15”.
No script, o argument0 foi atribuído para a
variavel “p”, onde em seguida foi adicionado
10 ao valor original, retornando “p” mais 50
para o objeto.
Será desenhado na tela o valor executado
por “reto2”, onde argument0 é “4” e
argument1 é “55”.
No script, o argument0 foi atribuído para “o”
e argument1 para “h”.
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 14
Pasta “Scripts” nome “reto”
o = argument0
h = argument1
i = 6+3
return m+n
Logo em seguida foi calculado em “i” a
expressão “6+3”. Mas no final ele pede
retorno somente da soma das variáveis “m”
com “n”, ignorando a varável “i” e sua
expressão.
Uma função tem muitas utilidades na criação de um jogo ou programa. No exemplo
abaixo, foi feita uma estrutura com função:
EXEMPLO 3
Nome da Função: “jogo01”
if (keyboard_key == argument0){
x -= 4
} else {
if (keyboard_key == argument1){
x += 4
}
}
Objeto 01: “alfabeto” evento “Step”
Objeto 02: “direcionais” evento “Step”
jogo01(ord('A'), ord('D'))
jogo01(vk_left, vk_right)
Veja que, chamamos o código de teclado em 2 objetos diferentes e com teclas
diferentes, só que os dois utilizam a mesma função, que é fazer os objetos andarem para
esquerda e para a direita. Sendo assim não precisamos repetir o código duas vezes.
Enfim, existem várias outras funções próprias do Game Maker, da próxima vez falarei
mais sobre o assunto. Obrigado pelo download e pela leitura.
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 15
Editado por Giosepe Luiz
[email protected]
Versão do Game Maker Usada: 8.0
29 de maio de 2010
Curitiba - Paraná - Brasil
Conheça mais sobre o Game Maker, baixe sprites, engines, outros e
tenha a ajuda que precisar nos sites a seguir:
http://www.gamemakerbrasil.com
http://www.spriters-resource.com
Saiba tudo sobre Informática e Tecnologia, obtendo dicas e downloads
das melhores fontes e sites da web!
http://www.dicasemgeral.com
Apostila Básica de Lógica e Programação para Game Maker – por Giosepe Luiz 16