sexta-feira, 29 de abril de 2011

Video Aula: Flash - Criando jogo de RPG - Parte 7

E finalmente a tão esperada parte 7 da vídeo aula de Flash, onde estamos aprendendo a desenvolver nosso jogo de RPG.


Nessa vídeo aula eu ensino a criar um sistema de menu simples, onde além de exibir dados do jogador também exibimos os itens que aprendemos a implementar na aula passada.

Nessa vídeo aula além de estudarmos uma parte importante e bastante comum nos jogos de RPG, os menus, eu ensino também partes interessantes referente a programação, entre elas a criação de funções, onde aprendemos a criar nossas próprias funções, uma parte importante na programação que ajuda na hora de organizar nossos códigos e deixá-los mais padronizados. Aqui empregamos a criação de uma função para desenvolver um sistema para uso de itens no jogo.

A dificuldade em desenvolver essa vídeo aula ficou em criar uma forma fácil de explicar a criação de um menu de lista de itens, uma parte um pouco difícil e alguns pode sentir dificuldade em aprender, então tenham paciência caso não entendam de primeira e revejam a vídeo aula, ou mandem um comentário caso tenham dúvida.

Quando terminarem a vídeo aula você verá que a lista de itens pode estar um pouco incompleta, faltando alguns detalhes como uma barra de rolagem para caso a lista seja extensa, o que por falta de tempo do You Tube teve que ficar para a próxima vídeo aula, além de outros detalhes como para os personagens do jogo quando o menu estiver ativo, dando um Pause no jogo.Então na próxima vídeo aula terminaremos nossa lista e vamos deixar o jogo mais refinado, como a pausa durante o menu e outras coisas que irão depender do tempo que sobrar do You Tube.

Então isto é só, fui!

terça-feira, 26 de abril de 2011

Lógica de Programação: IF, ELSE - Comandos de Controle de Fluxo

Hoje vamos começar a estudar mais uma parte importante na programação, os Comandos de Controle de Fluxo. Vamos entender melhor eles e compreender seu funcionamento.

Primeiro vamos pensar nas linhas do código fonte de um programa, que aprendemos anteriormente que nada mais é que um conjunto de comandos que serão executados pelo computador linha após linha assim como lemos uma receita de bolo. Se digitarmos comandos atrás de comandos até o final do código do programa sem nenhum tipo de comando de controle de fluxo, vamos ter uma espécie de programa burro, comparado a um funcionário que não pensa, apenas faz seu trabalho sem analisar, pensar ou questionar aquela ação. É para isso que serve os comandos de controle de fluxo, para que o computador possa analisar os dados do programa e a partir dai possa tomar rumos diferentes a partir das informações desse dado, complicado? Nem tanto, vamos continuar o raciocínio
.
Vamos começar com comando mais simples e mais comum na programação, o If. If significa em português "Se". É aquele "Se" que usamos em frases como, "Se o Corinthians ganhar a libertadores..." ou "Se eu sou inteligente...". A idéia na programação é a mesma, dar uma condição para que uma ação seja tomada. Se essa condição então for verdadeira, então alguma ação irá ocorrer, voltando ao português seria como, "Se o Corinthians ganhar a libertadores, vai chover canivete" ou "Se eu sou inteligente, eu sei programar". Para que uma ação seja tomada, primeiro é necessário que uma condição seja verdadeira, seja qual for essa condição, em poucas palavras é assim que podemos definir o If.

Se lembra anteriormente que eu falei da variável booleana, aquela que ela só armazena dois tipos de dados, true ou false, verdadeiro ou falso, 1 ou 0. Esses são os resultados que um If espera, um true ou false, recebendo verdadeiro ele executa as ações que lhe foram designadas, caso receba falso ela anula todas as ações designada a ela e o programa passa para os comandos após os comando do If.

Mas como testamos uma condição na programação? Para transcrevermos uma condição na programação devemos utilizar os Operadores de Comparação que com certeza você deve se lembrar a suas aulas de matemática da quinta série. São eles:

= (Igual)
> (Maior)
< (Menor)
<> ou != (Diferente)
<= (Menor ou Igual)
>= (Maior ou Igual)

Esses operadores são utilizados para montarmos nossas condições que vão retornar verdadeiro ou falso, de acordo com os dados que ele testar. Por exemplo, 1=5, essa condição retornará false e o If não vai executar os comando designados a ele, mas se a condição for 1<5, então o If vai retornar verdadeiro e logo as ações designadas ao If serão executadas. Da mesma forma, as condições 1=1, 6=>5 ou 3<4 retornam verdadeiro e as condições 5=6, 3<=1 ou 5>1 retornam falso por exemplo. Outra forma de retornar verdadeiro ou falso para  uma If é através das funções, porém vamos aprender isso mais para frente.

Lógico que em um programa ou jogo dificilmente iremos fazer testes assim, normalmente iremos testar as variáveis que aprendemos anteriormente. Por exemplo, vamos fazer um programa que ajude um médico a tomar certas decisões a partir de dados (variáveis) dos pacientes. Então certamente teríamos linhas parecidas com essa no nosso programa:

If idade_do_paciente>40
 "Faça o exame de próstata"

Ou mesmo o comando:

If mes_da_gravidez=9
 "Faça o parto!"

A lógica é sempre a mesma, o que muda de linguagem para linguagem são os operadores e a forma de escrever os comandos, como por exemplo, o C que usa dois iguais (==) para testes de igualdade.

Agora e se nesse programa desejássemos avisar para o médio caso as condições não fossem verdadeiras? É ai que entra o Else, que nada mais é que um complemento do If, e somente pode ser usado após ele. Else em português siguinfica "se não". Utilizado em frases como "Se eu ganhar na loteria, eu irei pagar as minhas dividas, se não vou deixar sem pagar mesmo" ou "Se eu souber programar, eu criarei um jogos, se não eu não vou criar nenhum jogo". E poucas palavras, é dar uma ação para ser feita caso a condição do If seja falsa. Então nosso programa ficaria:

If idade_do_paciente>40
 "Faça o exame de próstata"
Else
 "Esse tá salvo da dedada"

If mes_da_gravidez=9
 "Faça o parto!"
Else
 "Alarme falso"

No nosso exemplo introduzimos apenas um comando por If e Else, porém podemos colocar quantos comando quisermos dentro dos blocos de código do If e Else, até podemos colocar outro comando If dentro do If ou do Else caso ache necessário.

Na programação é muito comum se utilizar fluxogramas para demonstrar a forma como o programa vai tratar o fluxo de dados, abaixo temos uma fluxograma de exemplo mostrando um simples programa que usa o If e o Else.

Dessa forma podemos visualizar melhor a forma como os comandos de controle de fluxo trabalham. Nos fluxogramas, quando desejamos representar um comando de controle de fluxo, usamos um losango que é ligado em duas pontas diferentes, um para o resultado positivo e outro para o negativo, os outros elementos não são um padrão definido então podemos encontrar fluxogramas que usam outras formas para representar saída de dados ou texto, aqui uso um retângulo para dar inicio e fim ao fluxo, e uma forma de pontas esféricas para passar um texto para o usuário.

Agora voltando ao programinha do médico, verificamos a idade do paciente e o mês da gravidez da grávida, mas esse teste não é suficiente, pois se uma mulher tiver mais de quarenta anos ela será submetida ao teste de próstata, e aqui vai uma lição de anatomia de grátis para quem não sabe, mulher não tem próstata. Temos que complementar a condição do If, muito podem até pensar em colocar mais um If dentro do If, porém existe outra forma melhor de fazer isso, é através dos Operadores Lógicos.

Os Operadores Lógicos são usados para complementar o comando de condição, podemos adicionar quantos operadores quisermos em uma sentença de condição. As operações lógicas existentes são:

And ou && (E): Irá retornar verdadeiro apenas se as duas sentenças entre ele forem verdadeiras, exemplo 1=1 And 1<5 é verdadeiro, mas 1=1 And 1>5 é falso.

Or ou || (Ou): Irá retornar verdadeiro se uma das duas sentenças entre ele for verdadeira, independente se a outra for falsa. Exemplo, 1=1 Or 1<5 é verdadeiro, e 1=1 Or 1>5 também é verdadeiro, mas 1>5 Or 1>-1 é falso.

Not ou ! (Não): Irá retornar verdadeiro sem a condição a sua frente for falsa, e retornará falso se a condição a frente for verdadeira. Basicamente inverte o resultado da condição. Not 1=1 é falso, e Not 1<5 é verdadeiro.

Confuso? Vamos a pratica para clarear as idéias, programa para o médico ficaria assim.

If idade_do_paciente>40 And sexo="masculino"
 "Faça o exame de próstata"
Else
 "Esse tá salvo da dedada"

If mes_da_gravidez=9 And Not sexo="masculino"
 "Faça o parto!"
Else
 "Alarme falso"

Mas o médico não tá satisfeito com o sistema de gravidez, ele quer detectar se a gravidez é de risco, que ocorre quando a mulher é menor de quinze anos ou maior de 35 anos, nesse caso deve-se usar o Or.

if idade<=15 Or idade>=35
 "Gravidez de risco"
Else
 "Gravidez normal"

Entendeu agora, não é tão difícil, iremos usar muito esses controladores sempre em nossos jogos, como por exemplo, para passar para uma próxima fase do jogo o jogador tenha que acumular mais de 1000 pontos, logo teríamos um If com uma condição pontos>1000, porém além disso o jogador tem que ter três chaves, então teríamos uma condição como pontos>1000 And chaves=3. É Simples, e é um bom treino de raciocínio lógico.

Como exercício tente pensar nos seus jogos favoritos e tente imaginar qual a sentença usada nas condições para detectar suas ações nos jogos, é uma forma de se preparar para pensar no seu jogo.

Por hora é só, e me despeço antes que algum Corintiano apareça querendo me espancar.

quarta-feira, 20 de abril de 2011

Termos Técnicos: Buffer, Frame Buffer, Double Buffer, Triple Buffer.

E vamos lá enriquecer mais um pouco nosso vocabulário de criadores de jogos. Vamos falar agora dos Buffers.

Buffer na computação se refere a uma memória temporária, utilizado quando o computador processa certos dados, porém a saída desses dados é mais lenta que o processamento, então para que o processador não pare a espera da saída dos dados processados, ele armazenado dado processado no Buffer e continua processando o próximo dado, e quando a saída estiver disponível, requisita o próximo dado já processado que está no Buffer.

Essa técnica é empregada nos jogos também, e torna a fluidez dos jogos muito melhor. A placa de video e o processador podem ser mais rápido ou mais devagar para renderizar cada quadro dos jogos, isso depende do numero de elementos que a imagem tem em cena. Se visualizássemos os quadros assim que a placa e o processador gerassem os quadros, certamente não íamos entender nada do jogo, pois uma hora iríamos ver o jogo rápido demais, outra hora seria lento demais. Por isso ao invés de renderizar e exibir a imagem diretamente para o jogador, o processador e a placa de vídeo renderiza a imagem e passa para o Buffer, assim o jogador visualiza sempre o mesmo número de quadros por segundo, os FPS já estudados aqui. Quando tratamos de Buffer para renderização de imagens, chamamos esse buffer de Frame Buffer.

Mas mesmo com essa técnica, ainda sim não poderíamos visualizar os jogos de forma confortável se não fosse outra técnica empregada nos jogos, ela se chama Double Buffer, e muitos podem até desconhecer o que realmente essa técnica faz, pois precisamos visualizar um jogo sem essa técnica para realmente ver a diferença e a real utilidade dela. Se simplesmente mandássemos cada quadro para ser exibida pelo monitor sem o Double Buffer, cada imagem da animação do jogo seria exibida e depois apagada para que a próxima imagem renderizada da animação seja exibida, ou seja, exibe a cena - apaga - exibe a cena. Isso resultaria numa animação travada e até causaria irritação nos olhos dos jogadores.

A técnica Double Buffer trabalha diferente, ela exibe uma imagem renderizada para o jogador, até ai normal, porém ao exibir a próxima imagem renderizada da animação, a placa de vídeo ao invés de apagar a imagem anterior, ele na verdade sobrepõe a imagem anterior com a nova imagem  aos poucos, para ser mais exato ela sobrepõe pixel após pixel. Ou seja, ela pega o primeiro pixel da nova imagem e joga encima do primeiro pixel da imagem anterior, depois o segundo pixel da nova imagem sobre o segundo pixel da imagem anterior, e assim vai até que a imagem anterior tenha sido trocada totalmente pela nova imagem. Isso ocorre o tempo todo, durante todo o jogo, por isso o nome Double Buffer, ou duplo buffer, pois seriam necessários dois buffer, um para armazenar a cena anterior e outro para a nova.

Existe também o Triple Buffer, que na verdade é a mesma idéia, só que enquanto o efeito de sobreposição está ocorrendo já existe uma terceira imagem renderizada e pronta para ser jogada no monitor, adiantando ainda mais processamento, já que ele não fica esperando o efeito sobreposição terminar para gera uma nova imagem, lógico isso exige mais espaço para Buffer da placa de vídeo, mas os ganhos na fluidez das animações são muito satisfatória.

terça-feira, 19 de abril de 2011

Dicas: Yo Frankie!, o jogo Open Source feito em Blender

Mundo dos softwares, quando nos referimos a programas Open Source estamos falando de programas que além de serem distribuídos gratuitamente, também é possível baixar o código fonte do programa para fazer suas próprias modificações ou somente aprender seu funcionamento ou talvez até ajudar no desenvolvimento do software.

Mas, ao contrário do mundo dos programas para computadores onde temos diversos projetos assim, já no desenvolvimento de jogos não temos muitos projetos assim, normalmente podemos apontas poucos projetos de jogos Open Source por linguagem, e normalmente são iniciativas dos próprios criadores da linguagem ou do software de desenvolvimento. Um desses raros projetos é o Yo Frankie! feito no Blender pelo Blender Institute.


Yo Frankie! é um jogo baseado na animação Big Buck Bunny, uma animação também totalmente feita no Blender, se não assistiu assista pois é a prova de que dá para fazer animações profissionais a moda Pixar no Blender. O jogo controlamos um dos vilões do curta, o esquilo Frankie, onde devemos passar por diversas fases fazendo aquilo que vimos ele fazer no filme, maltratar os outros animaizinhos.

O game em si é muito bem feito, a qualidade gráfica é comparada a grandes produções, mostrando que a engine gráfica do Blender realmente é poderosa. A jogabilidade é simples, não é tão intuitiva mas nada que estrague o jogo. A parte chata do jogo fica por conta dos carregamentos, os loadings. A cada novo cenário carregado temos um, e para um jogo simples eles são um pouco demorados, o que mostra que o Blender ainda precisa trabalhar nisso direito.

Mas o legal mesmo para nós e explorar a produção do jogo, aqui podemos ver desde as texturas utilizadas nos jogos até o código conte utilizado no Blender, é uma ótima oportunidade de conhecer um projeto de jogo por dentro, para termos uma idéia de como funciona. Já não bastasse isso, ainda é possível encontrar no site vídeo aulas mostrando como o jogo foi feito passo a passo. O problema aqui é que é tudo em inglês, então alguns poderão não conseguir tirar todo proveito dessas aulas.




Para obter o projeto aberto e o jogo basta acessar o site acima e ir em Download, lá você baixa o jogo e o projeto Open Source tudo de uma vez, totalizando uns 120 mb. E lógico que é preciso ter o Blender já instalado para explorar o projeto aberto. As vídeo aulas se encontra na mesma página, e o resto é diversão, tanto para os jogadores quanto para os criadores de jogos.


Fica ai a dica para os Blendermaniacos, fui!

domingo, 17 de abril de 2011

Video Aula: Blender - Modelando Personagem para Jogos - Parte 2

E como prometido, eis que trago a segunda parte da video aula onde estamos aprendendo a modelar um personagem em LowPoly no Blender.


Bem, não tem muita coisa de novo referente ao que ensino nessa aula em comparação com a primeira aula, apenas pego as mesmas técnicas aplicadas até agora em parte do corpo para modelar o resto e concluir o modelo.

Como podem ver na imagem, com essa vídeo aula fechamos o modelo básico, eu poderia colocar mais detalhes e até posso fazer isso em uma futura vídeo aula, mas por hora acho que é o suficiente e já da para dar prosseguimento na vídeo aula para ensinar outras coisas.

Para a próxima vídeo aula vamos começar a texturizar nosso personagem LowPoly e assim adicionar os detalhes que não foram colocados no próprio modelo.

Por hora é só, fui!


sábado, 16 de abril de 2011

Video Aula: Blender - Modelando Personagem para Jogos - Parte 1

E como prometido, estou de volta a rotina normal de vídeo aulas, e para compensar o tempo perdido estou trazendo uma novidade, uma nova série de vídeo aulas, agora vamos modelar um personagem LowPoly no Blender.

Acredito que aqui não preciso apresentar o Blender, além de eu já ter demonstrado algumas coisas dele na série de vídeo aulas do Blitz, ele praticamente é usado por todos aqueles que se iniciam na modelagem 3D, por ser justamente o mais acessível.

Ao contrário da série de modelagem do 3D Studio onde eu tomo um rumo mais detalhado, o que resulta numa série mais longa, aqui decidi fazer algo mais direto, por isso a escolha de modelar um modelo LowPoly, pois ele é mais rápido de se fazer, em poucas vídeo aulas teremos um modelo completo, texturizado e animado, pronto para exportar para os jogos.

Uma dica para quem quer criar um modelo mais detalhado é tentar pegar as técnicas de modelagem detalhada que eu uso no 3D Studio e aplicá-la aqui nesse modelo do Blender.

Outro ponto aqui é que eu continuo não usando referencia alguma na minha modelagem, você podem achar eu meio chato, o que eu realmente sou heheh. Mas enfim, gosto de trabalhar a olho nu mesmo, sem referência alguma, e aqui ao contrário de passar os conhecimentos sobre as métricas do corpo humano como feito no 3DS, eu já passo as medidas prontas para vocês aplicarem diretamente no modelo.

A mais uma novidade aqui, é que eu produzi meia hora de vídeo, ou seja, na verdade essa primeira parte é uma divisão, e a outra parte eu já estou terminando de editar, e assim que eu terminar já posto a segunda parte, o que não vai demorar muito. Então aguardem, pois provavelmente meu próximo post será a segunda parte dessa vídeo aula.

Então, fiquem por enquanto com essa, e aguardem mais novidades.

sexta-feira, 15 de abril de 2011

Teste de popularidade, Twitter

Olá povo, não, ainda não trago uma vídeo aula nova, mais calma que to terminando de editar e logo trago novidades. A novidade desse post é na verdade um novidade para mim também, trago a vocês o Twitter do blog.

Confesso a vocês que não sou muuuito fã do Twitter, para ser sincero nem me lembro da senha da minha conta que criei no ano passado dele. Mas admito a importância do twitter como uma ótima ferramenta para se difundir informação de forma rápida, então nada melhor que agregar essa ferramenta ao blog.

Não se preocupem que não vou twittar que estou no banheiro no momento ou cortando as unhas dos pés. Tentarei usar dessa ferramenta da mesma forma que uso o blog e o MSN, ajudar aqueles que desejam desenvolver seu jogos, então não twittarei nada que eu não ache que realmente seja útil para os visitantes desse blog.

Sem mais, fui!

quinta-feira, 14 de abril de 2011

Calma que to vivo ainda!

Opa! olha só que está de volta!

Bem como podem notar estive fora alguns dias e o blog ficou sem atualizações, foram só alguns dias para resolver uns assuntos pendentes, mas já está tudo resolvido e estou de volta ao blog.

Para compensar a ausência de alguns dias estou preparando uma nova vídeo aula aqui, que já posso adianta que com certeza com certeza vai agradar aos usuários do Blender, e assim que terminar a edição do vídeo posto aqui no blog.

E isso é tudo por enquanto.

sexta-feira, 8 de abril de 2011

Lógica de Programação: Variáveis

Para ajudar aqueles que acompanham minhas séries de vídeo aulas, decidi fazer essa série de post para ajudar aqueles que estão iniciando na área de programação de jogos a entender melhor os termos e as lógicas que aplico nas vídeo aulas.

Primeiramente vamos entender o que se trata a lógica de programação. A melhor comparação que se pode fazer com a programação com a vida real, é a uma receita de bolo, funciona da mesma forma. Em uma receita primeiramente tempos os ingredientes que são declarados no início, depois temos o modo de fazer que deve ser seguido e executado linha a linha, da forma que é dita na receita. Temos aqui uma ótima analogia para programação, pois é dessa forma que basicamente cada linha de um programa funciona.

Uma vez me perguntaram em que ordem o computador lê os códigos inseridos na programação, pode parecer esquisito para alguns, mas algumas pessoas que estão iniciando podem ter essa dúvida, então por isso acho interessante frisar que assim como lemos um texto da esquerda para direita, de cima para baixo, os códigos de programação são lidos e executados da mesma forma, da esquerda para direita, de cima para baixo, linha após linha. Isso pode não ser sempre verdade, mas por enquanto para você que está começando é melhor entender dessa forma.

Assim como uma receita de bolo, onde no inicio declaramos os ingredientes que iremos usar, na programação devemos declarar no inicio os nosso ingredientes antes de realmente utilizá-lo, e um dos nossos ingredientes principais são as variáveis. Variáveis são na verdade pequenos espaços na memória onde armazenamos dados, mas para facilitar vamos fazer uma boa analogia, uma variável pode ser comparada a uma caixa. Numa caixa podemos armazenar qualquer coisa, ou mesmo nada, porém, as caixas têm um limite no que se pode armazenar dentro delas, as variáveis também são assim, elas tem um limite no número de dados que se armazena dentro delas. Se vamos usar uma caixa para armazenar algo, antes de comprá-la devemos saber o tamanho da caixa que iremos precisar, da mesma forma antes de criar uma variável devemos especificar seu tamanho através da declaração.

Quando declaramos uma variável, estamos primeiramente dizendo o que iramos guardar dentro dela, a partir dessa informação, o computador irá reservar um espaço para armazenar esse dado, que pode variar de acordo com o tipo variável escolhida na declaração. Somente após declararmos à variável e esse espaço for reservado na memória, poderemos usar essa variável para armazenar o tipo de dado pré definido na declaração.

Mas quais tipos de variáveis existem? Existem diversas, e há caso de linguagens de programação que tem tipos próprios de variáveis, porém existem os tipos básicos que são encontrados em todas elas, e que a maioria dos outros tipos de variáveis se baseia, são elas:

Inteiro (int): Variáveis do tipo inteiro armazenam somente números inteiros, esses incluem os números 1, 2, 3, 4 e assim por diante. E os valores negativos como -1, -2, -3, -4 e assim por diante. Porém não incluímos os números quebrados que são aqueles valores que tem casas decimais após a vírgula como 1,4 ou -0,5 por exemplo. O valor máximo que se pode armazenar nesse tipo varia de linguagem para linguagem, porém normalmente é muito alto, coisa de ultrapasse a casa dos milhões.

Flutuante (float): Assim como o inteiro, abrange os números 1, 2, 3..., e negativos como -1, -2, -3 ..., mas ao contrário do inteiro, ele cobre também os números quebrados que tem valores após a virgula, como 1,9 ou -5,1 por exemplo. Algo que deve ser ressaltado sobre os números quebrados é que as linguagens de programação utilizam-se de ponto (.) no lugar da virgula ao declarar números quebrados, ou seja, se nós gostaríamos de passar o valor 1,82 então devemos escrevemos 1.82.

Caráter (char): Pode armazenar somente um caráter, podendo ser ele letras como a, b, c..., ou numérico como 1, 2, 3... Também pode ser caracteres especiais com cifrão, dois pontos, ponto e vírgula, etc. Porém nem todas as linguagens suportam todos os caracteres especiais, podendo variar de linguagem para linguagem. A valore numéricos quando armazenados nesse tipo não podem ser utilizados para operações matemáticas, pois perdem seu valor numérico, sendo considerado um simples caráter visual.

Booleano (bool): Esse tipo pode armazenar somente dois tipos de valores, 0 ou 1 que são tratados respectivamente como falso e verdadeiro (false e true).

Caracteres (string): Esse tipo pode armazenar um conjunto de caracteres para formar frases e palavras, podendo variar o número máximo de caracteres para cada linguagem de programação. Algumas linguagens como o C, tratam string como um conjunto de variáveis do tipo char.

Esses são os tipos mais básicos de variáveis, existem outros, mas na maioria são versões dessas variáveis básicas com alguns incrementos como, por exemplo, o tipo double encontrado em algumas linguagens que serve para armazenar números maiores do que o tipo float não suporta.

Devemos antes de declarar um tipo de variável pensar em sua finalidade,  porque cada tipo requer um tamanho diferente na memória. Uma variável do tipo float por exemplo ao ser declarada exige mais espaço liberado na memória do que se fosse declarado um tipo inteiro. Mesmo que os computadores dos dias atuais disponham de um amplo espaço de memória, esses espaços não são infinitos, por isso ainda sim devemos pensar o tipo correto de variáveis a se declarar. Mesmo porque também nem sempre vamos lidar com um grande espaço de memória, como no caso de aplicativos desenvolvidos para dispositivos moveis como os celulares, normalmente eles dispõem de pouca memória e deve ser trabalhado sempre pensando nesse espaço limitado.

Ao declararmos uma variável, também damos um nome a ela, pelo qual podemos identificar essa variável. Ela pode conter qualquer nome desde que siga algumas regras que também variam de linguagem para linguagem, mas na maioria basicamente tem as mesmas regras. Uma delas é não poder começar o nome com um número, podendo somente utilizar números após o primeiro caráter. Não usar caracteres especiais como aspas, asterisco e  parênteses, e nem caracteres reservados que variam de linguagem para linguagem, como por exemplo < (menor), ; (ponto e vírgula), : (dois pontos), etc. Enfim, é sempre recomendado se utilizar letras, e números somente após o primeiro caractere.

Outro ponto sobre os nomes é que “A” é diferente de “a”, em linguagem de programação chamamos isso de  Case sensitive. Se declararmos uma variável com nome de Amora, não poderemos usar ela mais para frente usando o nome amora, nome com letras maiúsculas são diferentes de letras minúsculas e você deve prestar atenção ao utilizá-las para que não cause erro em seus códigos. Na verdade essa regra vale para quase tudo que é escrito em um código na maioria das linguagens de programação.

As variáveis são a base da programação e são utilizados em praticamente todo o decorrer de um código de um programa ou jogo, por isso devemos fixar bem suas regras e a forma de usar, para fazermos bom uso delas e tornar nosso código mais simples e gerando um programa ou um jogo mais leve.

Espero que tenham compreendido essa pequena introdução a programação, e agora consigam compreender melhor a forma que trabalho com as variáveis nas minhas vídeo aulas. Em breve estarei postando explicações mais detalhadas sobre outros elementos que fazem parte da programação de jogos e programas para computadores em geral.

quarta-feira, 6 de abril de 2011

Video Aula: Blitz3D - Criando um jogo FPS - Parte 5

Essa demorou um pouco, mas prometo que esse valeu à pena esperar, quinta parte da vídeo aula da série em que estamos programando um jogo FPS no Blitz Basic 3D.


Essa demorou um pouco porque nessa última semana estava com conjuntivite, isso explica também porque não tive muitas atualizações no blog, porém já estou recuperado e de volta ao trabalho. Mas vamos ao que interessa, essa nova vídeo aula.

Nessa vídeo aula começamos a programar nosso inimigo no jogo, digo começamos pois ao contrário do que eu imagina, não foi possível explicar a programação do inimigo em uma aula só. Aqui aprendemos o básico sobre o inimigo e sua inteligência artificial.

Para homenagear a minha série favorita que está completando 15 aninhos essa semana, a série Resident Evil, o inimigo que vamos programar é um zumbi, o que veio a calhar, pois a inteligência artificial de um zumbi é a mais simples e um inimigo de jogo, ideal para ensinar para aqueles que estão começando na programação de jogos.

Nessa vídeo aula também temos o primeiro contato com um modelo animado, porém como o tempo de vídeo aula não dá para ensinar a modelar e animar um zumbi rapidamente optei por baixar um já modelado e animado na internet. O site http://www.psionic3d.co.uk/ distribui gratuitamente modelos 3D que já vem pronto para serem usados no Blitz, então ficou fácil dessa vez, quem quiser pode usar outros modelos que se encontram no site para usar no projeto, basta apenas adaptar os comandos que ensinei na vídeo aula para o modelo especifico.

Porém, como foi dito, nessa vídeo aula apenas colocamos o inimigo no cenário e fizemos ele perseguir o jogador, fico devendo para a próxima vídeo aula programar o ataque do zumbi e como fazer ele morrer. Mas com o que já foi ensinado aqui você já pode encher seu jogo de zumbi e quem sabe fazer seu próprio Resident Evil.

Por hora fico por aqui.

sexta-feira, 1 de abril de 2011

Termos Técnicos: FPS, Slowdown e Anti-Aliasing

Vamos aprender mais alguns termos para enriquecer nosso vocabulário de criadores de jogos. Vamos começar com um simples, e certamente, quem costuma jogar jogos de PC já deve ter se deparado com ele, os FPS, não o do tiro em primeira pessoa, esse é o referente a velocidade do jogo.

FPS significa Frames per second, ou para o português, Quadros por segundo. Quem já comprou um jogo que tinha um desempenho lento na sua modesta placa de vídeo deve já conhecer esse termo na prática. O número de frames por segundo que nossos jogos podem exibir está ligado ao desempenho, se você tentar executar um jogo muito pesado em uma placa de vídeo simples, certamente obterá poucos FPS, e poderá sentir isso ao ver uma certa lentidão no decorrer do jogo.

O termo na verdade não nasceu no mundo dos games, na verdade ele é um termo que já era usado já no inicio do cinema mudo. Por exemplo, o filme da Disney A Branca de neve e o sete Anões de 1937 é um marco na história da animação por ser um dos primeiros longas animado a ter 24 FPS, imagina na aquela época, sem computador algum, desenhara e pintar a mão 24 quadros para cada segundo do filme.

Mas voltado para os jogos, hoje os jogos se limitam a 60 FPS, um número suficiente de frames para não deixar nossa visão perceber qualquer parada entre um frame e outro. Porém nem sempre os jogos conseguem atingir 100% desses 60 FPS. Para os jogos de PCS isso normalmente está relacionado ao baixo desempenho do computador e da placa de vídeo, porém esses baixos desempenhos podem ser encontrados em alguns caso nos consoles, é mais raro de fato, pois os jogos de consoles são produzidos para uma configuração especifica enquanto os de PC são produzidos para atender sempre a ultima linha de placa de vídeo existente. Quando isso ocorre em um jogo que está em um PC de ótimas configurações ou mesmo em um console, usamos o termo Slowdown.

Os Slowdown, que pode ser traduzido para lentidão, ocorrem normalmente quando há muitos elementos gráficos na tela ao mesmo tempo, por isso nem sempre é possível prever que eles ocorram em um jogo. Pegamos um exemplo conhecido, GTA San Andreas, se você une uns 20 carros em um local que tem diversos pedestres passando e começar a atirar para todos os lados até a policia aparecer, isso tudo somado a um efeito de tempo como chuva, na maioria dos computadores ou mesmo no PS2, teremos uma queda no número de FPS, então teremos um slowdown.

Nem sempre é possível evitar esses casos, as chances são maiores quando estamos tratando de jogos com uma diversidade de opções como GTA. Porém existem muitas formas de tentar evitar isso, muito programadores optam por programar uma espécie de medidor de FPS, caso ele comece e se mostrar baixo são desativados ou minimizados certos efeitos temporariamente que talvez não sejam notados em cenas tão complexas. Um desses efeitos pode ser o Anti-Aliasing.

O Anti-Aliasing ou Anti-Serrilhado se trata de um efeito para disfarçar serrilhados gerados pela utilização de pixels na renderização. Um exemplo clássico, você conhece o Mario? Certamente já deve ter visto o primeiro jogo do Mario ou mesmo o boneco em algum lugar por ai mesmo que de relance. Se notarmos ele é feito de poucos pixels, isso logo causa um enorme serrilhado em sua forma, ao invés de deixá-lo redondo.
Da época em que  o primeiro Mario foi lançado até hoje os processadores evoluíram e hoje podemos exibir um número maior de pixels na tela, porém ainda estamos limitados aos pixels, logo também estamos limitados aos serrilhados, afinal para os pixels não existem nem uma forma perfeitamente arredondada. Para evitar esses serrilhados então foi criado o Anti-Aliasing, que nada mas faz do que pegar as formas geradas pelo pixels e gerar uma linha de pixels que contorne as formas e o plano de fundo da imagem, essa linha  misturaram as cores das formas e do plano de fundo até deixar o contorno mais suave e desfocado.

Para criar o efeito Anti-Aliansing, é necessário que o processador e placa de vídeo faça muitos cálculos que envolvem cores, distancia dos objetos, textura, etc. Logo o efeito Antia-Aliasing pode ser um efeito muito pesado para o processador e como ele normalmente só é notado em cenas menos movimentadas, ele pode ser desativado em cenas mais complexas de se gerar em pró da produtividade do processador e sem afetar drasticamente o visual de um jogo. Existem outras técnicas para se atingir um ótimo desempenho e evitar slowdown nos jogos, e se possível futuramente falarei sobre eles.