Lição que da uma breve explicação sobre o que é o sed, e como trabalhar com ele.
Chegou a hora de falarmos sobre os objetos e personagens do jogo. Uma entidade é um objeto no mundo virtual que pode ou não ter interação com o jogador, o sed pode carregar entidades em formato .mdl, que são entidades de modelos, pcx, tga, bmp e dds que são entidades de sprites, hmp que são entidades de terreno e também entidades de mapa .wmb, mais essa não vem ao caso. Lembra que nós não compramos o 3dgs, e só com ele conseguiríamos as entidades .wmb.
Entidades de Modelos
Entidades de modelos são personagens , inimigos, caixas, portas, armas, e tudo aquilo que for um modelo .mdl no nível.
Você pode usar o editor de modelos MED, para criar suas entidades, mas também pode cria-los em um outro editor de sua preferencia como 3DS Max, Blender, Maya, e usar exportadores para em seguida importa-los no med.
Entidades de Sprites
As entidades de sprites, são entidades 2D, ou seja imagens que podem ou não ser interativas, os sprites podem ser criados com programas como Photoshop, Paint, Gimp, etc.
Entidades de Terreno
Entidades de terreno, também podem ser criadas com o med, ou outro software, elas serão usadas para compor nossos cenários externos, tais como morros, serras, até mesmo ruas.
Entidades De Mapa
São as .wmb, que não usaremos nesses tutoriais, mais se você quiser usa-la, basta cria-la no wed, e compilar como MapEntity. Pronto agora você pode aplicar actions a entidade .wmb.
Coordenadas
Lição que ensina como fazer o seu primeiro programa, usando a nova linguagem de programação da acknex.
Já temos nossa entidade no nível, mais e agora? Elas ficam cobrindo a tela, ficam desfocadas em relação a camera, como fazer para move-las?
Todas essas perguntas podem ser resolvidas com o trabalho de coordenadas de rotação, translação e escala.
Translação
Para ter uma noção sobre o que é translação considere as imagens:
As imagens explicam tudo certo? Para passar isso para código é muito fácil, os mesmos valores lidos nas imagens , são passados para as instruções de movimento do lite-c.
my.x
Move o objeto ao longo do eixo X, valors negativos fazem-o mover para traz, valors positivos fazem-o mover para frente.
my.y
Move o objeto ao longo do eixo Y, valors negativos fazem-o mover para esquerda, valors positivos fazem-o mover para direita.
my.z
Move o objeto ao longo do eixo Z, valors negativos fazem-o mover para baixo, valors positivos fazem-o mover para cima.
Com essas instruções, você já consegue mover as entidades, porem é um movimento travado e feio, em breve iremos aprender a mover objetos com um pouco mais de liberdade, no momento estudo o código abaixo:
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Ação do modelo
//============
action Translacao()
{
//Ajusta o tamanho do modelo
//=========================
my.scale_x = 0.3;
my.scale_y = 0.3;
my.scale_z = 0.3;
//Loop que faz o objeto transladar
//================================
while (1)
{
//Se a seta para esquerda for pressionada
if(key_cul == 1)
{
my.y = my.y - 0.1; //Move o objeto ao longo do eixo y
}
//Se a seta para direita for pressionada
if(key_cur == 1)
{
my.y = my.y + 0.1; //Move o objeto ao longo do eixo y
}
//Se a seta para cima for pressionada
if(key_cuu == 1)
{
my.x = my.x - 0.1; //Move o objeto ao longo do eixo X
}
//Se a seta para baixo for pressionada
if(key_cud == 1)
{
my.x = my.x + 0.1; //Move o objeto ao longo do eixo X
}
//Se a tecla z for pressionada
if(key_z == 1)
{
my.z = my.z - 0.1; //Move o objeto ao longo do eixo Z
}
//Se a tecla x for pressionada
if(key_x == 1)
{
my.z = my.z + 0.1; //Move o objeto ao longo do eixo Z
}
wait (1);
}
}
//Função principal
//================
function main()
{
//Aguarda o Nivel.hmp ser carregado
//=================================
level_load ("Nivel.hmp");
wait(1);
//Aguarda a camera se ajustar
//============================
vec_set(camera.x, vector(0, 0, 30));
wait(1);
//Cria o nosso modelo nas posições 0, 0, 30 e com a ação Translação
Também é necessario saber como rotacionar objetos, pois senão seus carros andarão em linha reta e se esborracharão na parede.
Esplicar rotações é um tanto difícil sem o uso de matematica, por isso vou usar imagens para que você compreenda melhor e não se estresse com os números.
Para trabalhar a rotação temos 3 instruções básicas:
my.pan
my.tilt
my.rool
Agora sua aeronave pode desviar de obstáculos. Veja um código simples:
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Ação do modelo
//============
action Rotacao()
{
//Ajusta o tamanho do modelo
//=========================
my.scale_x = 0.3;
my.scale_y = 0.3;
my.scale_z = 0.3;
//Loop que faz o objeto rotacionar
//=================================
while (1)
{
//Se a seta para esquerda for pressionada
if(key_cul == 1)
{
my.pan = my.pan - 0.1; //Rotaciona o objeto no angulo pan
}
//Se a seta para direita for pressionada
if(key_cur == 1)
{
my.pan = my.pan + 0.1; //Rotaciona o objeto no angulo pan
}
//Se a seta para cima for pressionada
if(key_cuu == 1)
{
my.roll = my.roll - 0.1; //Rotaciona o objeto no angulo roll
}
//Se a seta para baixo for pressionada
if(key_cud == 1)
{
my.roll = my.roll + 0.1; //Rotaciona o objeto no angulo roll
}
//Se a tecla z for pressionada
if(key_z == 1)
{
my.tilt = my.tilt - 0.1; //Rotaciona o objeto no angulo tilt
}
//Se a tecla x for pressionada
if(key_x == 1)
{
my.tilt = my.tilt + 0.1; //Rotaciona o objeto no angulo tilt
}
wait (1);
}
}
//Função principal
//================
function main()
{
//Aguarda o Nivel.hmp ser carregado
//=================================
level_load ("Nivel.hmp");
wait(1);
//Aguarda a camera se ajustar
//============================
vec_set(camera.x, vector(0, 0, 30));
wait(1);
//Cria o nosso modelo nas posições 0, 0, 30 e com a ação Rotação
As vezes quando você cria um objeto ele acaba ficando muito grande, para não ter o trabalho de voltar ao editor de modelos, você pode usar o sistema de escala do lite-c. Ou ate mesmo quando em uma cena, você precisa transformar um homem em anão...
isso pode ser feito trabalhando com a instrução:
my.scale
Os parâmetros passados são (X, Y e Z):
my.scale_x = 0.1;
my.scale_y = 0.1;
my.scale_z = 0.1;
que re-dimensiona o objeto. A instrução pede um eixo para executar a alteração de escala, eu recomento que indique todos os ângulos para que a imagem não fique desproporcional.
Quanto menor o valor indicado menor sera o seu modelo.
Veja um código simples:
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Ação do modelo
//============
action Escala()
{
//Ajusta o tamanho do modelo
//=========================
my.scale_x = 0.3;
my.scale_y = 0.3;
my.scale_z = 0.3;
//Loop que faz o objeto redimensionar
//=================================
while (1)
{
//Se a seta para esquerda for pressionada
if(key_cul == 1)
{
my.scale_x = my.scale_x - 0.01;//O objeto sera redimensionado
my.scale_y = my.scale_y - 0.01;//
my.scale_z = my.scale_z - 0.01;//
}
//Se a seta para direita for pressionada
if(key_cur == 1)
{
my.scale_x = my.scale_x + 0.01;//O objeto sera redimensionado
my.scale_y = my.scale_y + 0.01;//
my.scale_z = my.scale_z + 0.01;//
}
wait (1);
}
}
//Função principal
//================
function main()
{
//Aguarda o Nivel.hmp ser carregado
//=================================
level_load ("Nivel.hmp");
wait(1);
//Aguarda a camera se ajustar
//============================
vec_set(camera.x, vector(0, 0, 30));
wait(1);
//Cria o nosso modelo nas posições 0, 0, 30 e com a ação Escala
Lição que ensina como fazer o seu primeiro programa, usando a nova linguagem de programação da acknex.
Em todas as partes do jogo, precisamos nos locomover, isso é possível graças a dispositivos de entrada, como:
Mouse
Espero que você não tenha se esquecido das três instruções sobre o mouse:
mouse_mode = 0;
mouse_mode = 1;
mouse_mode = 2;
Essa é uma função que trata os três modos do mouse:
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Carrega as imagens da mira e cursor
//===========================
BMAP* Cursor_pcx = "Cursor.pcx";
BMAP* Mira_pcx = "Mira.pcx";
//Declara função
//==================
function MudaCursor();
//Função principal
//================
function main()
{
screen_color.blue = 150;
video_mode = 7;
//Chama a função MudaCursor, quando a tecla (m) for precionada
//==========================
on_m = MudaCursor;
while (1)
{
//Indica que a posição do mouse é a mesma que a do cursor
//==========================
mouse_pos.x = mouse_cursor.x;
mouse_pos.y = mouse_cursor.y;
wait (1);
}
}
//Função que troca o cursor pela mira
//==========================
function MudaCursor()
{
//Incrementa 1 a mouse_mode
//==========================
mouse_mode += 1;
mouse_mode %= 3; //Se o mesmo receber três valores, volta ao 1° valor
//Se mouse_mode for = a 1, mostra a mira
//===========================
if (1 == mouse_mode)
mouse_map = Mira_pcx;
//Se mouse_mode for = a 2, mostra o cursor
//===========================
if (2 == mouse_mode)
mouse_map = Cursor_pcx;
}
Teclado
Você já imaginou o que seria de um jogo sem o uso de teclas? Usar o teclado em jogos é quase uma obrigação, mais existe muitos jogos que não o usam. Em todo caso nós iremos aprender.
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Função principal
//================
function main()
{
level_load("Terreno.hmp");
wait(1);
while (1)
{
if (key_w) camera.tilt += 2 * time_step;
if (key_s) camera.tilt -= 2 * time_step;
if (key_a) camera.pan += 2 * time_step;
if (key_d) camera.pan -= 2 * time_step;
wait (1);
}
}
Como vocês podem ver, não é tão difícil capturar teclas em lite-c. Colocamos os escopos if dentro de um loop para que as teclas sejam verificadas constantemente.
Controle
Não esta bom? Você não quer usar o teclado? tão pouco o mouse? A você quer usar seu controle... Então vamos lá.
Antes do código, precisamos configurar e calibrar nosso controle, para não haver erros no futuro. Conecte o seu controle ao seu computador, agora vá em Iniciar // Painel de Controles, e clique em Impressora e Outros Itens de Hardware, em seguida clique em Controladores de Jogo.
O caminho pode variar em relação as versões do windows.
Na janela que se abre, selecione o seu dispositivo e clique em propriedades.
Vejá se esta tudo OK... Se sim encerre tudo e volte para o sed. Vamos aos códigos:
//Cabeçalho
//=========
#include <acknex.h>
#include <default.c>
//Função principal
//================
function main()
{
level_load("Terreno.hmp");
wait(1);
camera.pan = 0;
while(1)
{
camera.y -= joy_force.x;
camera.x += joy_force.y;
if (joy_1) camera.z += 1;
if (joy_2) camera.z -= 1;
if (joy_1 && joy_2)
{
camera.x = 0;
camera.y = 0;
camera.z = 0;
}
wait(1);
}
}
Como vocês viram, temos ali a nova instrução joy_force que é responsável por capturar as entradas do controle.
Textos
Lição que ensina como fazer o seu primeiro programa, usando a nova linguagem de programação da acknex.
Em um jogo sempre é necessario imprimir mensagens seja como informações, orientações ou apenas ilustrativas. Isso é possível com o uso dos textos.
Um texto é definido da seguinte maneira:
TEXT* meu_texto =
{
...
...
}
Dentro de um texto você pode colocar uma string que armazena a mensagem a ser exibida.
Strings
Uma string é uma seqüência de caracteres: letras, números, símbolos, abaixo segue alguns exemplos válidos de strings:
STRING* Nome = “Sr. Fumaça”;
STRING* msg1 = “Siga em Frente”;
STRING* Nplaca = “BBB985”;
STRING* Arma = “Escopeta”;
Após declarada a string pode ser chamada na definição do texto:
STRING* Arma1_str = “Você pego a arma 1”;
TEXT* txtArma1
{
pos_x = 300;
pos_y = 300;
layer = 5;
string (Arma1_str);
flags = VISIBLE;
}
Segue um exemplo do uso de strings e textos:
//Cabeçalho
//=================
#include <acknex.h>
#include <default.c>
//Definição da string
//=====================
STRING* Arma1_str = "Voce pego a arma 1!";
//Texto para impressão
//=====================
TEXT* txtArma1 =
{
pos_x = 300;
pos_y = 250;
string (Arma1_str);
flags = VISIBLE;
}
//Função principal
//======================
function main()
{
video_mode = 7;
screen_color.blue = 150;
}
Com isso você consegue exibir mensagens na tela para informar ao jogador sobre algum acontecimento.
Fontes
Já sabemos colocar os textos, porem aquela fonte feia e incompleta não ajuda muito.
Nessa parte você ira aprender a usar outros tipos de fontes e até mesmo a usar fontes criadas por você mesmo.
Podemos trabalhar com dois tipos de fontes, as true types e as bitmaps.
True type
As fontes true types são aquelas fontes instaladas no seu pc que se encontram na pasta fonts dentro do diretório do windows.
Segue uma declaração de font true type:
FONT* Nome = “NomeDaFonte#Altura(Tipo)”;
FONT* ftArial = “Arial#20b”;
Bitmap
Fontes bitmaps são as fontes criadas pelo programador ou artista grafico a partir de imagens.
Segue uma declaração de font bitmap:
FONT* Nome = “Nome.bmp”;
Esse exemplo mostra o funcionamento dos dois tipos de fontes:
//Inclui cabeçalhos
//========================
#include <acknex.h>
#include <default.c>
//Declara as menssagens
//========================
STRING* true_str = "Essa é uma fonte true type";
STRING* bmp_str = "Essa é uma fonte bitmap";
//Cria as fontes
//==============================
FONT* BitmapFont = "fonte.pcx";
FONT* TrueFont = "Arial#25b";
//Define o texto da fonte Bitmap
//==============================
TEXT* txtBitFont=
{
pos_x = 180;
pos_y = 200;
font = BitmapFont;
string(bmp_str);
flags = VISIBLE;
}
//Define o texto da fonte true type
//=================================
TEXT* txtTrueFont=
{
pos_x = 180;
pos_y = 250;
font = TrueFont;
string(true_str);
flags = VISIBLE;
}
Agora você já sabe como ter total interação com o usuario, nos próximos tutoriais iremos ver como usar tudo que nós aprendemos, em conjunto com funções, ações, loops, etc.
Funções
Lição que ensina como fazer o seu primeiro programa, usando a nova linguagem de programação da acknex.
Desta vez iremos aprender o que é, como criar e como usar as funções.
Então o que é uma função? Veja por si proprio:
function VidaHeroi()
{
Vida = 100;
Danos = 10;
while(player foi atingido)
{
Vida -= Danos;
wait(1);
}
}
Funções não são nada mais do que blocos de instruções que fazem com que o programa tome um determinado caminho.
Uma função deve ser declarada com a palavra chave function seguido do nome da função e encerrado com um par de () “parenteses”.
O corpo de uma função deve estar entre {} “chaves”. E pode conter as mais diversas instruções.
Para escrever uma função, primeiro temos que ter um problema, então segue o problema.
“Para o herói passar de nível, ele deve marcar 100 pontos .”
//Cabeçalho
//==================
#include <acknex.h>
#include <default.c>
Aqui criamos uma variável para armazenar os pontos.
//Variáveis
//================
var Pontos = 0;
Esse também é um novo ponto. Quando criamos uma função no fim da folha, mais a mesma será chamada antes, devemos fazer a sua declaração no topo da folha.
//Declara funções
//=================
function PassaNivel();
As string vão nos informar se o herói passou ou não de nível.
//Strings
//========
STRING* passa_str = "Voce passou de nivel";
STRING* aguarda_str = "Faca 100 pontos para passar de nivel";
E os textos vão imprimir as strings.
//Textos para exibição das mensagens
//===================================
TEXT* txtPassa=
{
pos_x = 200;
pos_y = 200;
layer = 3;
string (passa_str);
}
TEXT* txtAguarda=
{
pos_x = 200;
pos_y = 200;
layer = 3;
string (aguarda_str);
flags = VISIBLE;
}
Eu criei esse painel somente para mostrar o numero atual de pontos.
//Painel para impressão dos pontos
//=================================
PANEL* pPontos=
{
pos_x = 10;
pos_y = 10;
digits (10, 10, 5, *, 1, Pontos);
flags = VISIBLE;
}
Para uma função funcionar, ela deve ser chamada na hora da ação, Exemplo:
Se o herói levar um tiro, deve-se chamar a função – LevaTiro();
Se o herói tem uma chave e esta perto da porta deve-se chamar a função – AbrePorta();
No nosso caso a função sera chamada assim que o programa iniciar.
//Função principal
//==================
function main()
{
screen_color.blue = 150;
PassaNivel();
}
E aqui esta a função que passa de nível. Note o loop while, ele checa se o valor de Pontos é menor do que 100, caso seja e a tecla ctrl for pressionada ele transforma o valor de pontos em 100.
Em seguida a função checa se o numero de pontos é = a 100, caso seja ela mostra um texto dizendo que o herói passou de nível.
//Função para ir ao próximo nível
//===============================
function PassaNivel()
{
//Enquanto o numero de pontos for menor que 100
//================================
while(Pontos < 100)
{
//Se pressionar a tecla CTRL
//==========================
if(key_ctrl == 1)
{
Pontos = 100; //O numero de pontos será = 100
}
wait(1);
}
if(Pontos == 100)
{
txtPassa.flags = VISIBLE; //Torna visível
txtAguarda.flags = 0; //Torna invisível
}
}
Funções são muito fáceis de se trabalhar, mais a frente você ira aprender sobre o loop while e os comandos If e Else.
Loop While
Um loop while é algo muito interessante e útil. Considere while como (Enquanto), Logo:
Enquanto (Vida > 0)
{
Vida -= 5;
wait(1);
}
Enquanto (Heroi estiver vivo)
{
Mata heroi;
wait(1);
}
Enquanto (Inimigo estiver longe)
{
Caminha em direção ao inimigo
wait(1);
}
O corpo de um loop deve sempre terminar com uma instrução wait(), informando para o loop aguardar para dar o próximo ciclo.
Acho que já deu para entender né? Não? Então vamos aos códigos:
//Cabeçalho
//==================
#include <acknex.h>
#include <default.c>
//Variáveis
//================
var numero = 0;
//Painel para impressão dos pontos
//=================================
PANEL* pLoop=
{
pos_x = 10;
pos_y = 10;
digits (10, 10, 5, *, 1, numero);
flags = VISIBLE;
}
Note uma nova instrução dentro da função main. O time_step, é usado para normalizar a contagem, faça um teste sem o time-step. Não sera possível ver a contagem do numero de tão rapido que sera feita.
//Função principal
//==================
function main()
{
screen_color.blue = 150;
while(numero < 100)
{
numero += 1 * time_step;
wait(1);
}
}
Agora você já sabe o que é um loop while? Se ainda não, não se preocupe, pois ele sera visto muitas vezes e uma hora a ficha vai cair.
If e Else
Em primeiro lugar, saiba que If = Se, em português, e Else = Senão. Logo:
Se (o player morreu)
{
Fim de Jogo;
}
Senão
{
Continua Jogo;
}
If e Else são usados em muitos casos e a estrutura que você viu ai em cima é a sua forma de declaração. Para um melhor entendimento, vamos a um exemplo funcional:
//Cabeçalho
//==================
#include <acknex.h>
#include <default.c>
Usamos duas strings para sabermos quando, qual comando esta em ação
//Strings
//================
STRING* Tecla1 = "Voce Pressionou a tecla 1";
STRING* Tecla2 = "Voce Pressionou a tecla 2";
A variável tempo define qual mensagem sera mostrada
//Variável que indica se tempo é ou não = 100
//===================================
var tempo = 100;
//Declara função
//===============
function PassaNivel();
//Textos para impressão das mensagens
//===================================
TEXT* txtIf=
{
pos_x = 200;
pos_y = 200;
layer = 3;
string = Tecla1;
}
TEXT* txtElse=
{
pos_x = 200;
pos_y = 200;
layer = 3;
string = Tecla2;
}
//Função principal
//==================
function main()
{
screen_color.blue = 150;
//Chamamos a função em um loop para que seja executada constantemente
//=====================================
while(1)
{
PassaNivel();
wait(1);
}
}
//checa if e else
//===============================
function PassaNivel()
{
//Se tempo for igual a 100
//==========================
if(tempo == 100)
{
txtIf.flags = VISIBLE;
}
//Senão
//======
else
{
txtElse.flags = VISIBLE;
}
}
Agora vamos a uma nova funcionalidade do sed. Quando executamos o nível, temos a opção de alterar variáveis e strings em tempo de execução através do console.
Para isso pressionamos a tecla TAB e digite o nome da variável seguida do seu novo valor.
Faça isso com a variável tempo e adicione um valor menor que 100.
