Lite-C oficinas

Bem-vindo a lite-C! Se você é apenas compraram este incrível peça de software, tem cuidado: você tem um brinquedo para brincar com os poderosos. Mas porque é que se chama "lite"? Pois bem ... principalmente porque exige um esforço e muito menos recursos do que um peso pesado como o sistema de desenvolvimento Visual C + + ®. No entanto, lite-C vem com todo o software necessário para criar aplicações multimédia ou 2D e 3D computador jogos: inclui as Acknex poderoso motor e um script editor e depurador.

Passeio a mim através de 24 oficinas e você irá se tornar um avançado lite-C programador, mesmo que você nunca antes programado. Você precisará de cerca de 24 horas (well. .. esse é um dia se você não dormir) para completar o trabalho, mas confia em mim - você ficará satisfeito você fez isso. O foco das oficinas é o jogo programação, pois a maioria dos projectos são lite-C computador jogos. Por isso vamos concentrar-se nas características do jogo lite-C. Iremos também introduzir a linguagem C, mas não vai ir muito em detalhes. Se você quiser se tornar um verdadeiro mestre da lite-C, recomendo a comprar um C / C + + livro ou passar por um tutorial on-line grátis C, tais como Sam's Teach Yourself C em 21 dias, depois de concluírem as oficinas.

Cada workshop inclui totalmente funcional código que pode ser utilizado em todos os seus jogos futuros projetos. Você vai encontrar todas as amostras dentro do código litec_samples.zip arquivo, que está contida no arquivo zip deste tutorial e também pode ser descarregado a partir http://server.conitec.net/down/litec_samples.zip ou copiado a partir da Gamestudio CD. Você precisará A7 versão 7,07 ou superior, ou lite-C versão 1,07 ou superior para executar o código amostras.

Conhecer o motor
Variáveis
Funções
Bitmaps e painéis
Dígitos e Windows
Botões e cursores
Strings, textos e fontes
Posição, dimensão e ângulo

Entidades
Ações
Ponteiros
Se - Else ramificação
Usando o teclado
Usando o rato. Mouse eventos
Usando o joystick
Se livrar de bugs
Opções depuração
Entidade circulação
A física motor
Sprites. Animated sprites
Modelos. Animated modelos
Opções modelo animação. Ossos
O osso coletor
Variáveis globais. Variáveis locais

Por último, algumas palavras sobre mim: meu nome é George Pirvu e eu sou o CEO para Randombyte, empresa de desenvolvimento de software - www.randombyte.com. Eu tenho começado a usar Acknex versão A3, em 1997, foi um bom motor, mas o que você tem em suas mãos agora é uma melhor forma, acreditem! Eu sou o editor da Revista Acknex Usuário (Aum), uma revista gratuita que apresenta um modelo de jogo e um monte de lite-C tutoriais e código todos os meses.

Se você acha que lite-C é uma boa ferramenta apenas quando se trata de jogo desenvolvimento, a pensar novamente: Aum contém exemplos de sintetizadores, despertadores, planilha telespectadores, ferramentas capazes de gerar código script, modelo telespectadores, calculadoras e muito mais! Eu tenho trabalhado com vários motores de jogo, mas Acknex é a melhor ferramenta para o seu dinheiro: é poderoso, fácil de usar e tem uma grande (para não referir a enorme) usuários da comunidade.

Próximo: Conhecer o motor

Workshop 01: Conhecer o motor

Se você pode ler este documento você provavelmente já conseguiu instalar Lite-C no seu computador, o programa deverá ter uma entrada no Windows "menu iniciar. Você pode ver os atalhos para Lite-C Script Editor (SED) e ao manual. Vamos ver o que fazem:

-- O manual contém a descrição de todas as funções lite-C. Há muitas mais funções do que aqueles que estão abrangidos nestes workshops!
-- O script editor é o programa que nos ajuda a escrever escrever, executar, compilação e depuração de linhas de código. Lite-C inclui um grande script editor, com muitos recursos.

Você pode usar o nosso modelo freeware editor (MED), que podem ser encontradas na página de download, para criar objetos 3D (modelos). Precisa de um terreno para a paisagem de um jogo nível? Use MED para criá-la! Precisa de um jogador modelo? Crie-o em MED!

Você não estão ansiosos para começar a trabalhar? Incêndio-se o editor do argumento, clique em Arquivo / Abrir, navegue para a pasta do seu trabalho lite-C instalação e, em seguida, faça duplo clique no arquivo small.c.
Código:

//////////////////////////////////////////////////////////////////////////// // small.c - small lite-C example //////////////////////////////////////////////////////////////////////////// #include <acknex.h> // include these predefined, needed files in our project #include <default.c> void main() { // Load the level named "small.hmp" level_load("small.hmp"); // Now create the "earth.mdl" model at x = 10, y = 20, z = 30 in our 3D world ent_create("earth.mdl", vector(10, 20, 30), NULL); // NULL tells the engine that the model doesn't have to do anything }

Este é um típico Pura Mode lite-C programa. Pura Mode significa que lite-C utiliza o motor Acknex e suporta objectos predefinidos para sons, imagens, modelos e assim por diante. Isto torna muito mais fácil programação. A alternativa é o Legacy Mode, que é como uma norma com programação C / C + +, tais como compilador Visual C + +, e assim por diante. O "trabalho" pasta contém muitos exemplos de Pura Legacy Mode Mode e programas. Este tutorial irá cobrir Pura Mode programação; para aprender Legacy Mode, você pode usar qualquer livro sobre C / C + + e Windows API programação.

As linhas azuis no programa acima são apenas comentários que descrevem partes do código fonte. Você verá que o programa consiste na maior parte dos comentários. Existem apenas alguns "real" de linhas de código (a preto queridos); no entanto, este é um trabalho totalmente Lite-C pedido! Agora iniciar o programa clicando no botão triângulo preto. Encontrar-se-á em um pequeno nível paisagístico; earth.mdl nosso modelo será em lá também. Pressione Alt + Enter para executar o programa em modo de tela cheia, assim como você fazer com qualquer outro aplicativo do Windows; pressione Alt + Enter novamente para retornar ao modo janela.

Este exemplo simples ensina-nos a carregar um nível e como criar e colocar uma entidade (o modelo terrestre) no interior do nível. Não se preocupe se você não pode entender como o código funciona: nós vamos cobrir tudo, nos seguintes workshops. Vamos começar com os mais básicos de cada programa: as variáveis.

Seguinte: Variáveis

Workshop 02: Variáveis

A variável é um local em memória do seu computador (apenas como um contentor) que pode ser usado para armazenar alguns números. Vamos ver alguns exemplos lite-C:

var balas = 7;
var saúde;
var vidas = 3; / / o jogador tem 3 vidas

Estes são alguns curtas linhas de código, mas podemos utilizá-los para aprender muitas coisas novas:

1. Cada variável deve ser definida antes de ser utilizado, utilizando a palavra-chave chamado var. Se você escrever esta linha de código:

saúde = 100;

e você não tenha definido o chamado var saúde antes de utilizá-lo você receberá uma mensagem de erro motor.

2. Qualquer variável pode receber um valor inicial (balas = 7, vidas = 3) em jogo começar, mas não somos obrigados a fazer isso.

3. Nós podemos adicionar os nossos próprios comentários ao código. Cada vez se depara duas barras / / o motor irá ignorar as palavras, expressões, símbolos, etc que segui-lo. Dessa forma, podemos acrescentar comentários úteis para o nosso código:

car_speed var, / / a velocidade do carro que o jogador Chases
/ /%$%&^& Ha Ha Ha! %^&** I regra!

4. Cada linha C-lite necessidades de terminar com um ponto e vírgula. Muitos novatos se esqueça de acrescentar, no final da sua lite-C linhas de código, o que levou a muitas mensagens de erro.

5. lite-C usa uma variável (var) que pode ter até seis dígitos, com um máximo de três dígitos após o decimal; por isso, uma var pode armazenar números de -999999,999 a 999999,999. Você pode combinar dois ou mais vars se você precisa usar números maiores. Você também pode usar outras C / C + + tipos de variáveis, como int, char, curtas, longas, float, duplos e assim por diante. No entanto, neste seminário vamos concentrar-nos var variáveis que são as mais fácil de usar.

6. Cada variável nome deve começar com uma letra ou com um underscore _. Aqui estão alguns nomes válidos variável:
var AlohA;
var _me_too;
var go42;
var Iamb19;
var _12345;
Agora vamos dar uma olhada em algumas más var exemplos:

var #ItoldYou;
var 1_for_all;
var 12345;

Eu vou deixar que você descubra o que está errado no var definições acima.

7. Variável nomes são caso sensitivo. Isto significa que, se definir uma var desta forma:

var MyHeadShots;

e, depois, nós usá-lo mais tarde, no nosso código desta forma:

myheadshots = 5; / / ou
mYheadSHots = 5; / / ou
MYHEADSHOTS = 5;

o motor não irá aceitá-la.

8. Por último, as variáveis devem ter nomes significativos. Embora seja possível definir uma pilha de variáveis que ficará assim:

var x32;
var a125;
var h_34_5;
var _z34187;

não é uma boa ideia de fazê-lo desta forma. Você vai ter problemas ao tentar fazer lembrar aquilo que estas variáveis se você olhar para o seu código de algumas semanas mais tarde. Se você quer mostrar o seu código para outras pessoas, elas terão uma dura tempo tentando figura o que você quis fazer com o seu código. As definições abaixo var olhar muito melhor, não são eles?
var current_position; // posição actual do inimigo
var number_of_goals;
var high_score;
var player_armor; // será fixado em 100 quando o jogo começa
Chega teoria! Vamos usar essas variáveis! Tenha certeza que você unzipped a litec_samples.zip arquivo em uma pasta no PC. Inicie o editor do argumento e, em seguida, pressione o seu botão Abrir:

Navegue para a pasta amostras, aberto workshop02 e, em seguida, faça duplo clique no arquivo script02 dentro dela para abrir o arquivo lite-C.

Antes de continuar certifique-se de que você tenha configurado corretamente Lite-C. Clique no menu chamado Opções e, em seguida, selecione Preferências e do Meio Ambiente guia. Use a marca arquivo atual opção de ensaio (caso ainda não esteja). Isso garante que o actual processo é iniciado. Vamos prima OK e, depois, vamos tentar a nossa sorte com ensaio: Clique no botão triângulo!

O motor arranca. Sua tela irá tornar-se azul (sim, essa é a minha cor favorita). Isso acontece porque eu definir a cor de tela no script para azul. Não tenha medo, você vai aprender como a criação de cores diferentes!

Vamos voltar para o nosso ecrã, pelo que deve ser semelhante a este:

Essa tela não parece ainda muito pouco entusiasmante. Pressione a tecla Tab no teclado para mostrar o console (o cursor) e, em seguida, digite

a = 5;

e, em seguida, pressione Enter. Prima Tab novamente para ocultar o console. Você vai notar que a = 5, c = 5 agora. Eu me pergunto o que está acontecendo aqui ...

Prima Tab novamente, apagar o texto existente usando a tecla Backspace e, em seguida, digite a seguinte linha de código:

b = 3;

Pressione Enter - a tela deve ser semelhante a este:

A começar a fazer sentido de tudo isto, não é? Parece que c é a soma de a e b; experimentar vários tipos de valores para a e b, e você irá convencer-se. Agora vamos fechar a janela do motor pressionando [Esc], e vamos dar uma olhada na milagrosa pedaço de código que transforma nosso amado motor de uma simples calculadora:

////////////////////////////////////////////////////////////////////
#include <acknex.h>
#include <default.c>
var a = 0;
var b = 0;
var c = 0;
/////////////////////////////////////////////////////////////////////
PANEL* panDisplay =
{
digits(35, 10, "a = %0.f", *, 1, a);
digits(35, 19, "b = %0.f", *, 1, b);
digits(35, 28, "c = %0.f", *, 1, c);
flags = VISIBLE;
}
/////////////////////////////////////////////////////////////////////
function main()
{
video_mode = 7; // 800x600 pixels
screen_color.blue = 150; // azul escuro
while (1)
{
c = a + b;
wait (1);
}
}
Se você pensa que este pedaço de código é muito complicado, não se preocupe: nós vamos apenas discutir o azul de linhas de código, neste seminário. Ufa ... Senti-me bastante um sentimento de alívio quando ouvi que - você fez?

var a = 0;
var b = 0;
var c = 0;

Estes são três simples var definições. Agora eu sei que eu preciso para definir uma var desta forma se eu quiser usá-lo mais tarde, em meu jogo.

c = a + b;

Esta linha de código lite-C parece ser muito simples; faz c igual à soma de um e b. Vamos fazer uma pequena experiência. Encontre a linha de código "c = a + b;" e, em seguida, apague o sinal "+", substituindo-a por um "-". A linha editada deve ser semelhante a este:

c = a - b;
Salvar o script e, em seguida, pressione o botão Executar

Teste novamente.

Posso ver os bons velhos tela azul! Vamos tipo destes valores em (não se esqueça de pressionar Tab):

a = 2;
b = 5;

eo resultado é c = -3! É realmente funciona!

Você tem agora domina o básico da lite-C, você não tem? Vamos fazer uma pequena experiência, foi-nos dito que qualquer variável (var a partir de agora em diante) podem receber um valor inicial. Será isso verdade? Vamos verificar que de imediato: Verifique os valores para a e b, em seu arquivo script para torná-los mais ou menos assim:

var a = 20;
var b = 5;
var c = 0;

Vamos correr o nosso nível de teste mais uma vez, deve nós?

O motor tenha lido os novos valores e tem subtraído 5 a partir de 20, mostrando o resultado correto: 15. Sei que não é um jogo o que estamos fazendo aqui, mas é muito divertido! Portanto, agora sabemos como somar e subtrair valores; nós também pode usar * para multiplicar dois números / ou dividi-los. Poderíamos substituir a linha que faz o "c = a + b"; cálculo com muito mais complexo tipo de expressões, mas eu odeio matemática assim vamos conversar sobre qualquer outra coisa ...

Lembram-se das primeiras linhas de código abaixo a função principal? Eu não esquecê-los:

video_mode = 7; / / 800x600 pixels
screen_color.blue = 150; / / azul escuro

Lite-C sabe como lidar com dois tipos de variáveis: predefinidos e definidos pelo usuário vars. Algumas variáveis já são definidas dentro lite-C por seus criadores; estas são as variáveis predefinidas e eles estão controlando algumas características do motor. A var video_mode acima é uma variável previamente definidos; é usado pelo motor para definir o ecrã inicial resolução (800x600 pixels no meu exemplo). Por favor note que video_mode pode ter um valor entre 1 e 11. Por outro lado, screen_color é um tipo especial de variável - um vetor - que leva 3 valores - vermelho, verde, azul - e faz o que diz o seu nome - ele define a cor de tela. Estamos apenas definindo o azul dos componentes do vetor aqui, não se preocupe, vamos aprender sobre vectores mais tarde. Para uma lista completa das variáveis predefinidas verificar a referência manual.

Se você pretende criar a próxima Quake assassino é bom que saiba que quando a gente grande mudança na sua resolução de vídeo menu "Opções", eles simplesmente um conjunto var como o nosso video_mode para um novo valor. Sensação cansado? Eu também. Vamos fazer uma pausa.

Seguinte: Funções

Workshop 03: Funções

Espero que você tenha lido o seminário anterior, um sobre as variáveis. Eu não sei sobre você, mas eu aprendi algumas coisas bastante sobre essas vars. Este capítulo irá ensinar-lhe muitas coisas novas e interessantes sobre esperemos funções.

Quais são essas funções, mesmo assim? Vamos ver um pequeno exemplo:

function add_numbers( )
{
a = 3;
b = 5;
c = a + b;
}

Você vê o que eu vejo? Uma função é nada mais do que uma coleção de declarações, que consiste em várias lite-C instruções que use vars e coisas assim. Vamos ver algumas propriedades para estas funções:

1. Uma função é definida usando a palavra-chave função seguido do nome da função e um par de parênteses (). Os parênteses são usados para passar parâmetros adicionais para a função; no nosso caso nós não passamos quaisquer parâmetros, então eles estão vazios.

2. O corpo da função (seu conteúdo) deve ser escrito dentro de um par de curly colchetes ().

3. O corpo da função consiste de uma ou mais linhas de código que lite-C terminar com um ponto e vírgula.

4. Os nomes utilizados para as funções que não são restritivas, mas você deve manter com as convenções de nomenclatura utilizada para a vars.

5. Você não deve usar o mesmo nome de uma var e de uma função; isto irá levar a erros.

Se você está lendo este tutorial eu espero que você sabe que a sua idade, também. Não em anos, mas nos dias! Qual é, você não sabe disso? Você gostaria que escrever uma função que calcula o número de dias? Ok, então vamos tentar escrever uma função que calcula o número de dias passados por mim (ou você) na Terra. Vai usar algum vars, assim teríamos uma melhor defini-los primeiro:

var my_age = 33; // tua idade(em anos) esta aqui
var days_a_year = 365;
var number_of_days;

Nada de novo, até agora, certo? Nós definimos três vars e dois deles tenham recebido valores iniciais, porque sei minha idade, em anos, e sei também que quase todos os anos tem 365 dias. Eu estou me pouco nervoso - essa função irá funcionar?

Sei como para começar! Me escreva a palavra-chave função e, em seguida, o nome da função; vamos nome que compute_days:

function compute_days()
{

Não me esqueci do parenteses após o nome da função e ter adicionado a primeira curly suporte!

Agora vem a parte assustadora: como vou poder dizer ao motor para calcular o número de dias? Aguarde ... como é que eu faço é se eu usar uma calculadora bolso? Gostaria de fazer algo como isto:

number_of_days = 33 x 365 / / number_of_days é apenas um nome para o resultado

Agora vamos dar uma olhada em nosso vars; se eu substituir my_age com 33 e 365 com days_a_year vou obter algo como isto:

number_of_days = my_age x days_a_year

Esta linha começa a aparecer como lite-C, mas temos de corrigir dois pequenos problemas primeiro:
-- Lite-C * utiliza para multiplicar os valores, não x
-- Cada linha de lite-C código deve terminar com um ponto e vírgula

Ok, então a nossa função deve ser semelhante a este:

function compute_days()
{
number_of_days = my_age * days_a_year;
}

Tenho lembrado para adicionar suporte a segunda curly isso agora o corpo da função é delimitada pelas duas exigido curly parêntesis. Estou muito curiosa para ver se esta função funciona bem, então eu ter preparado um pequeno arquivo de script para os nossos testes. Fire up Lite-C, e, em seguida, abra o arquivo script03 localizada dentro da pasta denominada workshop03:

////////////////////////////////////////////////////////////////////
#include <acknex.h>
#include <default.c>

var my_age = 33;
var days_a_year = 365;
var number_of_days; // we need to calculate this value
///////////////////////////////////////////////////////////////////
PANEL* pDisplay =
{
digits (10, 10, 5, *, 1, number_of_days);
flags = VISIBLE;
}

O código é bem simples, não é mesmo? Já sabemos como trabalhar com essas vars, sabemos como adicionar comentários ... Vamos função compute_days cópia deste documento e colá-lo no script: selecionar todo o texto da função com o mouse, clique direito, escolha Copiar, alternar para Lite-C, botão direito do script no final do script e, em seguida, escolher Colar para colar a nova função direita antes da função main (). O resultado deve ser semelhante a este:

////////////////////////////////////////////////////////////////////
#include <acknex.h>
#include <default.c>

var my_age = 33;
var days_a_year = 365;
var number_of_days; // we need to calculate this value
///////////////////////////////////////////////////////////////////
PANEL* pDisplay =
{
digits (10, 10, 5, *, 1, number_of_days);
flags = VISIBLE;
}
///////////////////////////////////////////////////////////////////
function compute_days()
{
number_of_days = my_age * days_a_year;
}

Vamos correr o script nosso arquivo ...

Ele funciona ... mas nada aconteceu! Posso ver uma tela preta e um zero ... Estou a zero dias de idade? Eu pensei que eu sou muito mais velhos! Deve haver algo de errado com este código ... Eu sei que tenho copiado a funcionar correctamente! O que devo fazer?

Pois bem, nós escrevemos uma função que é suposto a correr bem, mas não temos "chamado" dele, nós não torná-lo correr. Vamos imaginar que você quer comemorar o seu aniversário e você contratar uma banda. Eles chegam em sua casa e eles se sentar em um canto sem fazer nada, à espera de seu comando. E você tando lá, é porque não dizer-lhes para começar a jogar e que você está se perguntando por que você não pode ouvir a sua música ... A mesma coisa acontece com a nossa missão: nós escrever o seu código, mas então temos de dizer-lhe para ser executado.

Ok, por isso agora estamos obtendo algum lugar: como faço para executar a minha nova função? Vamos a um tipo de linha que chama a função dentro de uma nova função principal, assim como na imagem abaixo:

////////////////////////////////////////////////////////////////////
#include <acknex.h>
#include <default.c>

var my_age = 33;
var days_a_year = 365;
var number_of_days; // we need to calculate this value
///////////////////////////////////////////////////////////////////
PANEL* pDisplay =
{
digits (10, 10, 5, *, 1, number_of_days);
flags = VISIBLE;
}
///////////////////////////////////////////////////////////////////
function compute_days()
{
number_of_days = my_age * days_a_year;
}
function main()
{
screen_color.blue = 150;
compute_days();
}

Chegou a hora de ensaio nosso nível de novo ...

Ok, desta vez ele trabalhou, mas não tenho certeza o que aconteceu; é função main () especiais ou o quê? Sim, é a principal função predefinida nome, portanto não tente criar outra função principal e nome-lo. Esta função especial será executado por si só toda vez que iniciamos o nosso script. Vamos ver qual é o código dentro principal:

function main()
{
screen_color.blue = 150;
compute_days();
}

A forma como eu vejo, o código chamadas (ele pode ser executado) a nossa função (depois de ter estabelecido a cor de tela). Ok, agora que estamos aqui vamos ver como nós chamamos uma função: é escrever o seu nome seguido por um par de parênteses e, depois, temos a final lite-C linha de código com um ponto e vírgula. Sons lógico, não é mesmo?

Dica importante: escrever as linhas de código para as suas funções em primeiro lugar e chamá-las mais tarde. O motor lê o código da mesma forma que você ler um livro: ela começa com a parte superior da página Script e vai até ao fundo, a leitura do código linha por linha. Se eu escrever o meu script desta forma

function main()
{
compute_days();
}
function compute_days()
{
number_of_days = my_age * days_a_year;
}

o motor vai dizer: Ah, isso é função principal. Sei função principal; eu preciso para executá-lo cada vez. O que dizer agora? compute_days (). O que está com essa função? Não sei se! Eu não sei o que quer de mim. Eu vou para exibir uma mensagem de erro e vou tomar o resto do dia de atraso:

Não se esqueça de definir a sua primeira função, caso contrário, o motor vai queixar quando você tentar usá-lo.

A propósito, o que é estranho com estas linhas

# include <acknex.h>
# include <default.c>

que sempre aparecem no topo do código suposto que fazer? # include acrescenta um outro pedaço de código para o nosso programa. acknex.h código padrão é o que precisamos sempre de acrescentar a um programa Pura Mode (lembrar a primeira lição?) e que contém todas as variáveis predefinidas e funções do motor. Default.c e contém algumas funções necessárias muitas vezes-, tal como o console de modo a última aula, bem como a capacidade de sair do programa, pressionando [Esc]. Ambos os arquivos podem ser encontrados em incluir a pasta. Omitir o '# include <default.c>' linha e [Esc] não irá funcionar anymore!

Você não estão ansiosos para saber mais? A nossa viagem através do maravilhoso mundo da lite-C revela-se muito fácil até ao momento, não é mesmo? O workshop irá seguir nos ensinar como criar painéis: elementos que podem exibir todos os tipos de números, bares, etc Sempre que você ver uma imagem ou uma figura na tela, há um painel definição que lhe está subjacente.

Seguinte: Bitmaps e painéis

Workshop 04: Bitmaps e painéis

Bitmaps

Um bitmap é nada mais do que uma foto com um arquivo criado pintura programa. Lite-C pode usar muitos formatos bitmap: pcx, bmp, TGA, DDS, jpg ..., ou 24 bit true color (altamente recomendado) ou 8 bits (não recomendado). Eu não posso sequer pensar por que você iria querer usar um 8 bits = 256 cores imagem ... esperar, eu sei porquê!

a) O seu jogo parece muito boa, e você quer fazer é olhar uglier;
b) Todos os clientes têm o seu antigo cartão 3D (como S3 Trio 3D ou Voodoo1), e você sabe que o jogo irá correr mais rápido em seus PCs se você usar 8 bits bitmaps.

Você deve usar true color bitmaps (texturas) o tempo todo, acreditem! Eu não iria comprar um jogo que usa apenas 256 cores para os seus níveis. Por outro lado, 32-bit Targa (TGA) bitmaps contêm um canal alfa adicionais que dá uma transparência de valor para cada pixel. Você pode chamar o canal alfa pintura usando seu programa (Photoshop, Paint Shop Pro, etc).

Como é que podemos definir um bitmap? Dê uma olhada no exemplo a seguir:

BMAP * health_pcx = "health.pcx";

Ok, por isso temos a palavra-chave BMAP terminando com um asterisco (*), seguido pelo nosso nome bitmap, e então escrever o nome do arquivo correspondente entre o "" (aspas). Temos a nossa script final linha de código com a marca, como de costume. Tenho chamado a minha bitmap health_pcx mas você pode usar qualquer outro nome, como por exemplo:

BMAP * teste = "health.pcx";

Você vê o que eu vejo? Quando eu quiser usar o bitmap no meu jogo (talvez alguns dias ou semanas depois) teste não será um nome pertinente para mim. Vou ter de verificar a definição de novo e de novo para ver o que "teste" significa. Ok, vamos definir o bitmap desta forma:

* BMAP saúde = "health.pcx";

Você acha que você vai lembrar o que é saúde depois de algumas semanas? Eu posso ouvir você perguntar: saúde é uma var, um bitmap, ou o quê? Já para não falar que você obterá erros se você tentar definir uma var que tem o mesmo nome com o bmap ... Convido você a usar nomes significativos para todos os recursos utilizados em seus projetos. É suficiente para mim para ver o nome health_pcx e eu vou saber que eu estou falando de um bitmap que utiliza um arquivo pcx. As definições eu uso para o bmp TGA e arquivos são semelhantes:

BMAP * ammo_bmp = "ammo.bmp";
BMAP * armor_tga = "armor.tga";

Outras pessoas utilizam outros métodos mencionando, por exemplo bmHealth (o prefixo bm significado bitmap). Tudo o que você usar, certifique-se de mantê-lo durante todo o seu código!

Os bitmaps são importantes recursos para nossos jogos, sempre que você ver uma foto da tela, há um bitmap definição que lhe está subjacente. Então o que estamos à espera? Vamos soltar o bitmap poder! Eu já criaram uma imagem fria e quero exibi-la na tela direita agora! Ok, nós podemos fazer isso, mas primeiro temos de aprender algumas coisas sobre ...

Painéis

Cada jogo tem que usar painéis! Se o seu jogo precisa de um painel, um cockpit, um botão, um ecrã, um inventário, etc você precisará usar um painel, uma rectangular bitmap que é colocado "durante" a tela. Cada jogo usa um mecanismo de 2D para tirar todas as coisas 2D; Lite-C inclui um aparato de 3D e 2D um motor tão bem.

Antes de começar, gostaria de lhe mostrar alguns exemplos de um painel de meu demonstrações: