TUTORIAL DE CRIAÇÃO DE UM JOGO NO 3D GAME BUILDER

Transcrição

TUTORIAL DE CRIAÇÃO DE UM JOGO NO 3D GAME BUILDER COM A FUNÇÃO SALVAR
Este tutorial tem por objetivo ensinar de forma prática como salvar
elementos de um jogo criado no 3D Game Builder. Para isso, vamos criar
um jogo simples e aplicar os conhecimentos nele.
Antes de começarmos, é importante frisar algumas coisas
importantes, tais como o conceito de Game Designer e Programador. Toda
pessoa que entra nesse mundo de jogos sabe que um jogo de verdade é
algo complexo e por isso demanda tempo, paciência, conhecimento em
diversas áreas e pessoal. Então, como é muito difícil alguém reunir todas as
características necessárias, normalmente são montadas equipes e as tarefas
são divididas. São várias as áreas, mas vamos nos focar no Game Designer
e no Programador. O primeiro é a idéia por trás do jogo, é ele que cria o
jogo, mas sem contudo dizer COMO fazer na prática para essa ou aquela
coisa acontecer. Já o programador é quem vai pegar essa idéia e colocar em
prática e, dependendo das ferramentas e recursos que possuir, poderá até
adaptar ou vetar alguma coisa por ser inviável. Para evitar isso, é
importante que o Game Design tenha ao menos conhecimentos básicos
destas ferramentas.
Vou dar um exemplo: uma vez eu quis fazer um jogo de teste em
que o jogador atirava, mas a sua munição era limitada e acabava depois de
um tempo. Eu sabia que a engine permitia um jogo de tiro, mas
normalmente esses tiros são ilimitados. A idéia foi lançada, acabou a parte
do Game Design, agora entra o Programador pra ver o “COMO”. Bom, eu
descobri que no banco de dados de armas era possível desabilitar os tiros,
mas não havia um script que fizesse isso, e nem como desabilitar uma
tecla, então descobri um script que trocava a arma do atirador, então o que
fiz: cadastrei uma nova arma com os tiros desabilitados e outro que fazia a
troca quando a munição acabava. Esse foi o trabalho do programador.
Muitas vezes, em função da falta de recursos ou pessoal, a equipe
tem que ser reduzida e alguns assumem mais de uma função. É normal o
Programador também ser o Game design. Então, para que ele possa
cumprir bem as suas tarefas ele precisa conhecer bem os recursos e
limitações da sua engine, bem como a linguagem de programação usada,
assim ele não vai criar algo que depois não pode ser feito, seja porque é
realmente impossível ou muito complexo, ou ainda, porque vai pesar muito
na máquina...
Vamos então criar o nosso jogo pensando nesses conceitos. Faremos
um jogo de tiro (para isso existe um modelo pronto, inclusive com o
jogador, está em MD2). Neste jogo, teremos uma área para atirar e outra
onde faremos a recarga da arma, que descarregará. Usaremos um alvo
http://alemdanimacao.zip.net
Página 1
móvel para acertarmos. O jogo consistirá em acertar o alvo, outro ator MD2
(vou usar o espantalho sofredor, rsrsrsrs!), e para ganhar teremos que
acertar uma certa quantidade de tiros nele. Bom, isso é fácil, se a gente
tentar, tentar, vai acertar ele, uns mais rápido, outros mais devagar, mas
vamos acabar chegando à quantidade de acertos necessária para ganhar,
logo, nunca iremos perder! Então, vamos deixar interessante: o jogador
começa com certo número de tiros e eles vão acabando à medida em que
atiramos e, quando acabarem, temos que recarregar a arma. Aí, para ficar
legal, vamos estipular um número de recargas possíveis. Se você ficar sem
munição e as recargas estiverem esgotadas, acaba o jogo e você perde!
Viu, conhecendo um pouquinho da engine fizemos o nosso trabalho de
Game Designer e criamos um jogo viável, agora vamos ver o COMO fazer…
Agora é que entra o Programador (Eu mesmo, rsrsrs!).
Bom vamos então criar um novo projeto, para isso leia o TUTORIAL
01 – CRIANDO UM PROJETO:
http://www.eternix.com.br/pt/3dgamebuilder/Tutorial01.php
Crie uma pasta para ele em algum lugar do PC. Vamos chamá-lo de
Tiro Certo (ou outro nome qualquer!). Na hora de escolher o tipo, escolha
Shooter Dynamic Câmera Game, e como nome do primeiro mapa, escreva
INICIALIZAR. Esse mapa tem como função apenas analisar os dados
necessários e a partir dele iniciar o jogo. Agora vamos aos dados que
precisamos e como armazená-los.
1 – O nome do jogador, é legal personalizar ele.
2 – Sua localização no jogo, existirão duas áreas, uma para atirar e
outra para recarregar a arma.
3 – Qual a situação da sua munição
4 – Quantos tiros ele conseguiu acertar.
5 – Quantas recargas já fez.
6 – Quantos tiros foram disparados
Como você pode ver, o programador vai ter algum trabalho, rsrsrs, já
o modelador nem tanto, porque o 3D Game Builder já tem os modelos
necessários prontos! Vejamos agora como se armazenam dados num jogo;
existem duas formas, a interna, por meio de Variáveis Globais e a externa,
por meio de bancos de dados ou outros arquivos, como de texto. Vamos
nos ater apenas ao modo com banco de dados.
As variáveis globais são funções que armazenam valores DURANTE a
execução do jogo, elas são lidas e alteradas todo o tempo, em função de
eventos e scripts, mas uma vez terminado o jogo, elas voltam ao valor
inicial, isto é, aquele que foi gravado primeiramente. Por exemplo, se o seu
Página 2
jogador começar com 50 tiros e ao carregar ficar com 100, quando você
terminar e fechar o jogo, ao reabrir vai estar com os mesmos 50 tiros... Por
serem Globais, elas afetam todo o jogo e não apenas o mapa atual.
Para CRIAR ou MODIFICAR uma variável global, usamos o comando
WriteGlobalVar e para LER essa variável usamos o comando
ReadGlobalVar. Comumente criamos as variáveis no evento ON Create do
mapa, de tal forma que isso seja feito apenas um vez e só precisemos mexer
quando houver alteração.
Para suprir a deficiência da variável global, isto é, ser resetada a cada
fim de jogo, seus dados precisam ser armazenados externamente, é aí que
entra o banco de dados. O problema do banco de dados é que ele não é lido
todo o tempo pelo jogo, para ser acessado é necessário um complexo
processo de conexão com ele, e assim que lermos ou alteramos seus dados,
que ficarão então armazenados nas variáveis globais, durante todo o jogo,
temos que desfazer essa conexão para liberar a memória.
Por isso é necessário que o mapa inicial, o inicializar, cumpra essa
função. Quando o jogo estiver carregando, primeiro ele vai checar se o
banco de dados existe (senão vai dar erro!) e depois, se existir, vai ler os
seus dados e gravar nas variáveis globais e, quando acabar, irá desfazer a
conexão, liberando a memória (isso é feito no Evento On create desse
mapa) só voltando a refazer isso quando resolvermos salvar o jogo. Baixe o
banco de dados nesse link:
http://www.eternix.com.br/pt/3dgamebuilder/bd_exemplo.zip
Este arquivo é um banco de dados “Access” com apenas uma tabela
chamada de ator e que possui 3 campos: Id = Integer, Nome = String e
Energia = Integer.
Antes de criarmos os scripts, vamos criar mais alguns mapas, para
isso vá em Menu > Arquivo > Novo Mapa. Vamos chamar esse mapa de
ERRO. Esse mapa será chamado caso o banco de dados não seja
encontrado. Vamos criar um terceiro mapa, que chamaremos de GAME, ou
JOGO. É nele que a ação irá se desenvolver e será carregado caso a
verificação veja que o BD (Banco de Dados) existe, uma vez que seus dados
poderão ser lidos e copiados. Observe que o mapa um, o inicializar, só vai
existir enquanto ele estiver lendo os dados, porque se o BD não existir, o
mapa ERRO será carregado e nada mais poderá ser feito e se ele existir,
seus dados serão lidos, salvos nas variáveis globais e o mapa GAME será
carregado, iniciando o jogo. Temos então o primeiro, INICIALIZAR, o
segundo ERRO e o terceiro, GAME.
Antes de começarmos a fazer os scripts, precisamos entender algo
muito importante na linguagem, sobre conflitos; você sabe que as linhas de
código são numeradas, começando em 1 e se estendendo até sei lá quanto.
Página 3
Bom, imagine uma situação em que haja um conflito, isto é, dois comandos
que não poderiam existir ao mesmo tempo. Vou dar um exemplo: imagine
que você faz um script de inteligência artificial em que o espantalho corra
em direção a uma árvore e que ao chegar perto dela ele pare de correr e
faça uma careta. E imagine que você escreva um outro em que, ao chegar
perto de você, ele pare também e faça outro gesto. Até aí tudo bem, mas
imagine que você esteja ao lado da árvore! Ele vai chegar perto de vocês
dois, os dois scripts estão em conflito, qual ação executar, a da árvore ou a
de perto de você? Simples, a que estiver na linha de cima! Isso mesmo, em
scripts independentes, não importa a ordem, mas em outros, é importante
ver quem vem primeiro. Cuidado com isso! Eu fiz esse comentário porque
existirão outras instruções que devem obedecer uma certa ordem de
execução.
No mapa INICIALIZAR, devemos desabilitar o jogador porque não
tem sentido ele se mexer e, somente depois, vamos criar as variáveis
globais e escrever o script de leitura do banco de dados. Note que neste
mapa não existe GRAVAÇÃO de dados e sim somente leitura, a gravação
será feita durante o jogo, em outro mapa e de outra forma. Por isso, os
dados que serão lidos no BD devem inicialmente ser iguais ao Default, ou
seja, os dados iniciais do jogo, nome inicial, quantidade de munição, etc., e
esses mesmos valores devem estar nas variáveis.
Mãos à obra então. No primeiro mapa, o INICIALIZAR, vamos criar
um piso qualquer, só para que o jogador não caia no infinito. Para isso crie
um cubo, altere a escala dele assim: X=200, Y=1, Z=200. É o único objeto
a ser criado neste mapa. Se você fez tudo certo até aqui, seu jogo deve
estar assim:
Página 4
Agora vamos começar a criar os outros elementos dos outros
mapas. Nos mapas ERRO e GAME, faça a mesma coisa que foi feita
no mapa INICILIZAR, crie o cubo e altere a escala. A diferença é que
no mapa ERRO, a gente pára por aqui e no mapa GAME faremos mais
coisas.
Algumas coisas serão faladas com menos detalhes porque são
coisas básicas, que podem ser aprendidas lendo os tutoriais do site:
http://www.eternix.com.br/pt/3dgamebuilder/tutoriais.php
No mapa GAME, abra o banco de dados Materiais, clique em Grass e
altere o Texture Escale dele para 200 em X, Y, e Z. Depois, aplique esse
material ao cubo que você criou, ele vai ser o chão do jogo. Neste chão,
você vai criar dois cercadinhos, cada um com uma pequena passagem. Eles
serão os dois locais aonde o jogador irá ser posicionado. Para fazer as
paredes, basta fazer cubos, alterar a sua escala e aplicar algum material a
eles. Depois, selecione uma parede e clone ela quatro vezes usando o botão
direito do mouse e arrume elas formando o cercadinho, com a passagem no
canto de uma das laterais. Esse será o local do “tiro-ao-espantalho”.
Depois, pegue a parede original, DUPLIQUE ela usando o botão direito e
aplique outro material e a partir desta nova parede monte outro cercado do
lado, pode ser com a passagem no outro canto de uma das laterais, assim
dificulta um pouco chegar até o local da recarga, que ficará no centro desse
cercado. Aplique o Skybox default se quiser. Agora, vamos colocar no
primeiro cercado a nossa vítima, o ator MD2 default, o espantalho! Se você
fez tudo certo até aqui, seu jogo deve estar mais ou menos assim:
Página 5
Vamos fazer um script de inteligência artificial pra ele, a idéia é que
ele corra sem parar ao redor do cercado. Para isso, criaremos 4 events
área, um em cada canto do cercado do espantalho e criaremos um script de
movimentação cíclico. Como são 4 pilares, criaremos uma variável chamada
“Rota”, com 4 opções. A cada colisão com um pilar, essa variável terá seu
valor mudado. No início do jogo, no evento on create do mapa
INICIALIZAR, declararemos essa variável de um jeito que quando for lida,
faça o espantalho ir na direção do 1º pilar. Assim, não importa aonde
estiver o espantalho, ele vai começar o jogo correndo para o primeiro
ponto. Daí, quando ele colidir com o primeiro pilar, automaticamente a
variável muda e o programa, ao lê-la, vai apontar o espantalho para o 2º
pilar, quando bater no 2º corre pro 3º, quando bater no 3º corre pro 4º e
quando bater no 4º volta para o 1° e começa tudo de novo.
Eventos de colisão são fáceis de fazer quando é o jogador que colide
com o objeto. Para isso, basta fazer o script e colocar no evento OnCollision
do objeto, mas quando é algum objeto do jogo, no caso o espantalho, a
coisa muda, teremos que usar outras funções, a GetCollidedObject1 e a
GetCollidedObject2, no evento On Collision do mapa. Neste evento, a
cada colisão, a variável muda. Já no evento OnLoop do espantalho iremos
colocar o script de leitura dessas variáveis e seu efeito, isto é, um script que
mude a animação, a direção e a força aplicada sobre o espantalho a cada
valor da variável Rota.
Também precisamos criar dois events área, um na porta de cada
cercado, porque quando o jogador passar por ali é que haverá a mudança
de lugar, na variável responsável por marcar sua localização.
No centro do segundo cercado, colocaremos uma árvore, ela fará a
recarga, quando colidirmos. Se você fez tudo certo, seu mapa deve estar
assim:
Página 6
Os meus 4 events área, responsáveis pelo giro do espantalho, são,
começando da porta e girando em sentido anti-horário, respectivamente:
Objeto16, Objeto17, Objeto18 e Objeto6. O Espantalho é Ator1. Comecei
declarando a variável no evento ON Create do mapa INICIALIZAR:
WriteGlobalVar('Rota', 4);
Agora, no evento OnCollision do mapa GAME:
//---Begin Script Builder: Fazer o espantalho correr para o 2º pilar quando bater no 1º ---//
if (GetCollidedObject1 = 'Ator1') then
begin
if (GetCollidedObject2 = 'Objeto16') then
begin
end;
end;
begin
begin
end;
end;
//---End Script Builder---//
begin
begin
end;
end;
begin
begin
end;
Página 7
end;
begin
begin
end;
end;
begin
begin
end;
end;
begin
begin
end;
end;
begin
begin
end;
end;
Página 8
Agora, no evento OnLoop do espantalho (Ator1):
//---Begin Script Builder: Fazer o espantalho correr em volta do cercado---//
if ReadGlobalVar('Rota') = 4 then
begin
if GetObjectAnimation('Ator1') <> '02run0' then
SetObjectAnimation('Ator1', '02run0');
PointObjectTo('Ator1', 'Objeto16');
ApplyForce('Ator1', 3000, 0, 0);
end
else if ReadGlobalVar('Rota') = 1 then
begin
end
begin
end
begin
end;
Página 9
Observe que cada valor da variável faz com que o comando
PointObjectTo aponte para um objeto diferente, de tal modo que ele vá na
direção dele, colida e altere a variável, o que faz ele apontar para outro
objeto, ininterruptamente. O comando GetObjectAnimation é para escolher
a animação de correr e o ApplyForce é para aplicar força nele. Para testar,
verifique os scripts, salve. Depois vá em Menu > Projeto > Propriedades e
altere o mapa inicial para o mapa Game. Depois salve o mapa e rode o
jogo. O espantalho vai correr em volta de todo o cercado. Você já poderá
atirar nele, mas nada vai acontecer. Se quiser, também vá em projeto,
propriedades e na armas do jogador coloque no efeitos “Default”. O tiro vai
ficar estilizado, rsrsrsrs!
Vamos criar agora os comandos de mudança de mapa e
reconhecimento do banco de dados, que é o que nos interessa. Vá agora no
mapa INICIALIZAR, vamos declarar as variáveis que irão ser salvas no
banco de dados (lembre-se que já declaramos a variável Rota com o
comando: WriteGlobalVar('Rota', 4);):
Nome do jogador: WriteGlobalVar('IndicadorNome', 'Jogador');
Localização do jogador: WriteGlobalVar('IndicadorLocal', 1);
Munição restante: WriteGlobalVar('IndicadorBalas', 80);
Acertos no espantalho: WriteGlobalVar('IndicadorAcertos', 0);
Recargas Feitas: WriteGlobalVar('IndicadorRecargas', 0);
Disparos feitos: WriteGlobalVar('IndicadorDisparos', 0);
Essas variáveis serão mostradas por meio de Labels (indicadores
visuais) na tela do jogo. Além destas, precisamos de ainda mais uma
variável, que seria “ResultadoJogo”, que vai dizer se ganhamos ou
perdemos: WriteGlobalVar('ResultadoJogo', 0);
Esta variável não irá aparecer na tela, apenas o seu resultado no
jogo. Durante a execução do jogo, ela fica em 0. Se você ganha, ela muda
para 1 e, com isso, uma mensagem de vitória é exibida na tela. Se você
perde, ela muda para 2 e outra mensagem, de derrota, é exibida. Depois eu
vou mostrar como fazer o script para isso, mas é importante entender como
funciona.
O jogo consiste em acertar o espantalho algumas vezes. Você começa
batizando o seu jogador (IndicadorNome) e atirando. Como você irá
começar na arena 1, você estará no local 1 (IndicadorLocal). Você começa
com 80 balas e vai disparando. A cada tiro, a munição irá se consumindo, e
a munição restante vai sendo mostrada no Label (IndicadorBalas). Quando
ela chega em 0, você não consegue mais atirar e precisa recarregar. Aí vai
ter que sair da Arena 1 e ir para a Arena 2, onde tem o carregador. Quando
Página 10
entrar nessa arena 2, vai pisar no event área que tem na porta, e a sua
localização irá mudar para 2 (IndicadorLocal). Ao chegar no centro dessa
arena, onde tem a árvore, ele irá colidir com ela e isso recarregará a arma,
fazendo com que a variável IndicadorBalas volte a 80. Aí você volta para a
Arena 1 e automaticamente pisa no event área da porta, alterando a
variável IndicadorLocal para 1. Todos os tiros que você der serão
registrados pela variável IndicadorDisparos. Para ganhar o jogo e fazer a
variável ResultadoJogo mudar de 0 para 1, basta acertar 15 tiros no
espantalho, antes de ficar sem munição. Você terá direito a 2 recargas. Se
a variável IndicadorRecargas estiver em 2 e a sua munição chegar a 0 (você
terá gasto 240 balas, 80 iniciais mais 160 resultantes das 2 recargas a que
tem direito), e você não tiver acertado 15 tiros no espantalho, a variável
ResultadoJogo muda para 2, o jogo trava e a mensagem FIM DE JOGO é
exibida.
O script então, no Evento OnCreate do mapa INICIALIZAR, está
assim por enquanto:
WriteGlobalVar('IndicadorNome','Jogador');
WriteGlobalVar('IndicadorLocal', 1);
WriteGlobalVar('IndicadorBalas', 80);
WriteGlobalVar('IndicadorAcertos', 0);
WriteGlobalVar('IndicadorRecargas', 0);
WriteGlobalVar('IndicadorDisparos', 0);
WriteGlobalVar('ResultadoJogo', 0);
Essas variáveis serão salvas no banco de dados ao clicarmos em um
botão que iremos criar. Salvaremos todos os dados e a posição do jogador
também. Quando o jogo iniciar esses dados serão lidos e reprogramados
nas variáveis, de tal forma que se salvarmos o jogo com 40 balas, ao abrir,
estaremos com as mesmas 40 balas. Se estivermos na arena 2, iremos
começar o jogo na arena 2, e assim por diante. Quando terminarmos o
jogo, perdendo ou ganhando, isto é, com a variável ResultadoJogo sendo
maior do que 0, o jogo automaticamente salva os dados originais no banco
de dados, isto é, a munição volta a 80, as recargas a 2, etc... Desta forma,
você pode ver que a hora que quiser pode parar o jogo no estado em que
está e voltar depois, recomeçando de onde parou.
Vamos agora trabalhar nosso banco de dados. Primeiro renomeie ele
para BD_TIRO. Depois, abra ele, e no campo (coluna) ID, coloque na
primeira linha 1, na segunda 2 e na terceira 3, automaticamente será criada
uma quarta linha com zero, mas não se preocupe.
Página 11
Altere o nome “Teste” na primeira linha do campo Nome para
“Jogador”. Nesta mesma linha, no campo Energia, vamos gravar o valor da
variável IndicadorLocal como 1.
Agora vamos para a linha 2. No campo Nome desta linha, grave o
valor da variável IndicadorBalas, 80, e no campo Energia o valor da variável
IndicadorAcertos, 0.
Finalmente, vá para a linha 3 e no campo Nome desta linha, grave o
valor da variável IndicadorRecargas, 0 e no campo Energia o valor da
variável IndicadorDisparos, 0. Salve e feche. Coloque esse banco no Disco
local “C:”. Com isso, você tem os valores iniciais que precisa para trabalhar,
tanto nas variáveis globais que vai declarar, quanto no banco de dados.
Note que a primeira e a última não precisam ser gravadas, a primeira é só
pra dar a partida no espantalho, depois ele se vira sozinho, isso nunca
muda, acontece somente DURANTE o jogo, e a última é o resultado do jogo,
que só poderá mudar DURANTE o jogo, e uma vez alterada, ela mesma se
encarrega de alterar os valores do banco de dados, resetando tudo.
Vamos agora criar no jogo os labels e elementos que irão exibir as
mudanças de variáveis (pra você ver como mudam e como são salvas!).
Veja bem, o posicionamento desses elementos pode variar, mas eles
precisam existir. Vá no menu Objetos > GUI Objects. Eu optei por colocar
duas placas embaixo, à esquerda eu criei um objeto tipo Panel, com 120 x
200, e sobre ele coloquei os 6 indicadores que preciso, usando LB Labels
(batizei seus nomes com os mesmos das variáveis pra facilitar):
IndicadorNome (nome do objeto) – JOGADOR: (caption, nome na tela)
IndicadorLocal – ARENA:
IndicadorBalas – MUNIÇÃO:
IndicadorAcertos – ACERTOS:
IndicadorRecargas – RECARGAS:
IndicadorDisparos – DISPAROS:
IndicadorAcertos – ACERTOS:
À direita, embaixo, eu criei um objeto Form, com 120 x 200,
modifiquei o Caption (o texto exibido) para “SALVAR DADOS” e sobre ele
coloquei um objeto tipo Edit com Caption “NOVO NOME” e um Button, com
o Caption “SALVAR”. Posicionei eles de tal forma que, durante o jogo, eles
não comprometam a visão geral, mas é possível depois ocultar esses
objetos. Se você fez tudo certo até aqui, seu projeto deve estar assim:
Página 12
Eu posicionei eles de tal forma que na janela do jogo cada um fique
num cantinho embaixo. Está na hora de começar a fazer o jogo começar de
forma certa, pelo mapa INICIALIZAR. Mas então já teremos que ter um
script que mude o mapa para o mapa GAME, onde vai acontecer jogo.
Vamos colocar também um script pra mudar o nome “GAME” que aparece
em cima da janela, usando a função SetWindowCaption.
Vamos também já fazer um script PROVISÓRIO de mudança de
mapa, isto é, porque ainda não fizemos o script de leitura do banco, apenas
ele checa se o banco existe ou não. Se ele existe, carrega o mapa GAME, se
não existe, carrega o mapa ERRO. O código completo, no evento ON
CREATE do Mapa INICIALIZAR, por enquanto ficou assim:
SetWindowCaption('TIRO CERTO');
DisablePlayerMove;
Página 13
if (FileExists('C:\BD_TIRO.mdb')= false) then
begin
ShowLoadingScreen('LoadScreen', '', 0, 0);
LoadMap('ERRO.gbm', 0, 3, 0, 10);
end
else if (FileExists('C:\BD_TIRO.mdb')= true) then
begin
LoadMap('GAME.gbm', 0, 3, 0, 10);
end;
A função “FileExists” checa se o banco de dados BD_TIRO está
mesmo no disco local “C:” e retorna verdadeiro ou falso. Se falso, carrega
uma textura qualquer (crie um material cadastrado com o nome de
LoadScreen) e o mapa ERRO (veja o tutorial de mudança de mapa:
http://www.eternix.com.br/pt/3dgamebuilder/Tutorial13.php ). Se retornar
verdadeiro, o mapa GAME é carregado. Note que a segunda instrução deste
mapa é o comando DisablePlayerMove, que paralisa o jogador, que não tem
que fazer nada neste mapa. Então, se o mapa erro for carregado, como lá
não acontece nada também, não precisamos reabilitar o Player, mas se o
mapa GAME for carregado, precisamos reativá-lo. Para isso, no evento ON
Create do mapa Game coloque o seguinte comando:
EnablePlayerMove;
Desta forma, o Player será reativado.
Já podemos ir nas propriedades do projeto e colocar como mapa
inicial o INICIALIZAR. Se você tirar o BD_TIRO do disco local C:, o jogo não
iniciará, mas se deixar, ele vai iniciar e ficará assim:
Página 14
Vamos começar a fazer as variáveis aparecerem na tela. Uma vez
que elas já existem, vamos fazer com que os LB labels as mostrem. Para
isso, você deve colar os seguintes códigos no evento MainLoop do mapa
GAME (esse evento ocorre durante todo o jogo):
//---Mostrar as variáveis nos Labels correspondentes---//
SetLabelText('IndicadorNome', 'JOGADOR:' +ReadGlobalVar('IndicadorNome'));
SetLabelText('IndicadorLocal', 'ARENA:' +IntToStr(ReadGlobalVar('IndicadorLocal')));
SetLabelText('IndicadorBalas', 'MUNIÇÃO:' +IntToStr(ReadGlobalVar('IndicadorBalas')));
SetLabelText('IndicadorAcertos', 'ACERTOS:' +IntToStr(ReadGlobalVar('IndicadorAcertos')));
SetLabelText('IndicadorRecargas', 'RECARGAS:' +IntToStr(ReadGlobalVar('IndicadorRecargas')));
SetLabelText('IndicadorDisparos', 'DISPAROS:' +IntToStr(ReadGlobalVar('IndicadorDisparos')));
Observem a segunda linha; SetLabelText é o comando para mostrar
no label um texto. O primeiro nome IndicadorLocal é o nome do meu objeto
label (lembra que renomeamos eles pra ficar mais fácil de achar?), a
palavra ARENA: é o texto que já existe lá e ao invés de modificá-lo, apenas
acrescentamos o texto complementar, igual ao valor da variável (por isso
tem o sinal de “+”). Como essas variáveis estão exibindo números
(Integer), eles precisam ser convertidos para o formato correto de string,
pra isso tem o comando IntToStr. Finalmente, o valor a ser convertido é o
da variável IndicadorLocal, que é lido através do comando ReadGlobalVar.
Eu falei da segunda linha, porque ela é igual às outras quatro que vem logo
abaixo, todas tem o comando IntToStr, menos a primeira linha. Isso
acontece porque o valor da variável IndicadorNome não é um número
(Integer) e sim uma String, e por isso é lido direto, sem necessitar de
conversão. Olha que lindo que ficou com os valores nos Labels:
Página 15
Bom, agora vamos criar os eventos que irão alterar as variáveis. É o
último passo antes de gravá-los e lê-los no banco. Vamos começar com os
fáceis, alterar a variável IndicadorLocal (isso porque mudar o nome do
jogador implica num comando mais chato). Para mudar a variável é só ir
colocar o comando de alteração no evento oncolision dos events área que
ficam nas passagens dos cercados. Vá no evento oncolision do event área
na porta da Arena 1, onde está o espantalho, e coloque o código:
Depois, vá no evento oncolision do event área na porta da Arena 2,
onde está a árvore, e coloque o código:
Rode o jogo e passe de um cercado para o outro e observe a
mudança no label ARENA! Esse é um bom exercício com variáveis.
Vamos então criar o restante dos scripts que tem a ver com os tiros.
Antes disso, devemos criar uma nova arma para o atirador, só que sem
balas! Para isso, clique no link e baixe o arquivo shooteractor:
http://www.eternix.com.br/temp/shooteractor.rar
Esse arquivo possui os arquivos MD2 do atirador e sua arma. Descompacte
os dois dentro da pasta raiz do seu jogo, ou dentro da pasta data ou ainda,
crie uma nova pasta. Depois, vá em Menu > Projeto > Armas do ator
principal. Nesse editor, crie uma nova arma, chame de Arma02 e com o
botão LOAD localize o arquivo Shotgun.md2. Depois, vá até o a caixa Tiro e
em enabled marque false. Com isso, essa nova arma fica sem poder atirar.
Vamos fazer agora o script que fará com que a cada tiro a variável
global IndicadorAcertos seja alterada. É parecido com aquele de colisão do
espantalho com os pilares (events área) e também deve ser colocado no
Evento ON Collision do mapa GAME (depois do script de colisão do
espantalho com os pilares, que já está lá):
//---Begin Script Builder: Alterar a Variável Global IndicadorAcertos em função de cada acerto no
espantalho---//
if Copy(GetCollidedObject1(), 0, 6) = 'Bullet' then
begin
begin
WriteGlobalVar('IndicadorAcertos', ReadGlobalVar('IndicadorAcertos')+1);
end;
end;
Página 16
begin
if (GetCollidedObject1 = 'RoboPrincipal') then
begin
end;
end;
O script analiza a colisão entre o objeto disparado pelo jogador
(Bullet) e o nosso espantalho, o Ator1. A cada colisão, a variável
IndicadorAcertos
passa
a
ser
igual
à
leitura
dela
mesma
ReadGlobalVar('IndicadorAcertos') com 1 (+1). É assim que alteramos
(WriteGlobalVar) a variável a cada evento, poderia ser +10, -3, etc...
Rode o jogo e teste. Ah, uma observação, durante esse tutorial,
nosso 3D Game Builder foi atualizado da versão 1.5, onde começamos, para
a 1.6. Com isso, não podemos mais usar “Ç” e nem acentos, então o nome
“MUNIÇÃO” que estava no Label virou “MUNIO”, então teremos que alterar
ele para BALAS, no Caption do Label! Se você fez tudo certo até aqui, ao
acertar o espantalho você verá o Label ACERTOS mudar de 0 para 1 e assim
sucessivamente a cada acerto:
Página 17
Vamos mexer agora na variável IndicadorDisparos. E também na variável
IndicadorBalas, uma vez que ambas dependem do mesmo evento, ou seja,
o disparo do tiro. Enquanto a IndicadorDisparos vai aumentar, a
IndicadorBalas vai diminuir até chegar em 0. Como esse evento se
desenrola durante o jogo, esse script deve ser colocado no evento MainLoop
do mapa GAME:
//---Begin Script Builder: Descarregar a arma e alterar as variáveis Indicador Disparos e Indicador Balas
conforme a execução da animação attack---//
if (ReadGlobalVar('IndicadorBalas') >0) and (ReadGlobalVar('IndicadorBalas') <=80) then
begin
If (GetObjectAnimation('mainActor') ='attack') then
begin
WriteGlobalVar('IndicadorDisparos', ReadGlobalVar('IndicadorDisparos')+1);
end
end;
if (ReadGlobalVar('IndicadorBalas') >0) then
begin
begin
WriteGlobalVar('IndicadorBalas', ReadGlobalVar('IndicadorBalas')-1);
end
end;
Funciona assim: primeiro ele checa se a variável está entre os valores
0 e 80, menos que isso não pode disparar por falta de munição e mais que
isso não pode porque é o máximo possível. O termo “and” quer dizer “e” e
diz que as duas condições precisam ser respeitadas para que a ação ocorra.
Se ambas estão satisfeitas, ele checa a animação do ator principal e se for
“attack”, ela altera a variável IndicadorDisparos somando 1 a cada disparo.
Note que esse script poderia ser feito em função de teclarmos a barra de
espaço, que é responsável pelo tiro, para isso usaríamos o comando
IsKeyPress, mas ocorre um problema porque essa tecla tem um nome
esquisito, 0x20, e se usamos esse termo no script, a verificação o rejeita...
Então, para contornar isso, usamos a referência da animação attack, afinal
toda vez que o jogador vai disparar, ele precisa executar ela!
Página 18
Bom, agora que fizemos o indicador disparos aumentar a cada tiro,
vamos fazer com que a munição acabe, e para isso tem a segunda parte do
script;
primeiro
ele
checa
se
tem
balas
ainda
(if
(ReadGlobalVar('IndicadorBalas') >0 ), se tiver, a cada tiro (execução da
animação attack), ele diminui a variável IndicadorBalas em -1. Se você fez
tudo certo, vai observar que a cada tiro, o label MUNIO (aqui ocorreu um
pequeno BUG, eu alterei o caption do label para BALAS, mas durante a
execução do jogo ele não mudou, depois eu tento deletar esse label e
colocar outro pra ver se resolve...) diminui e o Disparos aumenta! Se você
acertar o espantalho sofredor, o label ACERTOS vai contar seus pontos. Mas
você vai ver algo estranho, apesar da contagem estar certa, quando
acabarem as balas (80 disparos), não haverão mais alterações nos Labels,
mas o jogador continuará disparando, e é para isso que vamos criar agora
um script que troque a arma dele por uma arma descarregada assim que
acabar a munição (lembra que você criou uma Arma02, com os tiros
desabilitados?). Ainda no evento MainLoop do mapa GAME, copie e cole
esse script:
//---Begin Script Builder: Desabilitar disparos da Arma quando descarregada---//
if (ReadGlobalVar('IndicadorBalas') <= 0) then
begin
LoadMainActorWeapon('Arma02');
end;
Observe que enquanto a variável IndicadorBalas estiver > 0, a arma
usada é a Arma01, que tem seus disparos habilitados, e assim que ela
chega em 0, uma nova arma é carregada, a Arma02, que não pode atirar,
por meio do comando LoadMainActorWeapon. Agora acaba a munição e ele
não pode mais atirar.
Experimente atirar até acabar a munição, ele tem que parar de atirar.
Bom, agora vamos ao evento que vai recarregar a arma. Lembra que
isso aconteceria ao colidirmos com a árvore? Então vamos a ela, selecione-a
e clique em Eventos > OnCollision e cole o seguinte script:
//---Begin Script Builder: Recarregar a arma SE estiver descarregada e contar as recargas, com um
limite de 2---//
if (ReadGlobalVar('IndicadorBalas') < 80) then
begin
if (ReadGlobalVar('IndicadorRecargas') <2) then
begin
Página 19
WriteGlobalVar('IndicadorRecargas', (ReadGlobalVar('IndicadorRecargas')+1));
end
end;
Esse script faz o seguinte: primeiro ele checa se a variável é menor
que 80 (if (ReadGlobalVar('IndicadorBalas') < 80)), isto é, você está com
arma abaixo da carga máxima. Note que mesmo que ela não esteja
totalmente descarregada você poderá fazer uma recarga. Se ela estiver
cheia, não, o evento não pode ocorrer. Isso é bom pra evitar que a colisão
faça a variável IndicadorRecargas disparar feito doida. Então cuidado pra
não desperdiçar munição recarregando tendo ainda algumas balas!
Depois ele checa se você não estourou o limite de recargas, que é 2 (if
(ReadGlobalVar('IndicadorRecargas') <2)). Você só pode recarregar se não
tiver feito nenhuma, 0 ou tiver feito só 1. Se essas condições foram
satisfeitas, então a variável IndicadorRecargas vai ter somado a ela o valor
1(WriteGlobalVar('IndicadorRecargas', (ReadGlobalVar('IndicadorRecargas')+1));)
a arma será recarregada porque a variável IndicadorBalas terá seu valor
alterado pra 80 (WriteGlobalVar('IndicadorBalas', 80);) e a Arma01 é
carregada por meio do script: LoadMainActorWeapon('Arma01'); .
Vamos então aos testes:
1 – Inicie o jogo e não dê nenhum tiro. Vá até a árvore e colida com ela.
Nada deve acontecer.
2 – Dê alguns tiros e antes que a munição se acabe, colida com a árvore; a
munição deve ser recarregada até 80, indicando no Label Munio:80, e a
variável IndicadorRecargas vai mudar pra 1, também indicado no Label
Recargas.
3 – Agora que você viu que pode recarregar, descarregue a arma mais uma
vez e observe que não consegue mais atirar. Aí, colida de novo com a
árvore, recarregando novamente a arma. Note que o Label Recargas vai
mudar pra 2.
4 – Você está no limite das recargas, então descarregue a arma de novo e
tente colidir com árvore novamente. Você não poderá mais recarregar...
Se os testes deram certo, você deverá ver os Labels mais ou menos
assim:
Página 20
Observe que o label Disparos chegou a 124. O que limita ele é apenas
a sua munição.
Você deve estar se perguntando o que aconteceu com a árvore! Será
que o tutorial demorou tanto pra sair que ela secou? KKKKK! Não, é que o
Edirlei me explicou que a árvore do jogo é bastante pesada, então, para
economizar minha pobre CPU, eu optei por essa árvore seca! Só copiei o
evento OnCollision dela para esta nova árvore. E o Label Munio ainda
continua errado...
Bom, com isso já criamos todos os eventos para o funcionamento do
jogo (pode ser jogado, mas não salvo), exceto um, que é o resultado do
jogo. Bom, vamos criar então mais 3 GUI Objects. Um é um Panel de 80 x
300. Nele coloquei 2 Labels, em cima coloque: “VOCÊ VENCEU O JOGO!” e
embaixo coloquei: “FIM DE JOGO! VOCÊ PERDEU!” Veja como ficou:
Página 21
Para que esses novos elementos não sejam mostrados, vá até o
evento ONCreate do mapa GAME e cole o seguinte script:
//---Begin Script Builder: Ocultar as mensagens de final de jogo---//
HideObject('Panel0');
HideObject('Label0');
Esses são os nomes dos 3 novos GUI Objects que eu criei. Antes de
fazer o script do resultado do jogo, vamos agora ao que mais interessa, que
é lidar com o banco de dados. Vamos criar agora um script de leitura dele,
que vai transferir os dados para as variáveis.
É importante que você entenda o processo de desenvolvimento do
jogo e não apenas decore códigos. Até aqui você viu que existem elementos
que não precisam ser salvos e outros que sim. Aqueles elementos que você
quer salvar devem ser traduzidos para variáveis globais. Se você quer que o
personagem tenha magia, coloque um valor em uma variável, se quer
salvar a posição, marque posições estratégicas e grave na variáveis, se ele
muda de estado (paralizado ou não), o evento também pode ser traduzido
como uma variável. É isso que você tem que entender, antes de tentar
salvar algo, defina como armazenar a informação em forma de variável e
depois sim salve. Vamos começar com a leitura dos dados. Esse evento é
colocado no evento On Create do primeiro mapa, o INICIALIZAR. Esse script
é baseado no tutorial 15 e muitas explicações serão copiadas dele:
http://www.eternix.com.br/pt/3dgamebuilder/Tutorial15.php
Bom, nós já alteramos o nosso banco de dados e salvamos no disco local
C:\. Veja como ele deve estar:
A idéia é criar primeiro checar a existência dele, se não existir
carregamos o mapa erro. Depois, se ele existir, fazemos a conexão, lemos,
alteramos as variáveis e fechamos. Depois, se tudo estiver certo,
carregamos o mapa GAME. Vou escrever o primeiro script e depois explicar,
porque temos que testá-lo antes de passar para uma segunda etapa, que é
posicionar o jogador ora num local, ora em outro. Copie e cole esse código
Página 22
no evento ON Create do Mapa INICIALIZAR substituindo tudo que estava lá
antes:
DisablePlayerMove;
begin
end;
if (FileExists('C:\BD_TIRO.mdb')= true) then
begin
var Conn: TADOConnection;
var DataSet: TADODataset;
Conn:=TADOConnection.Create('Provider=Microsoft.Jet.OLEDB.4.0;Data
Source=C:\BD_TIRO.mdb;');
DataSet:=Conn.Execute('select nome, energia from ator where id = 1');
if DataSet.RecordCount <> 0 then
begin
WriteGlobalVar('IndicadorNome', DataSet.FieldAsString[0]);
WriteGlobalVar('IndicadorLocal', DataSet.FieldAsVariant[1]);
end;
Página 23
begin
WriteGlobalVar('IndicadorBalas', DataSet.FieldAsVariant[0]);
WriteGlobalVar('IndicadorAcertos', DataSet.FieldAsVariant[1]);
end;
begin
WriteGlobalVar('IndicadorRecargas', DataSet.FieldAsVariant[0]);
WriteGlobalVar('IndicadorDisparos', DataSet.FieldAsVariant[1]);
end;
DataSet.free;
Conn.free;
end;
Vamos agora analisar o script linha por linha:
Muda o nome Game da janela do jogo na execução.
DisablePlayerMove;
Desabilita o jogador, não é necessário movimentos nesse mapa.
Página 24
Conforme explicado antes, são as declarações das variáveis que precisamos
begin
end;
Conforme explicado antes, se o arquivo do banco de dados não existir, o mapa
ERRO é carregado.
begin
Se banco de dados for localizado, executar o seguinte script (conexão com o BD):
(Declara um objeto do tipo “TADOConnection”, ele é responsável pela
conexão com o banco de dados)
(Declara um objeto do tipo “TADODataSet”, ele é responsável por utilizar os
dados provenientes da conexão)
(Cria o objeto “Conn” definindo a String de conexão com o banco de dados,
esta string de conexão é a mesma utilizada pelos objetos da paleta “ADO”
ou
“DBGo”
do
Delphi,
no
exemplo
utilizei
o
provider
“Microsoft.Jet.OLEDV.4.0” e o caminho para o arquivo no parâmetro “Data
Source”, existem outros parâmetros que podem ser utilizados, como por
exemplo o usuário e senha do banco, para saber mais sobre estes
parâmetro consulte a ajuda do Delphi ou algum outro documento disponível
na internet). Observe o caminho para o arquivo, C:\ , o nome e a extensão,
tem que estar tudo certinho.
(Inicializa o objeto “DataSet” definindo a String do comando SQL que será
executado pelo objeto “Conn” no banco de dados, no comando SQL é
selecionado o campo “nome” e “energia” do registro com o “id = 1” da
tabela ator). Observe que para cada linha (id) tem um comando desses.
Página 25
(Caso a consulta tenha retornado algum registro para o “DataSet”, isto é,
se existe algo lá, mesmo que seja 0)
begin
(Utiliza o comando “WriteGlobalVar” para alterar a variável IndicadorNome
com o valor já como String na posição 0 do “DataSet”. Note que para string
(nome) usei o comando FieldAsString para ler os dados no banco)
(Utiliza o comando “WriteGlobalVar” para alterar a variável IndicadorLocal
com o valor já como Variant na posição 1 do “DataSet”. Note que para
Variant (número) usei o comando FieldAsVariant para ler os dados no
banco)
end;
begin
(Utiliza o comando “WriteGlobalVar” para alterar a variável IndicadorBalas
banco)
(Utiliza o comando “WriteGlobalVar” para alterar a variável IndicadorAcertos
banco)
end;
Página 26
begin
(Utiliza
o
comando
“WriteGlobalVar”
para
alterar
a
variável
IndicadorRecargas com o valor já como Variant na posição 1 do “DataSet”.
Note que para Variant (número) usei o comando FieldAsVariant para ler os
dados no banco)
(Utiliza
o
comando
“WriteGlobalVar”
para
alterar
a
variável
IndicadorDisparos com o valor já como Variant na posição 1 do “DataSet”.
Note que para Variant (número) usei o comando FieldAsVariant para ler os
dados no banco)
end;
DataSet.free;
(Destrói o objeto “DataSet” liberando-o do da memória)
Conn.free;
(Destrói o objeto “Conn” liberando-o do da memória)
end;
Depois de todas as variáveis atualizadas, carrega o mapa GAME. Até então
eu não estou usando script pra posicionar o ator principal. Para isso, usarei
as coodenadas X,Y e Z que tem logo após nome do mapa. Se eu quisesse
posicionar outro objeto, usaria o comando SetObjectPosition. Estude o tutorial
http://www.eternix.com.br/pt/3dgamebuilder/Tutorial15.php e analise quais
elementos eu usei e quais eu alterei para chegar ao resultado que eu quis.
Antes de posicionar o Player, vamos testar o script para ver se está
tudo certo. Lembra dos valores que gravamos no banco? Se tudo estiver
certo, eles tem que alterar as variáveis e mostrá-las nos labels:
Página 27
Bom, parece que está tudo certo, mas como os valores do banco são
os mesmos das variáveis, talvez ele não esteja lendo nada, apesar do script
ter sido aprovada pela verificação. Para testar, o único jeito é alterar os
dados no banco e rodar o jogo. Então, abra o banco e altere os dados
assim:
Se tudo estiver certo, quando rodarmos, esses novos valores terão
que aparecer:
Página 28
Bingo! Os valores foram alterados! Logo, a conexão e a leitura do
banco de dados foi perfeita, as variáveis gravadas no banco alteraram as do
jogo! Agora, vamos fazer a última instrução do mapa INICIALIZAR, que é
carregar o mapa GAME com a posição do jogador principal ora num lugar,
ora no outro. Isso é feito por meio da análize da variável IndicadorLocal. O
valor 1 indica a arena 1, do espantalho, e o valor 2 a arena 2, da árvore.
Quando termina a leitura do banco, a conexão se fecha e as variáveis
estão prontas para serem usadas. Então, basta fazer um script em função
dela; antes, porém, é necessário anotar a posição onde queremos que o
jogador apareça. Nas propriedades do projeto, o valor X=0, Y=3 e Z=0. Y é
a altura, então não vamos mexer, apenas em X e Z. Para isso, crie um cubo
e coloque ele onde você quiser que o jogador apareça no mapa 1. Depois
anote as suas coordenadas. Então, faça o mesmo na arena 2 e anote. Para
a Arena 1 eu achei X= -11 e Z=3. Na Arena 2 eu achei X=-14 e Z=33.
Então, no evento ON Create do mapa INICIALIZAR, substitua o script de
carregar o mapa game que está lá (LoadMap('GAME.gbm', 0, 3, 0, 10);) por esse:
if (ReadGlobalVar('IndicadorLocal') =1) then
begin
LoadMap('GAME.gbm', -11, 3, 3, 10);
end
else if (ReadGlobalVar('IndicadorLocal') =2) then
begin
LoadMap('GAME.gbm', -14, 3, 33, 10);
end;
Com isso fechamos o script. Se a variável está em 1, carrega-se o
mapa Game com o jogador na posição -11,3,3. Se a variável está em 2, a
posição muda para -14,3,33. Para testar isso, rode o jogo com a variável
IndicadorLocal em 1 e veja onde o Player vai aparecer. Depois, feche o
jogo, abra o banco de dados e na primeira linha, campo energia, altere o
valor de 1 para 2. Salve e feche. Agora rode o jogo e veja onde ele aparece!
Com isso você pode ver que podemos salvar a posição de objetos do jogo,
basta que essas posições sejam gravadas em variáveis globais e existam
scripts que as leiam corretamente.
Agora que criamos o script de leitura de dados, vamos fazer o de
gravação. Esse script vai ser feito no evento On Interact do botão salvar.
Basicamente, bastaria gravar todas as variáveis globais no banco de dados.
Mas para complicar nossa vida eu incluí um campo que permite alterar esse
nome e ele também é salvo, na forma de variável Global. Então, o processo
é gravar primeiro o nome na variável e depois, no mesmo evento,
Página 29
estabelecer a conexão com o banco, gravar os dados (inclusive do nome
novo) e desfazer a conexão.
Para que esse assunto possa ser compreendido, vamos fazer o script
em duas partes, primeiro vamos apenas lançar o novo nome na variável
global IndicadorNome e testar. Para isso, clique no botão salvar que você
criou e no evento oninteract copie e cole esse script:
WriteGlobalVar('IndicadorNome', GetEditText('Objeto20'));
Lembre-se que Objeto20 é o nome do meu objeto tipo Edit, onde
você vai escrever o nome. Se o seu tiver outro nome, mude. Salve e rode o
jogo. Depois, vá nele, onde está “NOVO NOME” e escreva um nome
qualquer e clique em salvar. Você vai ver que o Label JOGADOR: vai exibir
o mesmo nome que você digitou. Você pode fazer isso a qualquer hora.
Significa que o nome foi gravado na variável Global IndicadorNome, cujo
valor é a leitura do comando GetEditText, mas só vai ficar lá durante o
jogo. Quando ele for encerrado e aberto de novo, o nome que vai aparecer
é aquele que está salvo no banco de dados, “Jogador”. Veja como ficou:
Finalmente, vamos partir para o script que vai gravar as variáveis
globais no banco de dados. Ele vai ficar no mesmo evento oninteract do
botão salvar, só que depois desse que já colocamos. Lembre, primeiro
grava na variável e depois no banco. Esse script é uma variação daquele
outro de leitura, primeiro a gente estabelece uma conexão com o banco de
dados, grava as variáveis e desfaz a conexão. Aí, uma vez com tudo salvo
Página 30
no banco, da próxima vez em que ele for iniciado, durante o carregamento
do mapa INICIALIZAR, os dados serão retransferidos para as variáveis. Vou
colocar o script e depois explicar; copie e cole todo esse código substituindo
tudo o que estiver no evento Oninteract do seu botão salvar:
//---Begin Script Builder: Alterar a Variável Global IndicadorNome com o nome do jogador e gravar as 6 variáveis no
banco de dados antes do encerramento do jogo---//
if (ReadGlobalVar('ResultadoJogo') =0) then
begin
Conn:=TADOConnection.Create('Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\BD_TIRO.mdb;');
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorNome')) + ' where id = 1');
Conn.ExecuteSQL('update ator set energia = ' + QuotedStr(ReadGlobalVar('IndicadorLocal')) + ' where id = 1');
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorBalas')) + ' where id = 2');
Conn.ExecuteSQL('update ator set energia = ' + QuotedStr(ReadGlobalVar('IndicadorAcertos')) + ' where id = 2');
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorRecargas')) + ' where id = 3');
Conn.ExecuteSQL('update ator set energia = ' + QuotedStr(ReadGlobalVar('IndicadorDisparos')) + ' where id = 3');
Conn.Close;
Conn.Free;
end;
//---Begin Script Builder: Alterar a Variável Global IndicadorNome com o nome do jogador e gravar as 6 variáveis no
banco de dados antes do encerramento do jogo---//
begin
Checa a variável ResultadoJogo para ver se o jogo ainda não foi finalizado. Se o
jogador ganha ela muda pra 1 e se perde muda pra 2. Com a finalização do jogo e
a mudança da variável, não é possível salvar mais nada e o jogo é resetado
automaticamente.
Altera a variável IndicadorNome em função do texto que está no Objeto20, por
meio do comando GetEditText
(Declara um objeto do tipo “TADOConnection”, ele é responsável pela conexão com
o banco de dados)
Página 31
(Cria o objeto “Conn” definindo a String de conexão com o banco de dados assim
como foi explicado anteriormente no script de leitura de dados)
(Utiliza a conexão para executar um comando SQL de update para alterar o registro
no campo “nome” com o “id=1” (linha 1) para o valor que for lido na variável
IndicadorNome e adaptado corretamente pelo comando QuotedStr)
no campo “energia” com o “id=1” (linha 1) para o valor que for lido na variável
Conn.Close;
(Fecha a conexão com o banco de dados)
Conn.Free;
end;
Finalmente finalizamos esse script de salvamento, mas ainda não terminou.
Isso porque o jogo ainda não pode ser finalizado. Farei agora o último script, aquele
que altera a variável ResultadoJogo. Não basta apenas mostrar as mensagens, é
necessário que os valores originais sejam restaurados, as recargas fiquem em 0, os
disparos fiquem em 0, etc... Só o nome é que não vou resetar. Esse é um script
que ocorre durante o jogo, logo deverá ser colocado no evento MainLoop do mapa
Página 32
GAME. Basicamente temos que primeiro alterar a variável ResultadoJogo e depois,
em função dela, fazer as outras funções, que é paralisar o Jogador, mostrar as
mensagens e resetar os valores NO Banco de dados, eles não vão aparecer nos
Labels, exceto quando o jogo for reiniciado. Vamos a ele então (esse script deve
ser colocado após o script que já está no evento mainloop do mapa GAME):
//---Begin Script Builder: Alterar a variável ResultadoJogo para 1 em caso de vitória e 2 em caso de
derrota---//
if (ReadGlobalVar('IndicadorAcertos') =15)
(ReadGlobalVar('IndicadorBalas') >=0) then
and
(ReadGlobalVar('IndicadorRecargas')
<2)
and
begin
end
else if (ReadGlobalVar('IndicadorAcertos') =15) and (ReadGlobalVar('IndicadorRecargas') =2) and
(ReadGlobalVar('IndicadorBalas') >0) then
begin
end
else if (ReadGlobalVar('IndicadorAcertos') <15) and (ReadGlobalVar('IndicadorRecargas') =2) and
(ReadGlobalVar('IndicadorBalas') <=0) then
begin
end;
//---Begin Script Builder: Travar o jogo, exibir as mensagens e resetar o jogo em função do resultado da
variável ResultadoJogo---//
begin
DisablePlayerMove;
ShowObject('Panel0');
ShowObject('Label0');
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorNome')) + '
where id = 1');
Conn.ExecuteSQL('update ator set energia = ' + IntToStr(1) + ' where id = 1');
Página 33
Conn.ExecuteSQL('update ator set nome = ' + IntToStr(80) + ' where id = 2');
Conn.Close;
Conn.Free;
end
else if (ReadGlobalVar('ResultadoJogo') =2) then
begin
DisablePlayerMove;
where id = 1');
Conn.Close;
Conn.Free;
end;
Página 34
//---Begin Script Builder: Alterar a variável ResultadoJogo para 1 em caso de vitória e 2 em caso de
derrota---//
if (ReadGlobalVar('IndicadorAcertos') =15)
and
(ReadGlobalVar('IndicadorRecargas')
<2)
and
Se a variável IndicadorAcertos for igual a 15 (o objetivo do jogo) e a variável
recargas for menor que 2 (você ainda pode recarregar a arma) e a sua munição
tiver acabado ou não (IndicadorBalas maior ou igual a 0):
begin
Altere a variável ResultadoJogo para 1 (você ganha!).
Se a variável IndicadorAcertos for igual a 15 (o objetivo do jogo) e a variável
recargas for igual a 2 (você não pode mais recarregar a arma) e a sua munição não
tiver acabado (IndicadorBalas maior que 0):
begin
Altere a variável ResultadoJogo para 1 (você ganha!).
end
Se a variável IndicadorAcertos for menor que 15 (o objetivo do jogo) e a variável
recargas for igual a 2 (você não pode mais recarregar a arma) e a sua munição
tiver acabado (IndicadorBalas menor ou igual 0):
begin
Altere a variável ResultadoJogo para 2 (você perde!).
end;
//---Begin Script Builder: Travar o jogo, exibir as mensagens e resetar o jogo em função do resultado da
variável ResultadoJogo---//
Caso você tenha ganhado:
begin
DisablePlayerMove;
Desabilita o jogador.
Página 35
Mostra o panel que serve de fundo para as mensagens.
Mostra a mensagem VOCÊ VENCEU O JOGO!
o banco de dados)
como foi explicado anteriormente no script de leitura e salvamento de dados)
where id = 1');
IndicadorNome (o nome que você usar será mantido!) e adaptado corretamente
pelo comando QuotedStr)
no campo “energia” com o “id=1” (linha 1) para o valor defalt 1 e adaptado
corretamente pelo comando IntToStr)
no campo “nome” com o “id=2” (linha 2) para o valor defalt 80 e adaptado
corretamente pelo comando QuotedStr)
Página 36
Conn.Close;
Conn.Free;
end
Caso você tenha perdido:
begin
DisablePlayerMove;
Desabilita o jogador.
Mostra o panel que serve de fundo para as mensagens.
Mostra a mensagem FIM DE JOGO! VOCÊ PERDEU!
o banco de dados)
como foi explicado anteriormente no script de leitura e salvamento de dados)
where id = 1');
IndicadorNome (o nome que você usar será mantido!) e adaptado corretamente
pelo comando QuotedStr)
Página 37
corretamente pelo comando QuotedStr)
Conn.Close;
Conn.Free;
end;
E este foi o último script! Vamos agora fazer os testes para checar se tudo
funciona corretamente. A primeira coisa a ser feita é jogar um pouco, fazendo com
que as variáveis mudem, de preferência, vá até a arena 2, para que a variável
IndicadorLocal saia do valor defalt, 1, e mude para 2. Agora, escreve um novo
nome para o jogador no campo NOVO NOME e clique no botão salvar. O Label
JOGADOR: deve exibir esse novo nome. Feche o jogo e depois abra-o de novo. O
jogador deverá ser posicionado na arena 2, todas as outras variáveis deverão estar
intactas, e o nome que você salvou deverá aparecer no Label, assim:
Página 38
Agora, abra o banco de dados e cheque se houve alteração dos valores, eles
devem estar iguais aos últimos salvos:
Agora, abra o jogo novamente. Os valores devem reaparecer e o jogador
deverá ser posicionado na Arena 2! Somente o campo NOVO NOME volta a exibir
essa mensagem, mas o nome que você salvou não se altera:
Continue a jogar. É necessário saber se ganhando ou perdendo os dados no
banco serão resetados e as mensagens irão aparecer! Não importa se você ganhar
ou perder, o Jogo deve travar, a mensagem correta deve ser exibida e os dados no
banco deverão ser resetados! Não salve mais, jogue até o fim! Como você pode
ver, eu reapareci na arena 2! Veja o que acontece se você acertar os 15 tiros sem
ficar sem munição:
Página 39
Agora, vamos fechar o jogo e abrir de novo, todos os valores deverão ter
sido resetados, menos o nome que você salvou:
Como você pode ver, tudo funciona exatamente como o planejado, só falta
checar agora o nosso banco de dados! Vejamos então:
Página 40
E com isso, concluímos o nosso tutorial! Espero que você tenha entendido
que mais importante que decorar códigos, é entendê-los! Só pra facilitar, vou
colocar agora o resumo de todos os scripts. Em anexo eu também envio a arma e o
Banco de dados, caso você não consiga baixar.
RESUMO DE TODOS OS SCRIPTS DO JOGO:
MAPA INICIALIZAR
EVENTO ON CREATE
DisablePlayerMove;
begin
end;
begin
Página 41
begin
end;
begin
end;
begin
end;
DataSet.free;
Conn.free;
end;
if (ReadGlobalVar('IndicadorLocal') =1) then
Página 42
begin
LoadMap('GAME.gbm', -11, 3, 3, 10);
end
else if (ReadGlobalVar('IndicadorLocal') =2) then
begin
LoadMap('GAME.gbm', -14, 3, 33, 10);
end;
MAPA GAME
EVENTO ON CREATE
EnablePlayerMove;
//---Begin Script Builder: Ocultar as mensagens de final de jogo---//
HideObject('Panel0');
EVENTO MAINLOOP
//---Mostrar as variáveis nos Labels correspondentes---//
SetLabelText('IndicadorNome', 'JOGADOR:' +ReadGlobalVar('IndicadorNome'));
SetLabelText('IndicadorLocal', 'ARENA:' +IntToStr(ReadGlobalVar('IndicadorLocal')));
SetLabelText('IndicadorBalas', 'MUNIÇÃO:' +IntToStr(ReadGlobalVar('IndicadorBalas')));
SetLabelText('IndicadorAcertos', 'ACERTOS:' +IntToStr(ReadGlobalVar('IndicadorAcertos')));
SetLabelText('IndicadorRecargas', 'RECARGAS:' +IntToStr(ReadGlobalVar('IndicadorRecargas')));
SetLabelText('IndicadorDisparos', 'DISPAROS:' +IntToStr(ReadGlobalVar('IndicadorDisparos')));
//---Begin Script Builder: Descarregar a arma e alterar as variáveis Indicador Disparos e Indicador Balas
conforme a execução da animação attack---//
if (ReadGlobalVar('IndicadorBalas') >0) and (ReadGlobalVar('IndicadorBalas') <=80) then
begin
begin
WriteGlobalVar('IndicadorDisparos', ReadGlobalVar('IndicadorDisparos')+1);
end
Página 43
end;
if (ReadGlobalVar('IndicadorBalas') >0) then
begin
begin
WriteGlobalVar('IndicadorBalas', ReadGlobalVar('IndicadorBalas')-1);
end
end;
//---Begin Script Builder: Desabilitar disparos da Arma quando descarregada---//
if (ReadGlobalVar('IndicadorBalas') <= 0) then
begin
end;
//---Begin Script Builder: Alterar a variável ResultadoJogo para 1 em caso de vitória e 2 em caso de derrota---//
if (ReadGlobalVar('IndicadorAcertos') =15) and (ReadGlobalVar('IndicadorRecargas') <2) and
begin
end
begin
end
begin
end;
//---Begin Script Builder: Travar o jogo, exibir as mensagens e resetar o jogo em função do
resultado da variável ResultadoJogo---//
begin
DisablePlayerMove;
Página 44
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorNome'))
+ ' where id = 1');
Conn.Close;
Conn.Free;
end
begin
DisablePlayerMove;
Conn.ExecuteSQL('update ator set nome = ' + QuotedStr(ReadGlobalVar('IndicadorNome'))
+ ' where id = 1');
Página 45
Conn.Close;
Conn.Free;
end;
EVENTO ONCOLLISION
begin
begin
end;
end;
begin
begin
end;
end;
begin
begin
end;
end;
Página 46
begin
begin
end;
end;
begin
begin
end;
end;
begin
begin
end;
end;
begin
begin
end;
end;
begin
Página 47
begin
end;
end;
//---Begin Script Builder: Alterar a Variável Global IndicadorAcertos em função de cada acerto
no espantalho---//
begin
begin
end;
end;
begin
if (GetCollidedObject1 = 'RoboPrincipal') then
begin
end;
end;
EVENTO ONCOLLISION DA ÁRVORE
//---Begin Script Builder: Recarregar a arma SE estiver descarregada e contar as recargas, com
um limite de 2---//
if (ReadGlobalVar('IndicadorBalas') < 80) then
begin
if (ReadGlobalVar('IndicadorRecargas') <2) then
begin
WriteGlobalVar('IndicadorRecargas', (ReadGlobalVar('IndicadorRecargas')+1));
Página 48
end
end;
EVENTO ONCOLLISION DO EVENT ÁREA DA PASSAGEM DA ARENA 1
EVENTO ONCOLLISION DO EVENT ÁREA DA PASSAGEM DA ARENA 2
EVENTO ONINTERACT DO BOTÃO SALVAR
//---Begin Script Builder: Alterar a Variável Global IndicadorNome com o nome do jogador e gravar as 6
variáveis no banco de dados---//
Conn.Close;
Conn.Free;
Desejo a todos um bom estudo. Com paciência e imaginação, esses scripts
podem ser adaptados a diversas situações, permitindo assim uma imensa variedade
de jogos. Um grande abraço a todos e aguardem o próximo tutorial!
Ronaldo Lemos
Rio de Janeiro, 02 de Dezembro de 2009
Página 49

TUTORIAL DE CRIAÇÃO DE UM JOGO NO 3D GAME BUILDER

Transcrição

Documentos relacionados

GAME DA RESPONSABILIDADE SOCIAL FAMATH

REGULAMENTO – ESCAPE GAME POCKET 1. O Evento 1.1. O

Brasil Game Cup (BGC) confirma torneio de Counter Strike: Global

Curso de Game Design – Aula 01

CRONOGRAMA DE ATIVIDADES – AULAS DE ESPECIALISTAS

Visitantes da Brasil Game Show 2016 poderão participar da

clube de conteúdos game zone – termos e condicoes

Felippe Velasques Giriboni

Game On - Barbican

O Melhor emulador de Super Nintendo existente

Artigos Clube Delphi

Delphi 5 - Guia do Desenvolvedor_capitulos do CD

why_guia_de_ruby_pdf - Mairon D. Brasil Ruby on Rails