GAME ENGINE DO BLENDER(Traduzido por Aclive)http://ddj.orgfree.com

1. INTRODUÇÃO:

1.3 - Por que utilizar a engine Blender? Qual o seu potencial?

- Ambiente integrado, com modelador, animação e “game player”.- Construção de objetos com Física aplicada (dinâmica de corpo rígido) e simulação de colisão.- De fácil interatividade com sensores predefinidos e outros blocos lógicos.- Multiplataforma: Windows, Linux, FreeBSD, BeOS, Irix e mais...

1.4 - LÓGICA DE UM JOGO:

A figura abaixo mostra um objeto (o jogador) num cenário simples.

Esta seção corresponde a um pequeno tutorial que irá ensiná-lo a:- Ajustar os atributos dos objetos;- adicionar blocos lógicos- conectar os blocos lógicos- o uso básico de teclado, “Always” e “Touch Sensor” (sensor de toque)

Este documento não ensina como usar o Blender, a modelar ou fazer qualquer animação. Para estas informações, procure o manual ou os inúmeros tutoriais dispostos na internet.

Preparando:Inicie o Blender e carregue o arquivo “B-Man1.blend”. Você pode usar a tecla F1 ou o menu

“FILE” para carregar a cena. Com a cena já carregada, provavelmente você verá algo parecido com o screenshot abaixo:

A janela 3D a esquerda é uma “view” texturizada para a câmera. A janela direita é um frame do arame da observação do caracter “jogador” (player). Ele está selecionado, devido a sua coloração rosa.

A parte inferior é onde se encontra os botões com as funções (RealTimeButtons), você pode chamá-las com F8. É aqui que a maioria do trabalho de interatividade dos gráficos 3D no blender serão feitos.

Agora podemos iniciar a “gameEngine” movendo o cursor do mouse para a janela 3D e pressionando a tecla “P”. Com nós não definimos qualquer tipo de interatividade você vai ver as linhas de controle desaparecerem e o céu azul em vez de cinza. Pressione ESC para parar a “gameEngine” novamente.

Fazendo um ator “que cai”:Agora clique com o botão esquerdo do mouse sobre o “ator” no “RealtimeButtons”.

Simplesmente ative o botão escrito “DYNAMIC”. Isto define par o objeto selecionado como um ator que ele será construído com atribuições de “Física” da “gameEngine” (ou seja, será um corpo que é afetado por uma gravidade). Se você acidentalmente tirar a seleção do jogador torne a selecioná-lo com o botão direito do mouse e recarregue a cena.

Atributos a serem ajustados para o objeto

Agora rode a “gameEngine” novamente. Pressione a tecla “P” com o mouse sobre o a janela com a opção “texturizada” e você verá o “jogador” cair sobre o terreno e saltar algumas vezes. Pressione ESC pra parar a engine.

Movendo o ator:O “RealtimeButtons” estão logicamente divididos em quarto colunas. A coluna mais a esquerda

é usada para ajustar os parâmetros que fazem o objeto “cair”. As outras três colunas são usadas para a construção das interatividades que acontecem em seu jogo.

Agora vamos mover o jogador pelo ambiente.

Existem três partes chamadas “Sensors” (Sensores), “Controllers” (controladores) e “Actuators” (atuadores). Você pode pensar os “Sensors” como uma forma de vida (que dá vida ao jogador), os controladores como o cérebro e os atuadores como a musculatura.

Agora pressione o botão “Add” para cada coluna uma vez com o botão esquerdo do mouse para fazer um “LodigBrick” (bloco lógico) para os sensores, controladores e atuadores.

Selecionando o tipo de “LogikBrick”.

O screenshot acima mostra os tipos de “LogicBricks” existentes. Clique no botão escrito “Always” e escolha “Kayboard”. Na versão 2.41 o screen é um pouco diferente do de cima, mas no geral é bem semelhante.

Agora clique com o botão esquerdo no interior da caixa fazia correspondente ao campo “key”. O texto “Press any key” aparece. Pressione a tecla que você deseja para mover seu personagem para frente (eu sugiro a seta para cima).

Agora nós temos como controlar o movimento. Nós vamos definiar como o jogador vai se mover. A primeira linha de números é chamada “FORCE” e define com que força será aplicada quando o controle de movimento estiver ativo. Os três numeros são as respectivas forças no eixo X, Y e Z.

Se olhar na malha do jogador você verá para onde o eixo X está apontando. Para mover para frente é necessário aplicar uma força “positiva” ao longo do eixo X. Para fazer isto basta clicar sobre o número com o botão esquerdo do mouse. Coloque o valor 10.00 para X.

Nos temos que fazer as ligações como foram exibidas no screenshot mais acima. Nos precisamos conectar através de linhas os blocos lógicos.

Clique e arraste com o botão esquerdo do mouse pressionado sobre a bola amarela do “Keyboard Sensor” e você observará uma linha preta, ligue esta linha preta no anel no controlador AND. Solte o mouse e agora os “LogicBricks” estão conectados. Agora conecte a bola amarela do controlador AND com o anel do controle de movimento (Motion Controller).

Para deletar uma conexão mova o mouse sobre a conexão. A linha irá ficar evidente e você poderá apagá-la pressionando a tecla X ou DELETE.

Agora pressione a tecla “P” para iniciar a “gameEngine” e então pressione a SETA PARA CIMA e você verá o jogador indo para frente ao longo do eixo X.

Mais controles:Agora adicione mais “LogicBricks” como mostrado no screenshot abaixo. Estes “LogicBricks”

vai permitir você mudar a orientação do personagem utilizando as teclas de setas. Note que a linha “Torque” do “Motion Actuator” produz um movimento de giro no jogador em torno do eixo especificado. No caso, o eixo Y.

Pulo:Para adicionar mais graus de liberdade e também para mostrar mas um sensor como controle de

entrada, iremos fazer o jogador pular.

Adicione o “LogicBricks” como exibido na figura acima para o jogador. O é ativado através do teclado. Mas existe também um outro sensor conectado ao controlador AND, é o sensor “Touch”. O controlador “Touch” somente dá um impulso no jogador quando o objeto está tocando algo. Esta correlação é lida da seguinte forma “Se a tecla A for pressionada E o jogador estiver tocando o terreno (ou piso), ENTÃO dê um impulso produzido pelo atuador de movimento”. Este caminho assegura que o jogador não vai dar um novo salto enquanto estiver no ar. Tente deletar a ligação do sensor “Touch” para o controlador AND e vejo o que acontece...

O controle para o pulo está conectado a dois “Motion Controllers”, ambos tem uma força de 100.00 para o eixo Z. Porque o valor 100.0 é o máximo para cada atuador de movimento, assim nós usamos dois atuadores para obter um impulso maior e produzir um pulo mais alto.

2 - A ENGINE:Tecnicamente a “GameEngine” é uma central de trabalho com uma coleção de módulos para

propósitos interativos como Física, gráficos, lógica, som e network. O funcionamento se processa num ambiente de realidade virtual, consistindo da construção de ambientes e comportamentos (como Física, animação e lógica). Os elementos deste ambiente – também chamado objetos do jogo (GameObjects) – comportam-se autônomamente após ajustes de uma ferramenta chamada “LogicBricks” e propriedades. Para refrescar a nossa memória, os “Sensors” são os sensores, os “Controllers” é o cérebro e os “Actuators” permitem que a ação aconteça, ou seja, são os “músculos” do objeto.

Até o momento “Controllers” podem ser scriptados usandos a linguagem python ou também expressões simples. A idéia é que a criação de blocos lógicos possam ser editados utilizando caminhos alternativos no futuro. “Controllers” podem ser mudado para determinados centros de controle, como o centro audio visual, centro de movimentação, etc..

2.2 - Opções da GameEngine:

Com este menu você pode mudar as opções durante a edição da cena. Correntemente somente a opção “Autostart” é salva com o arquivo.

Start Game (tecla P) :: Inicia a GameEngine.

Use vertex arrays :: Habilita (verifica) ou desabilita o uso de “vertex arrays”. VertexArrays normalmente aumenta a velocidade de calculos complexos na cena. Se seu systema não suporta OpenGL vertexarrays você pode desabilitar a função.

Enable All Frames :: Esta opção verifica se a GameEngine roda em 50 Hertz sem “quebra” de frames. Isto é útil enquanto “executa” para a “Targa-Sequence” ou quando necessita ter certeza que todas as colisões são calculadas sem perdas sobre computadores mais lentos.

Disable Sound :: Habilita e desabilita o som.

Disable Mipmaps :: Não use mipmap, isto pode aumentar a velocidade de processamento (obviamente vai depender da máquina)

Autostart :: Habilita a iniciação automática ao ler o arquivo.

2.3 Opções em linha de comando para a GameEngine:Quando o Blender é carregado com a opção –h na linha de comando (shell do Windows ou

janela DOS) ele irá imprimir os parâmetros da linha de comando. Veja abaixo:

bash-2.00$ blender -h Blender V 2.12Usage: blender [options ...] [file]

Render options: -b <file> Render <file> in background -S <name> Set scene <name> -f <frame> Render frame <frame> and save it -s <frame> Set start to frame <frame> (use with -a) -e <frame> Set end to frame (use with -a)<frame> -a Render animation

Animation options: -a <file(s)> Playback <file(s)> -m Read from disk (Don't buffer)

Window options: -w Force opening with borders -p <sx> <sy> <w> <h> Open with lower left corner at <sx>, <sy> and width and height <w>, <h>

Game Engine specific options: -g fixedtime Run on 50 hertz without dropping frames -g vertexarrays Use Vertex Arrays for rendering (usually faster) -g noaudio No audio in Game Engine -g nomipmap No Texture Mipmapping -g linearmipmap Linear Texture Mipmapping instead of Nearest (default)

Misc options: -d Turn debugging on -noaudio Disable audio on systems that support audio -h Print this help text -y Disable OnLoad scene scripts, use -Y to find out why its -ybash-2.00$

-g fixedtimeEsta opção roda a engine em 50 hertz sem baixar os frames. Isto é útil enquanto “executa” para

a “Targa-Sequence” ou quando necessita ter certeza que todas as colisões são calculadas sem perdas sobre computadores mais lentos.

-g vertexarraysDesabilita o uso de vertexarrays. VertexArrays normalmente aumenta a velocidade de calculos

complexos na cena. Se seu systema não suporta OpenGL vertexarrays você pode desabilitar a função.

-g noaudioDesabilita o som.

-g nomipmapNão usa mipmap. Isto pode aumentar a velocidade do jogo.

-g linermipmapAjusta o mipmapping de textura para Nearest (default).

2.4 - O “RealTimeButtons”:O “RealtimeButtons” é o conjunto de botões que permite produzir interatividade entre os

objetos 3D presente no ambiente no Blender. O Blender é uma ferramenta completa de desenvolvimento para interatividade no mundo virtual incluindo uma “gameEngine” para a criação de jogos. Tudo isso pode ser feito sem precisar compilar o jogo ou o cenário. Simplesmente pressione a tecla P e execute tudo em tempo real. Na janela principal de trabalho encontra-se o botão que dá acesso ao “RealtimeButtons” ( ). Aqui você definirá seus blocos lógicos (LogicBricks) e com isso o comportamento de seus objetos.

Informação: A palavra “games” (jogos) aqui é usa para todos os tipos de interatividade 3D. O Blender não existe limitação quanto ao tipo de jogo que se deseja criar.

Os “RealtimeButtons” podem ser logicamente ser separados em duas partes. A parte à esquerda contém os ajustes globais para os objetos do jogo (gameObjects).

É nesta parte que inclui os ajustes geral para a física, como amortecimento (damping) ou massa do objeto. Aqui você pode definir se um objeto precisa ser calculado na cena com física, como um ator, ou se vai apenas fazer parte do cenário, formando o nível.

Ajuste para os objetos:

ActorAtivando “Actor” para um objeto permite a gameEngine a avaliar este objeto. O botão “Actor”

vai habilitar mais botões descritos mais abaixo. Um objeto sem “Actor” pode formar, fazer parte do cenário (como os suportes de um estágio) e são “vistos” por outros atores também.Ghost

Um objeto “Ghost” não possui colisões, mais ainda possui “chave” de sensor de colisão. Ideal para criar algum tipo de evento.

Dynamic

Esta opção ativada faz com que o objeto esteja sujeito as leis da física. Esta opção habilita novos botões que permite definir os atribulos do objeto mais detalhadamente.

Rigid BodyO “Rigid Body” (corpo rígido) habilita a física avançada da gameEngine. Com isto é possível

fazer esferas rolar automaticamente quando elas entram em contado com outros objetos e a fricção entre os materiais é diferente de zero. A dinâmica de corpo rígido deve ser aprimorada em versões futuras da gameEngine.

Do FhEste botão ativa o mecanismo “Fh”. Com esta opção você pode criar comportamente de vôo ou

nado para atores. Um ator “voando” ou “nadando”.

Rot FhCom esta opção ajustada o objeto irá rodar em torno do ponto z semelhante (da mesma

maneira) sobre o terreno quando usado o mecanismo Fh. (?)

MassA massa de um ator dinâmico como um “efeito” é a propriedade que permite especificar como

a força será aplicada sobre ele. Note que não adianta aumentar a massa de um objeto para ele cair mais rápido que outro. É a resistência do ar que produz diferentes velocidades de queda (sem ar, todos os objetos irão cair da mesma maneira!). Use o valor “Damp” para simular a resistência do ar.

SizeÉ o tamanho da esfera limite. A esfera limite determina a área na qual a colisão irá ocorrer. Em

versões futuras isto não será limitado a apenas esferas. Provavelmente isto já ocorre com a versão 2.41

DampAmortecimento geral para o movimento de um objeto. Use este valor para simular

amortecimentos em objetos que estão no ar (como em queda) ou na água. No espaço, para simular ar, é preciso colocar valores baixos para o amortecimento. Para simular água, use valores mais altos.

RotDampFaz o mesmo que “Damp” mas para rotação do objeto.

AnisotropicQuando atores movem-se sobre superfícies você pode definir o atrito entre os objetos. O atrito

irá tornar os objetos mais lentos, porque sempre haverá uma força contrária a existente sobre o objeto e que o impulsiona para frente devido ao contato com a superfície. Ele é controlado no ajuste de material dinâmico (dynamic material settings). Este atrito trabalha igualmente em todas as direções do movimento.

Com o “Anisotropic” ativado você pode controlar o atrito independentemente para cada eixo. Isto é muito usual em jogos de corrida, onde por exemplo o carro recebe diferentes atritos dependendo do tipo de curva ou situação em que apresenta.

Segue abaixo os ajustes que definirão as propriedade do objeto (gameObject). Estas propriedades podem conter valores que descrevem atributos do objeto como variáveis numa linguagem de programação. Use o botão ADD para adicionar propriedades.

A verdade é que o “RealtimeButtons” é o centro de comendo para adicionar a lógica para seus objetos e ambiente. A lógica consiste de sensores (Sensors), Controllers e Actuators.

“Sensors” são como sensores de uma forma de vida. Eles reagem a tecla pressionadas, colisões, contatos com materiais (touch), eventos com o tempo (timer events) ou valores de propriedades.

Os controladores estão coletando eventos dos sensores e são capazes de calcular então o resultado. Os controladores são o “cerebro” das operações. Controladores simplesmente fazem um “E” (AND). Um exemplo é o teste se uma tecla foi pressionada “E” (AND) um certo tempo passou. Há também o controlador “OR” e você pode usar script em python e expressões para criar comportamentos mais complexos.

Os atuadores produzem as ações nos objetos. Um atuador de movimento (Motion Actuator) é como um músculo. Um “músculo” pode aplicar força nos objetos para movê-los ou girá-los. Existem atuadores para executar animações pré-definidas (via IPOs), que podem ser comparadas como um reflexo.

A lógica é conectada por linhas usando o mouse, “Sensors” para “Controllers” e “Controllers” para “Actuators”. Feito tudo isso corretamente você será capaz de rodar o jogo imediatamente! Se descobrir algo no jogo que não está do seu agrado, basta parar a gameEngine, editar o ambiente 3D e reiniciar e assim por diante. Este caminho pode reduzir drasticamente o tempo de desenvolvimento além de ser mais confortável!!!

2.5 - Propriedades:Propriedades carregam informações limites para o objeto, similar a variáveis locais em

linguagens de programação. Nenhum outro objeto pode normalmente acessar estas propriedades, mas é possível copiar propriedades com “Property Copy Actuator”.

O botão “ADD property” adiciona uma nova propriedade. Por default, uma propriedade adicionada é do tipo “float”. Detele um a propriedade com o botão “Del”. O “MenuButton” difine o tipo de propriedade. Clique e com o botão esquerdo do mouse escolha no menu o tipo que deseja. O “Name:” o texto pode ser editado clicando com o botão esquerdo do mouse sobre ele. SHIFT-BACKSPACE apaga o nome.

Informação: O nome da propriedade é “case sensitive”, desta forma, “casa” é diferente de “Casa”.

O próximo campo é diferente para cada tipo de propriedade. Para o tipo booleano são dois botões a escolher: “True” e “False”. O tipo string aceita cadeia de caracteres. Entre com uma string clicando no campo com o botão esquerdo do mouse. Os outros tipos usam números para definir um certo valor. É possível editar com teclado ou arrastando o mouse.

Tipos:

Boolean (Bool)Esta propriedade armazena um valor binário, ele pode ser “True” ou “False”.

Integer (Int)Armazena números como 1, 2, 3, 4, ... na faixa de -2147483647 a 2147483647.

FloatArmazena um número de ponto flutuante.

StringArmazena uma cadeia de caracteres.

TimerEste tipo de propriedade faz um “update” (atualização) com o atual tempo do jogo em

segundos, iniciando do zero.

2.6 - Ajuste no MaterialButtons:Alguns atributos físicos podem ser definidos com o ajuste de material no Blender. O

“MaterialButtons” pode ser acessado via o ícone . Crie um novo material ou escolha um existente com o botão no menu. No “MaterialButtons” você precisa ativar o botão “DYN” para ver os ajustes dinâmicos (de dinâmica).

RestitutEste parâmetro controla a elasticidade das colisões. Um valor igual a 1.0 irá converter toda

energia cinética em energia elástica, ou seja, será restituído em força igual e oposta. Este objeto tem então uma elasticidade ideal. Um “Restitut” igual a um fará o objeto quicar indefinidamente sobre o terreno.

FrictionEste valor controla o atrito do objeto. Se o atrito é baixo, seu objeto vai deslizar como no gelo,

se é alto terá um efeito tipo “cimento”.

Fh ForceEm conjunção com “Do Fh” e/ou “Rot Fh” faz o objeto flutuar sobre uma superfície. “Fh

Force” controla a força que sustenta o objeto sobre o terreno (superfície).

Fh Dist“Fh Dist” controla o tamanho da área “Fh”. Quando o objeto entra nesta área o mecanismo

“Fh” começa a trabalhar.

Fh DampControla o “arrasto” dentro da área “Fh”. Valores acima de 0.0 vai causar um “arrasto” no

movimento do objeto dentro da área “Fh”.

Fh NormCom este botão ativado o objeto simplesmente sentirá uma força na direção da normal da face

do terreno. Isto irá causar um efeito no objeto que o fará descer uma rampa ou ladeira. (Veja FhDemo.blend)

2.6.1 - Ajuste de especularidade da gameEngine:

SpecAjusta o controle de intensidade de especularidade.

HardAjusta o controle do tamanho da especularidade.

Spec colorAtivando este botão, você habilita os ajustes RGB ou HSV para definir a cor da especularidade.

2.7 - Luzes na GameEngine:

Luzes podem ser criadas pressionando ESPAÇO -> ADD Lamp. Para uma lâmpada selecionada é possível abrir as suas propriedades. Estas propriedades são a cor, a energia, etc... A GameEngine é totalmente integrada no Blender, existem alguns botões que são somente usuais para animações lineares.

Um ajuste comum a todos os tipos de lampadas é a energia e a cor (ajustável com RGB).Para permitir uma face a receber luz em tempo real na GameEngine do Blender a face precisa

estar ajustada para “Light” no Paint/FaceButtons. Com a camada (Layer) ajustada para a luz e objetos é possível controlar a luz precisamente. Luzes somente afetam faces sobre a mesma camada. Por camada é possível usar 8 luzes (limitação do OpenGL) para luzes em tempo real.

Tipos de luzes da GameEngine:

Lamp“Lamp” é uma fonte de luz puntiforme.

SpotÉ uma lâmpada restrica a um espaço cônico. Na janela 3D é possível ver as linhas do cone. Use

“SpotSi” para ajustar o ângulo de “visão” da luz.

SunÉ um tipo de luz direcional. A distância não afeta sua intensidade. A luz direcional é exibida

com uma linha que mostra a sua direção.

HemiA luz “Hemi” não é suportada pela game engine. (Este manual é antigo, de 2001!

Provavelmente a nova versão da engine 2.41 de 2006 já deve dar suporte a este tipo de luz. É bom conferir).

As luzes “Lamp” e “Spot” são sensíveis com a distância. Use “Dist:”, “Quad1:” e “Quad2:” para ajustar isto.

2.8 - O Blender e as Leis da Física:Todos os objetos no Blender com a opção “Dynamic” são avaliados com as Leis da Física e

definidos pela engine para usá-las.As propriedade chave para um objeto dinâmico é a sua massa. Gravidade, força e impulsos

(limite de colisão) somente trabalham com objetos que possuem massa. Desta forma, somente objetos dinâmicos podem experimentar algum tipo de arrasto, ou velocidade de amortecimento (como o que ocorre com o ar ou resistência da água).Observação: Note que objetos dinâmicos usando “dLoc” e “dRot” não apresenta resultados desejados. Uma vez que um objeto dinâmico é controlado por forças e impulsos, qualquer mudança explícida de posição ou orientação de um objeto pode não corresponder com a velocidade. Para objetos dinâmicos é melhor utilizar “linV” e “angV” para explicitar definições de movimento.

Como definimos uma massa para seu objeto dinâmico ele será afetado pela gravidade, causando sua queda no ambiente até encontrar outro objeto com limite para colisão já que o objeto dinâmico possui um limite esférico para colisão. O tamanho da esfera-limite pode ser modificado no parâmetro “Size:”. O valor da gravidade por default está ajustado para 9.81. Você pode modificá-la no “WorldButtons” com o deslizante “Grav”. Uma gravidade zero é muito útil para jogos espaciais ou simulações!

Informação: Use os ajustes “Damp:” e “RotDamp:” para a resistência do ar ou simular outros ambientes. Não use estes ajustes para simular atrito! O Atrito (Friction) pode ser simulado usando os ajustes de material dinâmico (dynamic material).

Objetos dinâmicos possuem limite por duas razões. Ambos tem “Do Fh” habilitado e tem pequeno arrasto (damping), ou você está usando um valor “Restitut” no material dinâmico (dynamic material) que é bem alto.

Se você não definir um material, por default a restituição será 1.0. Este é o valor máximo para a restituição e ele irá produzir um efeito bastante interessante pois o objeto ficará quicando indefinidamente no piso (elasticidade perfeita!)

No primeiro caso, incrementando um “arrasto” (damping) pode-se reduzir os quiques! No último caso define-se um material para o objeto e ajusta-se o seu valor de restituição para um número menor que 1.0. O valor de restituição determina a elasticidade do material. Um valor igual a zero determina que a velocidade de afastamento depois da colisão será nulo, ou seja, será um choque inelástico. Um valor igual a 1.0 faz com que o momento seja conservado mesmo depois da colisão.

O Damping (arrasto) irá decrementar a velocidade em % por segundo. Damping é usual para estabelecer uma velocidade máxima. Um valor alto diminui a velocidade do objeto drasticamente. A velocidade máxima é alcançada quando a força que tende a acelerar o objeto é igual a sua desaceleração provocada pela força de arrasto. Damping é usual para produzir também oscilações amortecidas.

Friction (atrito) é uma força tangente ao contato entre as superfícies dos objetos. A força de atrito possui um valor máximo que é proporcional a normal, isto é, a força que pressiona os objetos uns contra os outros. Esta proporcionalidade é denota o coeficiente de atrito. Um valor alto para a força de atrito irá permitir um valor alto para o atrito máximo. A “regra” para o movimento obedece as leis da resultante de forças, ou seja, se a força aplicada for menor que o atrito máximo, o objeto não se move. Se for igual, ele fica na eminência do movimento, se for maior o objeto se move. Se no movimento a força for igual a força de atrito cinético, o objeto se move com velocidade constante.

Para alguns objetos é necessário ter diferentes atritos em direções diferentes. Por exemplo, um skate possui pouco atrito quando se move para frente ou para trás, mas um atrito relativamente alto quando se move para os lados. Isto é chamado “anisotropic friction” (atrito anisotrópico). Selecionando o botão “Anisotropic” no “RealTimeButtons” irá habilitar o atrito anisotrópico. Depois de selecionar este botão, três barras deslizantes vão aparecer com o coeficiente relativo para cada eixo local a ser ajustado. Um coeficiente de atrito ao longo de um eixo igual a zero significa que ao longo desse eixo o atrito é zero. Um coeficiente de atrito igual a 1 significa que o atrito máximo é aplicado no dado eixo.

2.9 - EXPRESSÕES:

Expressões válidas

Expression type ExampleInteger numbers 15Float number 12.23224Booleans TRUE, FALSEStrings "Eu sou uma string!"Properties propnameSensornames sensorname (um nome no LogicBrick)

Expressões aritméticas

Expression ExampleEXPR1 + EXPR2 Addition, 12+3, propname+21EXPR1 - EXPR2 Subtraction, 12-3, propname-21EXPR1 * EXPR2 Multiplication, 12*3, propname*21EXPR1 / EXPR2 Division, 12/3, propname/21EXPR1 > EXPR2 EXPR1 greater EXPR2EXPR1 >= EXPR2 EXPR1 greater or equal EXPR2EXPR1 < EXPR2 EXPR1 less EXPR2

Operações booleanas

Operation ExampleNOT EXPR Not EXPREXPR1 OR EXPR2 logical OREXPR1 AND EXPR2 logical ANDEXPR1 == EXPR2 EXPR1 equals EXPR2

Declarações condicional: IF( Test, ValueTrue, ValueFalse )

Exemplos de expressões:

Expressão Resultado Explicação12+12 24 Adiçãoproperty=="Carsten" TRUE or

FALSEString comparação entre uma propriedade e uma string

"Erwin">"Carsten" TRUE Comparação entre Strings

2.10 - Botões de som:Os “SoundButtons” ( ) são usandos para carregar e gerenciar sons na gameEngine.

No “SoundButton” é possível chamar sons como é visto no screenshot acima (o som, no caso, tem nome: MiniGunFire.wav). Este nome é ajustado para o nome do som sample por default. Com o

“MenuButtons” você pode abrir um som existente e criar um novo “SoundObjects”. A cor azul indica que mais de um usuário está utilizando o som, o número indica o número de usuários.

O “NumberButton” indica quantos “SoundObjets” partilham o exemplo. Quando o botão “pack/unpack” é pressionado, o “sample” é empacotado dentro do arquivo *.blend. Isto é muito importante quando for distribuir arquivos, já que não é necessário ter os arquivos de sons em separado. Tudo fica embutido dentro do próprio arquivo do blender.

O botão “Play” obviamente toca o som e o botão “Loop” ajusta se o som irá tocar uma única vez ou se vai executar repetidamente. Dependendo do “play-mode” no “Sound Actuator” este ajuste pode estar “não disponível”.

A barra de ferramenta “Vol:” ajusta o volume global do som.

Pitch: com o “pitch” você pode mudar a frequência do som. Atualmente ele suporta valores entre -12 semitons a +12 semitons. Em Hertz: se seu “sample” possui frequência de 1000Hz, o “baixo” possui 500Hz e o “alto” 2000Hz.

A próxima linha de botões vai definir o som 3D. Com o botão “3D vol” ativado (se desativar “Fixed”) você habilida o som 3D. Esta medida de volume do som depende da distância entre a fonte sonora e o observador. O observador é a câmera ativa!!!

O botão deslizange “Attn:” ajusta a atenuação do som. No mundo 3D você pode escalar a relação entre avanço e distância. Por exemplo, se um som passar pela câmera você deseja ajustar o fator que determina como o som vai se comportar quando passa por você (observador – câmera).

A próxima linha de botões define a posição estéreo do som. Com “3D pan” ativado o volume do canal direito e esquerdo do som vai depender da posição relativa do ouvinte. Quando “Fixed” está ativado você pode manualmente ajustar o som com o botão deslizante “Pann:”

2.11 - Janela de som:

A janela de som é usada para visualizarmos o som, ou seja, sua forma de onda. A barra verde indica a posição do som que está sendo executada. Isto pode ser usado para sincronizar o som com uma animação IPO. A parte inferior da janela mostra a duração do som em segundos.

2.12 - Performance e design visando a otimização para o melhor resultado:Os computadores tem se tornado cada vez mais velozes. Mas ainda sim algumas performances

devem ser buscadas na hora de se criar o design do game para que o framerate mantenha constante e o jogo não fique lento e desagradável ao jogar. Isto não é somente um bom estilo em design e programação mas simplesmente essencial para a plataforma que o programa irá rodar e que o Blender é capaz de fornecer. Assim, ao criar um jogo, tendo em vista as diversas plataformas, tenha em mente algumas regras importantes de otimização:

1] Originalmente para um “AddObject Actuator” precisa estar em uma camada invisível (muito importante, talvez você vai usar isto regularmente no futuro).

2] Não utilize propriedades em combinação com controladores AND/OR/Expr com a linguagem de script. Existe um controlador python.

3] não “divida” (reparta) variáveis (pyhon) entre scrips.

4] Use poucas interligações entre conecções “LogicBrick”, se possível.

5] Use ALT-D (instância de malha para novos objetos) quando for fazer uma réplica, isto é melhor do que SHIFT-D (copia da malha).

6] polígonos com mapeamento “alpha” são expansivos, assim use com moderação.

7] A “bandeira” (flag) para colisão estando desligada melhora bastante a performance. O uso de “ghost” é econômico quando comparado com um objeto “físico” regular.

8] Use o menor número de polígonos possível. É muito fácil adicionar polígonos a um modelo, no entanto, remover polígonos sem distorcer o modelo é difícil. Procure enriquecer os detalhes cobrindo a malha com uma boa textura.

9] Mantenha a resolução das texturas o mais baixo possível. Você pode trabalhar com versões em alta-resolução e então reduzi-las quando for publicar o jogo (veja UV Texturing).

10] Polígonos ajustados para “Light” são expansivos. Um acelerador de hardware irá trabalhar bastante com calculos de transformações e luzes. Use somente se for necessário e verifique sempre a performance.

11] No lugar de luz em tempo real use “VertexPaint” para iluminar, escurecer ou pintar faces como sugestão de situações de luzes. Bastante útil e criativo!

3 - GAME LogikBricks:

A lógica do jogo no GameBlender está situada no “RealtimeButtons”. Aqui é possível ligar diferentes “LogicBricks” (bloco lógicos) juntos. A seguir serão descritos todos os blocos lógicos usados pela engine.

3.1 - SENSORS:Sensors atuam como sensores realmente. Eles pode detectar colisões, tato (toque), olfato (perto,

proximidade), visão (raio, radar).

Tipos de sensores (Sensors):

3.1.1 - AlwaysEste é o sensor mais básico da engine. Ele executa uma tarefa continuamente. Por exemplo, uma peça que fica girando no cenário pode ser criada usando este recurso (como as moedas que giram e devem ser coletadas)

O botão [x] deleta o sensor da lógica do jogo (gameLogic). Isto acontece sem confirmação, portanto, tome cuidado! O botão a direita do botão de deletar permite a escolha do tipo de sensor (no screenshot acima o sensor é “Always”). Clique sobre ele e irá aparecer uma lista de sensores. O próximo botão é o botão do nome do sensor. O Blender assume um nome automaticamente no momento da criação do sensor, mas você pode renomeá-lo a vontade.

Informação: Nomeie seus “LogicBlicks” e os objetos no Blender para facilitar a manutenção de suas cenas. Um esquema gráfico pode se tornar complexo demais.

Com a pequena seta laranja é possível “minimizar” a janela do bloco lógico. É muito útil quando o esquema lógico se torna mais complexo.

A próxima linha de botões é usada para determinar com que frequência o sensor está “atirando”. Este é um tópico mais complexo, daremos exemplos mais adiante nesta documentação.Informações gerais sobre pulsos:

Pulsos são formas de sensor chave em ambos “Controllers” e “Actuators”. Um pulso pode ter dois valores, TRUE e FALSE.

Cada controlador é sempre avalisado quando ele recebe um pulso, se o pulso for TRUE ou FALSE isto não vem ao caso. A entrada “gate” de um controlador lembra o valor do último pulso. Isto é necessário para que os controladores iniciem a ligação de múltiplos sensores, então ele pode ainda fazer uma operação lógica AND ou OR sobre todas as entradas. Quando um controlador está chaveado, e depois da avaliação de todas as entradas, ele pode decidir entre executar um script interno ou enviar um pulso para os atuadores.

Um atuador reage a um pulso de maneira diferente, com pulso TRUE ele é chaveado em ON (torna-se ativo), com FALSE ele é chaveado em OFF.

botão de modo de pulso.

O primeiro botão ativa o modo de pulso positivo. A todo momento o sentor “atira” um pulso e ele é um pulso positivo. Isto pode ser usual, por exemplo, mas iniciar um movimento com um “Motion Actuator”. O próximo botão ativa o modo de pulso negativo, isto pode ser usado para parar o movimento.

Informação: se nenhum modo de pulso estiver ativado o sensor “Always” irá “atirar” somente uma vez. Isto é muito usual para iniciar alguma coisa (movimento, material, etc) no início do jogo.

O botão de nome “f:” (no caso do screenshot acima, está ajustado para 41), determina o delay (retardo) entre dois pulsos pelo sensor. O valor de “f:” é dada em frames.

O botão “Inv” inverte o pulso, se é positivo (TRUE) vai se tornar negativo (FALSE) e vice-versa. Veja o exemplo “pulses.blend”.

3.1.2 - Keyboard:O sensor “Keyboard” é, talvez, um dos sensores mais usados porque ele provê uma interface entre o Blender e o usuário (mais adiante falaremos da entrada através do mouse).

Os botões de modo de pulso são comuns para todos os sensores e possuem a mesma funcionalidade descrita no sensor “Always”.

Ativando o botão “All keys” o sensor vai reagir com qualquer tecla. No campo “Hold” você pode por chaves de modificação.

Metodos python:

setKey(int key);Ajusta a tecla que o sensor vai reagir.

Int key getkey();Captura a tecla que o sensor reagiu.

setHold1(int key);Ajusta o modificador chave um.

Int key getHold1();Captura o modificador key one.

setHold2 (int key);Ajusta o modificador tecla dois.

setUseAllKeys(bool all);Ajusta a opção “All keys” para todas=TRUE

Bool all getUseAllKeys();Captura o estado da opção “All Keys”

List keys getPressedkeys();Captura uma lista das teclas pressionadas;

List events getkeyEvents();Captura uma lista dos eventos das teclas.

3.1.3 - Mouse:O sensor mouse inclui os botões usuais presentes nos mouses. O propósito principal desse sensor é obviamente criar uma interface entre o usuário e o aplicativo através do mouse. Atualmente o sensor é capaz de “vigiar” os cliques ou movimento do mouse. Para capiturar a posição atual do ponteiro do mouse será preciso usar um scripth Python. Isto será tratado mais adiante neste documento.

Metodos python:

Int xposgetXPosition();Captura a posição x do mouse.

Int yposgetYPosition();Captura a posição y do mouse.

3.1.4 - Touch:O sensor “Touch” “atira” um pulso quando o objeto está designado para tocar um material. Se você entrar com um nome no campo “MA:” então ele somente reage para o material correspondente ao nome caso contrário irá reagir a todos os materiais. Isto é muito útil para ativar efeitos para materiais específicos. Por exemplo, o personagem deve morrer ou ter o “life” abaixado de um dado valor se tocar no material lava.

Metodos python:

setTouchMaterial( (char* matname));Ajusta o material na qual o sensor “Touch” vai reagir.

Char* matname getTouchMaterial();Captura o material que o sensor ‘Toch’ reagiu.

gameObject obj getHitObject();Retorna o objeto que foi tocado.

List objs getHitObjectList();Retorna uma lista dos objetos que foram tocados.

Veja o exemplo ‘touch.blend’.

3.1.5 - Collision:O sensor “Collision” é um sensor geral usado para detector o contato entre dois objetos. Além disso reage sobre materiais e é simplesmente capaz de detectar propriedades de um objeto. Entretando você pode escolher (comutar) o campo de entrada do material para propriedade clicando sobre o botão “M/P”.

Metodos python:

setTouchMaterial( (char* matname) );Ajusta o material de colisão na qual o sensor irá reagir.

Char* matname getTouchMaterial();Captura o material de colisão que o sensor reagiu.

setProperty( (char* propname) );Ajusta as propriedades do sensor colisão.

Char* propname getProperty();Captura a propriedade de colisão da reação do sensor.

gameObject obj getHitObject();Retorna o objeto que está colidindo.

List objs getHitObjectList();Retorna a lista de objetos que colidiram.

Veja o exemplo ‘collision.blend’.

3.1.6 - Near:O sensor “near” reage a aproximação dos atores ao objeto com o sensor.

Informação: O sensor de proximidade (near) somente “sente” objetos do tipo “Actor” (um objeto dinâmico é um “actor”).

Se o campo “Property:” estiver vazio, o sensor de proximidade irá reagir a todos os atores na faixa. Se o campo tiver um nome para a propriedade, o sensor irá reagir somente sobre atores que possuem a propriedade do nome.

A faixa (esférica) do sensor de proximidade é ajustada com o botão “Dist”. O valor “Reset” define que o valor da distância do sensor de proximidade é resetado novamente. Isto é muito útil para impedir multiplos pulsos quando um ator está justamente na distância “Dist”, ou para abrir uma porta a uma certa distância mas fechar em outra distância diferente. Veja o esquema de pulsos do sensor:

Métodos python:

setProperty( (char* propname) );Ajusta a propriedade do sensor de proximidade para reagir.

Char* propname getProperty();Captura a propriedade que o sensor de proximidade reagiu.

Exemplos de use de sensor de proximidade podem ser aplicados a inimigos quando o jogador se aproxima, uma porta abrir, etc...

3.1.7 - Radar:O sensor “Radar” funciona como um radar real. Ele observa um objeto em terno dos eixos indicados com os botões “X, Y, Z”. Se uma propriedade for digitada no campo “Prop:”, ele somente reage a objetos que possuem esta propriedade.

No campo “Ang:” você pode entrar com o ângulo de abertura do radar. Este ângulo é equivalente ao ângulo de visão de uma câmera. O ajuste “Dist:” determina a distância em que o sensor radar é capar de “ver”.

Objetos não bloqueiam a linha do sinal do sensor radar. Isto é diferente do sensor “Ray” (veja mais adiante). Você pode combinar ambos para fazer um radar que não é capaz de “ver” atraves de objetos, um muro, por exemplo.

3.1.8 - Property:O sensor “Property” logicamente verifica uma propriedade “ligada” (atada) a um mesmo objeto.

O sensor ‘property’ do tipo “Equal” verifica a igualdade da propriedade dada no campo “Prop:” e o valor dado no campo “Value:”. Se a condição for verdadeira, ele “atira” um pulso de acordo com o ajuste do modo de pulsos.

O “Not Equal” verifica a “inegualdade” e então atira os pulsos.

A propriedade tipo “Interval” atira seus pulsus se o valor da propriedade estiver dentro do intervalo definido por “Min:” e “Max:”. Este tipo de sensor é especialmente usual para verificar valores flutuantes (que mudam). Isto é mais comum com a propriedade “Timer”.

A propriedade “Changed” emite pulsos toda vez que a propriedade é chamada. Isto, por exemplo, acontece, apesar de que, uma propriedade “Actuator”, um script python ou uma expressão (? – a traduzão está confusa aqui)

Metodos python:

SetProperty( (char* propname) );Ajusta a propriedade para verificar.

Char* propname getProperty();Captura a propriedade para verificar.

setType( (int type) );Ajustes do tipo do sensor propriedade.1] Equal2] Not Equal3] Interval4] Changed

SetValue( ( char* expression) );Ajusta o valor para verificar (uma expressão).

Char* expression getValue();Captura o valor para verificar (uma expressão).

Veja o exemplo ‘property.blend’.

3.1.9 - Random:O sensor Random atira um pulso randomicamente de acordo com o ajuste de pulsos (50/50 pick).

Informação: Com o “seed” igual a 0 (zero) o sensor Random trabalha exatamente como o sensor “Always”. Escolha 0 (zero) para não randômico!

Metodo python:

SetSeed( (int seed) );Ajusta o “seed” para a geração randômica.

Int seed getSeed();Captura o “seed” para o sensor “Random”.

Int seed getLastDraw();Captura o ultimo “draw” (desenho, configuração) do sensor “Random”.

Veja o exemplo random.blend!

3.1.10 - Ray:O sensor “Ray” lança um raio para a uma dada distância determinada pelo botão “Range”. Se o raio tocar um objeto com a propriedade correta ou o material ajustado o sensor atira um pulso.

Informação: Outro objeto bloqueia o raio, assim não é possível ver através de paredes!

Sem um nome para o material ou propriedade, o sensor reage a todos os objetos.

Métodos python:

List [x,y,z] getHitPosition();Retorna a posição onde o raio tocou o objeto.

List [x,y,z] getHitNormal();Retorna o vetor normal de como o raio interceptou o objeto.

List [x,y,z] getRayDirection();Retorna o vetor da direção do raio.

gameObject obj getHitObject();Retorna o objeto da interceptado.

Veja o exemplo “ray.blend”!

3.2 - CONTROLADORES:Controladores agem como o “cérebro” da lógica do seu jogo. Este reage a decisões simples

como conexões de entradas, reage a expressões complexas ou a scripts python que permite a criação de eventos mais complexos como a inteligência artificial.

Tipos de controladores:

3.2.1 - AND:

O controlador AND combina uma, duas ou mais entradas de sensores. Todas as entradas precisam estar ativas (serem válidas, verdadeiras) para poder passar pelo controlador.

Veja o exemplo ‘and.blend’.

3.2.2 - OR:

O controlador OR combina uma, duas ou mais entradas de sensores. O controlador deixa o pulso passar se uma ou mais entradas forem válidas (ativas).

Veja o exemplo “or.blend”.

3.2.3 - Expression:Com o controlador expressão (Expression Controller) você pode criar lógicas um pouco mais complexas para o jogo com uma linha simples de “código”. É possível acessar a saída dos sensores ligados para o controlador e acessar as propriedades dos objetos.

Informação: O mecanismo de expressão imprime saídas de erros na janela do console DOS caso alguma falhe.

Veja o exemplo ‘expression.blend’.

3.2.4 - Python:

O controlador Python é o controlador mais poderoso da gameEngine. É possível ligar um script Python a ele, que permite a você criar controlar seus objetos do jogo (gameObjects) desde um simples movimento de corrida até complexos movimentos programados para simular inteligência artificial.

Digite o nome do script que você deseja ligar ao controlador python no campo “Script:”. O script precisa existir na cena, caso contrário, o Blender vai ignorar o nome que digitou.

Observação: Nomes no Blender são “case sensitive”! Assim, um script “player” é diferente de “Player”!

Métodos python:

Actuator* getActuator( char* name , );Retorna o atuados com “name”.

List getActuators();Retorna uma lista python de todos os atores conectados.

Sensor* getSensor( char* name , );Retorna o sensor com “name”.

List getSensors();Retorna uma lista python de todos os sensores conectados.

3.3 - ATUADORES:Atuadores são blocos lógicos de execução. Eles podem ser comparados com “músculos” que dão vida aos objetos.

Tipos de atuadores:

3.3.1 - Motion:

O atuador de movimento é sem dúvida o atuador mais importante. Ele move, produz rotação ou aplica velocidade em objetos.

Um caso simples de uso do atuador de movimento é, obviamente, para mover objetos. Isto é feito com o valor “dLoc” na terceira linha. Toda vez que o atuador é ativado por um impulso ele move o objeto uma dada quantidade colocada em “dLoc”. Existem três valores correspondendo aos eixos X, Y e Z. Assim quando você entra com um valor 1.0 no primeiro campo o objeto será movido de uma unidade por vez no game (o relógio na gameEngine produzem “ticks” de 1/25 segundos).

O botão chamado “L” entre cada linha do atuador de movimento determina se o movimento aplicado precisa ser tratado como global ou local. Se o botão estiver pressionado (verde escuro) o movimento é aplicado baseando-se nos eixos locais do objeto. Se o botão não estiver pressionado o movimento é aplicado baseado na orientação global (do mundo).

Force:Os valores desta linha aplica forças no objeto. Isto trabalha somente com objetos dinâmicos.

Torque:Os valores desta linha agem com forças que produzem movimento de rotação (torque). Trabalha somente com objetos dinâmicos. Valores positivos gira o objeto no sentido horário.

dLocMove o objeto como já foi explicado anteriormente.

dRotGira o objeto de um dado ângulo (36 é rotação total, completa)

linVAjusta a velocidade do objeto para um dado valor.

angVAjusta a velocidade angular de um dado valor. Valores positivos giram no sentido horário.

O atuador de movimento inicia o movimento do objeto quando recebe um pulso (TRUE) e para quando recebe um pulso (FALSE). Para “pegar” um movimento numa certa distância, é preciso enviar um pulso FALSE para o atuador sempre.

Metodos python:

setForce ( list [x,y,z] , bool local );Ajusta o parâmetro “Force” (força) para o atuador de movimento.

List [x,y,z] getForce( );Captura o parâmetro “Force”do atuador de movimento.

setTorque( list [x,y,z] );Ajusta o parâmetro “Torque” do atuador de movimento.

List [x,y,z] getTorque( );Captura o parâmetro “Torque” do atuador de movimento.

setdLoc( list [x,y,z] );Ajusta o parâmetro dLoc do atuador de movimento.

List [x,y,z] getdLoc( );Captura o parâmetro dLoc do atuador de movimento.

setdRot( list [x,y,z] );Ajusta o parâmetro dRot do atuador de movimento.List [x,y,z] getdLoc( );Captura o parâmetro dRot do atuador de movimento.

setLinearVelocity( list [x,y,z] );Ajusta o parâmetro linV do atuador de movimento.

List [x,y,z] getLinearVelocity( );Captura o parâmetro linV do atuador de movimento.

setAngularVelocity( list [x,y,z] );Ajusta o parâmetro angV do atuador de movimento.

List [x,y,z] getAngularVelocity( );Captura o parâmetro angV do atuador de movimento.

3.3.2 - Constrait:Com o atuador Constraint é possível limitar a liberdade de um objeto de um certo grau.

Com o “MenuButton” você especifica o canal de que liberdade deseja limitar, por exemplo, eixo X, Y ou Z (no screenshot acima, está travado o eixo Y). Com o “NumberButtons” “Min” e “Max”

é definido os valores mínimos e máximos para o valor dos limites do movimento. Para limitar um objeto em mais de um canal simplesmente use mais de um atuador Constraint.

Metodos python:

setDamp (int damp);

int damp getDamp( );

setMin (int min);

int min getMin( );

setMax( int max);

int max getMax ( );

setMin (int min);

int min getMin( );

setLimit (? Limit );

int limit getLimit( );

3.3.3 - IPO:

O atuador IPO executa uma animação de “IPO-curves” para um objeto. Se o objeto possui um filho (child) com um IPO e você ativar o “Child” no atuador, o IPO vai executar a animação do Child.

Modos IPO suportados pela engine:

PlayExecuta o IPO do frame inicial determinado por “Sta” até o frame final determinado por “End” toda vez que um pulso positivo atinge o atuador. Qualquer outro pulso enviado durante a execução será desconsiderado.

Ping PongExecuta o IPO do frame inicial “Sta” para o frame final “End” ao primeiro pulso positivo que atinge o atuador. O proximo pulso recebido irá executar o IPO de “End” até “Sta”.

FlipperExecuta o IPO enquanto o pulso for positivo. Quando o pulso for negativo (nenhum é enviado) o IPO é executado do frame corrente até o frame “Sta”.

Loop StopExecuta o IPO em loop a enquando o pulso for positivo. Ele para na posição corrente se o pulso for negative (cessar).

Loop EndExecuta o IPO repetidamente enquanto existir um pulso positivo. Quando o pulso para ele continua a executar o IPO até atingir o final do loop e então para a execução.

PropertyExecuta o IPO para o frame indicado na propriedade digitada no campo “Prop:”

Atualmente os seguintes IPOs são suportados pela gameEngine:

Mesh ObjectsLoc, Rot, Size e Col

LampsLoc, Rot, RGB, Energy

CamerasLoc, Rot, Lens, ClipSta, ClipEnd

Metodos python:

setType (??? , );

int type GetType ( ??? , );

SetStart ( int frame , );

SetEnd ( int frame , );

Int frameGetStart ( );

Int frameGetEnd ( );

3.3.4 - Camera:

O atuador Camera tenta similar um cameraman. Ele focaliza um ator no campo de visão e tenta permanecer a uma certa distância do mesmo. Os movimentos são suaves e há alguns “retardos” na reação do movimento em relação ao objeto.

Você seleciona o objeto que deseja que a câmera vai acompanhar no campo “OB:”, digitando o nome do objeto. O campo “Height:” determina a altura que a câmera irá permanecer sobre o objeto.

“Min:” e “Max:” corresponde a menor e maior distância da câmera ao objeto. Os botões “X” e “Y” especificam os eixos que a câmera vai permanecer na visualização do objeto.

Dê uma olhada no exemplo “camera.blend”.

3.3.5 - Sound:

O atuador “Sound” executa um “SoundObject” que foi previamente carregado com os “SoundButtons” (isto já foi explicado mais acima).

Modos de execução do som:

Play StopExecuta o som enquanto ouver um pulso positivo.

Play EndExecuta um som até o final quando um pulso positive é recebido.Loop StopExecuta e repete o som quando um pulso positivo é fornecido.

Loop EndToca o som repetidamente, quando um pulso positivo é fornecido. Quando o pulso para o som é executado até o final.

Veja o exemplo “sound property.blend”.

3.3.6 - Property:

Modos de propriedades:

AssignAssume um valor ou expressão (dado no campo “Value”) para uma propriedade. Por exemplo, uma expressão como “Proppy + 1” o “Assign” trabalha como um “Add” (adicionador). Para strings é preciso usar quotas para adicionas as strings (“...”).

AddAdicione o valor ou resultado de uma expresão para uma propriedade. Para subtrair simplesmente dê um valor negativo para o número no campo “Value:”.

Copy

Isto copia uma propriedade (neste screen “Prop: Sprop”) do objeto com o nome dado em “OB: Sphere” dentro da propriedade “Prop: Proppy”. Isto é uma maneira fácil de trocar informações entre objetos.

Metodos python:

SetProperty ( char* name);

*char name GetProperty ( );

SetValue (char* value);

Char* value GetValue( );

3.3.7 - Edit Object:Este atuador permite a ação sobre objetos, como adicionar novos objetos, deletar objetos, etc...

Tipos de Edit Object:

Add Object:

O atuador “Add Object” adiciona um objeto na cena. O novo objeto vai estar orientado ao longo do eixo X do objeto criado.

Informação: Mantenha o objeto a ser adicionado sobre uma camada separada e invisível ou ele não vai trabalhar como esperado.

Entre com o nome do objeto a ser adicionado no campo “OB:”. O campo “Time:” determina quando tempo (em frames) o objeto deve existir. O valor “0” denota que ele vai existir para sempre na cena. Tome muito cuidado para não tornar a engine muito lenta pela adição de muitos objetos na cena. É possível usar outros eventos para adicionar ou eliminar objetos na cena (colisões, properties, etc) usando o “LogicBricks”.

Com os botões “linV” é possível dar uma velocidade inicial ao objeto no momento que ele é criado. Esta velocidade é dada em relação as componentes X, Y e Z. O botão “L” considera a orientação local. Quando ele estiver pressionado a velocidade é interpretada sobre o eixo local do objeto adicionado.

Metodos python:

setObject ( char* name);Ajusta o objeto a ser adicionado.

Char* name getObject( char* name);Captura o nome do objeto.

setTime (int time);Tempo em frames em que o objeto vai existir depois de adicionado a cena. Um valor zero o objeto estará na cena eternamente, a não ser que seja eliminado por outra propriedade.

Int time getTime ( );Captura o tempo de vida do objeto adicionado.

setLinearVelocity ( list {vx, vy, vz} );Ajusta a velocidade linear do objeto (em unidades da gameEngine) adicionado.

List [vx, vy, vz] getLinearVelocity ( );Ajusta a velocidade linear do objeto (em unidades da gameEngine) do atuador.

gameObject* getLastCreateObject ( );Captura o ponteiro do ultimo objeto criado. Isto permite a manipulação dinâmica do objeto adicionado.

End Object:

O tipo “End Object” simplesmente finaliza a vida do objeto na cena quando o atuador recebe um pulso. Isto é muito usual para finalizar a existência de balas depois de colisões ou algo similar. Quando o personagem pega uma peça e esta deixa de existir na cena, etc...

Replace Mesh:

O tipo “Replace Mesh” substitui a malha de um objeto por uma nova dada pelo campo “ME:”. Lembre-se que o nome da malha não é implicitamente igual ao nome do objeto.

Metodos python:

setMesh( char* name);ajusta a malha para ser substituida pelo atuador para “name”.

Char* name getMesh( );Captura o nome da malha do atuador “ReplaceMesh”.

Track to:

O tipo “Track to” gira o objeto apontando-o sempre para um objeto alvo especificado no campo “OB:”. Normalmente isto acontece somente no plano x/y do objeto, caso o botão “3D” não esteja pressionado). Com “3D” pressionado o objeto irá orientar-se em três graus de liberdade. O parâmetro “Time:” ajusta a rapidez com que o objeto é capaz de acompanhar o alvo. Um valor zero faz com que o objeto acompanhe o alvo imediatamente, valores acima de zero produz um retardo dando um efeito mais suave.

Metodos python:

setObject (char* name);

char* name getObject( );

setTime( int time);

int time getTime( );

setUse3D( );

bool 3d setUse3D( );

3.3.8 - Scene:O atuador “Scene” (Cena) é utilizado para “ligar” cenas e câmeras na gameEngine.

Escolha a ação com o “MenuButton” e entre com uma câmera existente ou o nome de “cena” no campo de texto. Se o nome não existe, o botão ficará escuro.

Reset:

Simplesmente reinicia e “reseta” a cena. É o mesmo efeito de para o game com ESC e reiniciar com P.

Set Scene:

Vai para a cena indicada no campo texto. Durante o “swith” todas as propriedades são resetadas.

Metodos python:

setScene( char* scene);Ajusta a cena que deseja exibir.

Char* scene getScene( );Captura o nome da cena do atuador.

Set Camera:

Muda para a camera indicada no campo texto.

Metodos python:

setCamera( char* camera );Ajusta para a câmera que deseja mudar.

Char* camera getCamera( );Captura o nome da câmera do atuador.

Veja o exemplo “SetCamera.blend”.

3.3.9 - Random:Uma função indispensável para jogos são as que geram números randômicos de modo a gerar variações em movimentos ou comportamentos de inimigos.

O parâmetro “Seed” é um valor que alimenta o gerador randômico com um valor inicial para a geração de números. O computador gera números “pseudo-randômicos” que irão se repetir a cada execução. Você irá pegar a mesma sequência de números se escolher o mesmo valor de “Seed”. Obviamente valores diferentes irão gerar uma sequência randômica diferente.

Preencha o nome da propriedade que deseja ser colocada como números randômicos no campo “Property:”.

Tipos de atuadores randômicos:

Boolean Constant:

Este não é uma função totalmente randômica, use este tipo para testar a lógica do jogo com valores TRUE ou FALSE.

Boolean Uniform:

Este é o típico randômico classico dos 50-50 por cento, ou meio-a-meio. As chances dos resultados TRUE e FALSE são iguais. Isto é equivalente a jogar uma moeda.

Boolean Bernoulli:

Esta função randômica resulta num valor booleano de TRUE ou FALSE. No entanto, é possível controlar as chances de haver entre um TRUE e FALSE com o parâmetro “Chance”. Uma chance de 0.5 vai trabalhar da mesma forma que o “Bool Uniform”. Uma chance de 0.1 vai resultar em 1 em cada 10 casos de sair TRUE.

Integer Constant:

Para testar a lógica com um valor dado no campo “Value:”.

Integer Uniform:

Este tipo de propriedade randômica produz um valor inteiro entre (e incluindo) um dado “Min:” e “Max:”. No exemplo ilustrado no screenshot acima o atuador vai escolher um valor entre o mínimo (no caso 1) e máximo (no caso 6).

Integer Poisson:

Os números randômicos são distribuídos “a partir de uma média” dado por “Mean:” (?)

Float Constant:

Para depurar a lógico do jogo com um dado valor.

Float Uniform:

Vai gerar um número de ponto flutuante entre um valor “Min:” e “Max:”.

Float Normal:

Retorna um número randômico em torno do número dado em “Mean:” e com um desvio padrão dado por “SD:”.

Float Negative Exponential:

Retorna um número randômico que é descrito por algum processo natural como o decaimento radioativo ou vidas de bactérias. O ajuste “Half-life time:” ajusta a média desta distribuição.

Metodos python:

setSeed (int seed);Ajusta o seed (o valor inicial do gerador dos números randômicos)

Int seed getSeed( );Captura o seed do atuador.

Float para1 getPara1( );Captura o primeiro parâmetro da distribuição randômica selecionada.

Float para2 getPara2( );Captura o segundo parâmetro da distribuição randômica selecionada.

setProperty( char* propname );???Char* propname getProperty( );Captura o nome da propriedade do atuador.

setDistribution ( int dist );??

Int dist getDistribution ( );Captura o método de distribuição randômica do atuador.

4 - UV Texturing:Textura produzem um grande impacto visual sobre jogos ou ambientes interativos. Com

texturas é possível criar detalhes em malhas com poucos polígonos. Com texturas que possuem canal alfa é possível criar coisas como janelas, fendas ou grades sem a necessidade de modelar diretamente.

4.1 - Formatos de arquivos disponíveis:O Blender usa o OpenGL para desenhar toda a sua interface a também para a gameEngine. Este

caminho permite utilizar seus aplicativos numa série de plataforma diferente. No que se refere ao uso de texturas deve-se prestar a atenção em várias coisas antes de rodar o jogo do blender em outras plataformas. Um game multiplataforma deve funcionar em todas as plataformas e o uso correto das texturas depende disto.

- a altura e largura da textura devem ser múltiplos de 64, por exemplo, 64x64, 64x128, 128x64, etc.

- não é recomendável utilizar texturas com resoluções acima de 256x256 pois nem todas as placas de vídeo suporta imagens de alta resolução.

4.2 - O Blender pode usar os seguintes formatos de texturas em tempo real:

TargaO arquivo Targa ou TGA (formato .tga) é um tipo de arquivo de imagem comprimido. Inclui

canal alfa.

IrisIris (.rgb) é um arquivo nativo do formato IRIX. É um arquivo de imagem comprimido. Inclui

canal alfa.

JpegÉ um tipo de arquivo de imagem comprimido muito utilizado em fotos. Devido ao tamanho

reduzido é muito usado para exibição em webs. Ele não possui canal alfa e devido a sua qualidade baixa não é recomendável como formato para trabalho de design de fases para um jogo.

Manuseando as mídias:Para a publicação e fácil manuseio dos arquivos Blender é possível incluir todas as fontes

dentro da cena. Normalmente texturas, sons e fontes não são incluídas no arquivo quando o mesmo é salvo. Desta forma quando você carrega o arquivo .blend todas as fontes são carregadas dos seus respectivos diretórios de origem. Mas se deseja distribuir o game é possível comprimir todas as mídias para serem salvas juntos com o arquivo do Blender, desta forma poderá distribuir o jogo num arquivo único que contém todas as mídias. Isto permite também a proteção das mídias usadas no jogo.

No menu FILE tem uma opção PACK FILE, clicando nesta opção irá aparecer uma caixa de presente na faixa do menu superior. Isto indica que todos os arquivos usados na mídia serão salvos automaticamente junto com o arquivo .blend, criando, desta forma, um arquivo único com toda mídia empacotada.

Observação: No texto original existe a função “Advanced Unpack” mas no Blender 2.41 não encontrei esta

função, pelo que não traduzi esta parte!

4.3 - O editor UV:O editor UV é totalmente integrado ao Blender e permite mapear textura sobre as faces dos

modelos. Cada face pode ter suas coordenadas individualmente texturizadas. Isto pode ser combinada com vértices coloridos que permitem escurecer ou clarear a textura ou também pintá-las.

Para iniciar o editor UV entre em modo de seleção de faces pressionando a tecla F ou no menu de MODO selecione a opção “UV face select”. A malha é agora desenhada “z-buferizada”. Pressionando ALT-Z é possível alternar entre o modo texturizado e sólido, isto ajuda na visualização da textura.

Para selecionar um objeto basta clicar sobre ele com o botão direito do mouse, o mesmo acontecendo para seleção de faces. Você pode selecionar (ou deselecionar) todas as faces pressionando a tecla A no modo de edição ou usando a tecla B para alternar entre a seleção “circulo” (o raio pode ser alterado com o botão de rolar central) e retangular. Lembre-se que para entrar no modo de edição basta pressionar a tecla TAB.

4.3.1 - A janela de manipulação de imagens (Image Window):Para acessar a janela de manipulação de imagens basta ir no ícone de mudança do tipo de

janelas disponíveis e escolher a opção “UV/Image editor”.

Veja abaixo o aspecto da janela de manipulação de imagem UV.

Na parte inferior da janela segue o menu correspondente ao “UV/Image editor”. O “View” exibe os modos de exibição da janela e a visualização das ferramentas de pintura e

propriedades. Na ferramenta de pintura é possível escolher vários tipos de pincéis e as cores correspondentes na paleta de cores que deseja usar. E o “View Properties” permite o ajuste dos vértices no “UV vertex” e o botão “Anim” permite o uso de animações de texturas.

O “Select” exibe um menu com as seleções possíveis para vértices ou faces da malha para edição.

Em “Image” é possível carregar uma imagem, salvar, pintar a textura, desempacotar uma imagem para um diretório (não é possível pintar uma imagem que esteja “empacotada”).

Em “UVs” ficam os possíveis ajustes de UV sobre a malha. Veja o screenshot abaixo:

5 - Python:Python é um interpretador, interativo, linguagem orientada a objetos.Python combina poder com uma sintaxe extremamente fácil. Ele possui módulos, classes,

“exceptions”, tipos de dados com alto nível de dinamismo e tipos dinâmicos. Python é multiplataforma e não é necessário IDEs elaboradas para programar nele.

Python é gratuíto e pode ser usado para fins comerciais.

5.1 - O janela de texto (TextWindow):O “TextWindow” é uma janela de texto simples mas bastante usual, totalmente integrada ao

Blender. O propósito principal desta janela é escrever scripts em Python, mas ela também é muito usual para escrever comentários sobre o arquivo Blender ou para explicar o propósito da cena para outros usuários.

A janela de texto pode ser exibida pressionando-se SHIFT-F11 ou através do ícone no meno inferior da janela.

Em “File” é possível abrir um arquivo de texto ou python e criar um novo. No primeiro ícone a direito de “File” é possível colocar o editor no modo “fullscreen”. O icone do meio permite exibir as linhas para controle e o ícone “AB” habilita / desabilita o exibição de palavras chaves em cores, como comandos ou comentários.

O botão “Screen” altera o tamanho da fonte e o “Tab” determina a distância da tabulação.Segurando o botão esquerdo do mouse é possível selecionar textos para edição. Alguns

comandos via teclado são possíveis também para edição. Segue abaixo uma lista das teclas usadas:

Teclas de comando da janela de texto:

ALT – CCopia para o buffer o conteúdo do texto selecionado.

ALT – XCorta o conteúdo do texto selecionado (elimina).

ALT – VCola o texto que está armazenado no buffer no local onde está o cursos na janela de texto.

ALT – OLê um texto. Vai aparecer uma janela de arquivos.

CTRL – RRelê o texto atual, muito usual para edição com editores externos.

SHIFT – ALT – FAbre um menu pop-up. Clicando com o botão direito do mouse também abre um pop-up.

ALT – JAbre uma janelinha onde é possível especificar o número de linha que deseja pular para edição.

ALT – U“Undo” (desfazer) ilimitado para a janela de texto.

ALT – R“Refaz” o último “Undo”.

CTRL – AMarca o texto todo da linha.

5.2 - Python para Games:Com Python integrado dentro da gameEngine é possível influenciar “LodicBricks”, chamando

seus parâmetros e reação sobre eventos ligados pelos “LogicBricks” (blocos lógicos).É possível influenciar um objeto no jogo pelo controlador python diretamente. É possível

mover, aplicar forças ou capturar informações do objeto.

5.2.1 - Básico do “game Python”:O primeiro passo para usar o python em jogos é adicionar um sensor e um controlador python

para um dado objeto. Então basta adicionar um novo arquivo de texto na janela de texto (TextWindow). Preencher o nome do arquivo de texto no campo “Script:” com o nome do arquivo python que servirá de controlador do objeto. Abaixo segue um screenshot exibindo o processo:

Agora entre com o seguinte script na janela de texto (não é necessário digitar as linhas que iniciar com “#” pois estas são apenas comentários).

1 # first gamePython script 2 # gets the position of the owning object 3 # and prints it on the console 4 5 import GameLogic 6 7 controller = GameLogic.getCurrentController() 8 owner = controller.getOwner() 9 10 print owner.getPosition()

O comando “print” e os erros do interpretador Python serão exibidos na janela console do DOS quando inicia o blender. Isto é muito usual para a visualização dos resultados enquanto programa em python.

Este script básico somente imprime e posição do objeto que é próprio do controlador python. Mova o objeto e então reinicie a gameEngine com a tecla “P” e veja o resultado na janela do DOS.

Agora vamos explicar as funções presente no script linha por linha. A linha 5 é a linha mais importante do programa. Importamos o módulo “GameLogic” que é o basico de todos os “gamePython” no blender.

Na linha 7 capturamos o controlador, que executa o script e assume a variável “controller”.Na linha 8 nós usamos o controlador que capturamos na linha 7. Assumimos a variável

“owner”.Agora temos um “owner” (próprio – refere-se a peça) e podemos usar metodos para fazer

coisas com ele. No exemplo, na linha 10 usamos o método “getPosition()” para imprimir a posição do “gameObject” como uma matriz de valores X, Y e Z.

Você pode usar vários outros métodos que um objeto pode ter baseado em script python. Este é o propósito desta documentação, mostrar os principais métodos python.

Adicione a seguinte linha no final do script.

1 print dir(owner)

Inicie a gameEngine novamente, pare e dê uma olhada na anela do console do DOS. Você terá a seguinte saida:

[0.0, 0.0, 0.0] ['applyImpulse', 'disableRigidBody','enableRigidBody', 'getLinearVelocity', 'getMass', 'getOrientation', 'getPosition', 'getReactionForce','getVelocity', 'restoreDynamics', 'setOrientation', 'setPosition', 'setVisible', 'suspendDynamics']

A primeira linha mostra a posição do objeto na cena. As próximas linhas mostram os métodos que podem ser aplicados ao “owner”. Por exemplo, se você usar o método “getMass” ele vai retornar a massa de um objeto dinâmico. Com o conhecimento da função “dir()” você pode “perguntar” ao python informações sobre o objeto sem precisar consultar qualquer documentação externa.

5.3 - Exemplos para jogos com implementações Python:Aqui você irá encontrar alguns exemplos pequenos de uso do python na gameEngine. Explore

os arquivos .blend e procure entender completamente como os exemplos foram feitos. Use as rotinas em suas cenas e projetos.

5.3.1 - Movendo objetos usando python:Você pode usar as funções setPosition() ou applyImpulse() para mover um objeto com script

python. Outro caminho é usando os campos de ligação para um atuador de movimento (Motion Actuator).

O script descrito abaixo mostra o uso deste método para mover objetos num caminho randômico, isto é similar a um movimento browniano de moléculas ou bactérias.

1 # Usa python para ajustar o atuador e mover objetos 2 # 29/03/2001 carsten@blender.nl 3 4 # CTRL-LEFTARROW para fullscreen 5 6 7 # Importa o modulo GameLogic 8 import GameLogic 9 10 11 # Captura o controlador (controller - which carries the script) 12 contr = GameLogic.getCurrentController() 13 14 # e o atuador (por nome!) 15 move=contr.getActuator("move") 16 17 # Captura um “random float” (0.0 ... 1.0), este é um gerador randômico 18 # que gera sequências diferentes toda vez que a engine é iniciada! 19 random = GameLogic.getRandomFloat() 20 21 # Ajusta o dRot e dLoc in the attached activator (observe que o último 22 # "1", para movimento local! 23 move.setDRot(0,(random-0.5)/5,0,1) 24 move.setDLoc(random/5,0,0,1) 25 26 # Ativa o atuador 27 GameLogic.addActiveActuator(move,1)

Observe que o uso da função getRandomFloat() é usado para gerar números randômicos sem usar o atuador Random. Estes números randômicos são diferentes toda vez que a engine é iniciada. A última linha ajusta os valores no atuador e o ativa com addActiveActuator().

A figura acima mostra os blocos lógicos usados. Tenha certeza de colocar o nome do atuador corretamente pois o script é referenciado para este nome no atuador. O atuador “add object” (adicionar objeto) está presente para criar a trilha a medida que o objeto se move!

5.3.2 - Verificação simples de visibilidade:

1 # Simple visibility check 2 3 import Rasterizer 4 5 6 # experimental visibility flag 7 # it will hide all objects 8 # so objects must be set visible 9 # using this script 10 11 Rasterizer.enableVisibility(1) 12 13 14 # get controller and sensor 15 cont = GameLogic.getCurrentController() 16 sensor = cont.getSensor("viznear") 17 18 # Set the player visible ;-) 19 sensor.getOwner().setVisible(1) 20 21 22 # now set all objects in the range of the near 23 # visible. Try to change "Dist" and "Reset" 24 objects = sensor.getHitObjectList() 25 if objects: 26 for obj in objects: 27 obj.setVisible(1)

Para uma verificação simples de visibilidade usando o “Near Sensor” (sendor de proximidade) para seu jogador é mostrada no screenshot abaixo. O sensor Near vai chamar o script de visibilidade com uma lista de objetos que estão dentro do sensor de proximidade definida por “Dist” e “Reset”. Tenha certeza que verificar que o pulso esteja no modo positivo para “f:0”.

Dê uma olhada no exemplo: visibility.blend

5.3.3 - Cursor do mouse com Python:

1 # Mouse cursor control 2 3 import GameLogic 4 import Rasterizer 5 6 # Get the dimensions of the game window 7 ww = Rasterizer.getWindowWidth() 8 wh = Rasterizer.getWindowHeight() 9 10 # calculate the aspect (in full screen the aspect of the CRT) 11 aspect = float(wh)/ww 12 13 # With this value you can calibrate the mouse to the 3D Window 14 actionx=28.0 15 actiony=actionx*aspect 16 17 #Get controller, sensor and owner 18 c = GameLogic.getCurrentController() 19 sensor = c.getSensor("mouse") 20 owner = c.getOwner() 21 22 # I use properties for debugging purpose (use wireframe to see) 23 owner.x = float(sensor.getXPosition()-ww/2)/ww*actionx 24 owner.y = float(sensor.getYPosition()-wh/2)/wh*actiony 25 26 # Set the position of the crosshair directly 27 # (see SCA, there is no Actuator) 28 owner.setPosition([owner.x,0,-owner.y])

O script é chamado pelo “Mouse Sensor” (sensor do mouse), ajustado para “chave sobre movimento”. Observe o uso de duas propriedades, X e Y, elas são usadas para fazer um “debug” necessário para o script trabalhar.

Dê uma olhada no exemplo: MG1.blend

5.4 - GamePython: Documentação por Módulo

5.4.1 - Módulo GameLogic:

SCA_PythonController getCurrentController ( );Retorna o “controller object” que carrega o script (?)

Void AddActiveActuator ( actuator , bool active);Este método faz o atuador (actuator) ativo (“active=TRUE”) ou inativo (“active=FALSE”).

Float GetRandomFloat ( );Esta função retorna um número randômico na faixa de 0.0 até 1.0. O “seed” é capturado do sistema de tempo de modo a gerar sequências de números randômicos diferentas cada vez que o programa é executado.

setGravity ( [gravityX, gravityY, gravityZ] );Ajusta a gravidade no mundo.

5.4.2 - Módulo Rasterizer:

Int GetWindowWidth ( );Esta função retorna a largura da janela do Blender com o game em execução.

Int GetWindowHeight ( );Esta função retorna a altura da janela do Blender com o game em execução.

Void MakeScreenshot ( char* filename);Esta função escreve uma screenshot no disco no formato TGA.

EnableVisibility ( bool usevisibility );Isto ajusta todos os objetos para invisível quando “usevisibility” for TRUE. O jogo pode então ajustar a visibilidade “atrás” somente para objetos necessários (?).

showMouse ( bool show);Exibe o cursor do mouse quando “show” for ajustado para TRUE enquanto o jogo estiver rodando.

setBackGroundColor ([float R, float G, float B]);

setMistColor ([float R, float G, float B]);

setMistStart ( float Start );

setMistEnd (float end);

5.4.3 - Módulo “GameKeys”:Este modulo apenas exibe todos nomes das teclas presentes no teclado (AKEY = 65, etc...)

“AKEY”, ..., “ZKEY”“ZEROKEY”, ..., “NINEKEY”“CAPSLOCKKEY”“LEFTCTRLKEY”, “RIGHTCTRLKEY”“LEFTALTKEY”, “RIGHTALTKEY”“LEFTSHIFTKEY”, “RIGHTSHIFTKEY”“ESCKEY”, “TABKEY”, “RETKEY”, “SPACEKEY”, “LINEFEEDKEY”“BACKSPACEKEY”, “DELKEY”, “SEMICOLONKEY”, “PERIODKEY”, “COMMAKEY”“QUOTEKEY”, “ACCENTGRAVEKEY”, “MINUSKEY”, “VIRGULEKEY”, “SLASHKEY”“BACKSLASHKEY”, “EQUALKEY”, “LEFTBRACKETKEY”, “RIGHTBRACKETKEY”“LEFTARROWKEY”, “DOWNARROWKEY”, “RIGHTARROWKEY”, “UPARROWKEY”“PAD0”, …, “PAD9”“PADPERIOD”, “PADVIRGULEKEY”, “PADASTERKEY”, “PADMINUS”, “PADENTER”“PADPLUSKEY”“F1KEY”, …, “F12KEY”“PAUSEKEY”, “INSERTKEY”, “HOMEKEY”, “PAGEUPKEY”, “PAGEDOWNKEY”“ENDKEY”

5.5 - Métodos padrão para blocos lógicos (LogicBricks):Todos os blocos lógicos possuem os seguintes métodos:

getOwner ( );Este rotina retorna o owner que é o gameObject que foi assumido pelo LogicBrick.

setExecutePriority ( int pri );?

Int pri getExecutePriority ( );?

5.5.1 - Métodos padrão para sensores:Todos os sensores seguem os métodos abaixo:

Int isPositive ( );Se o sensor “atira” pulsos positivos.

Bool getUsePosPulseMode ( );Retorna TRUE se o gerador de pulso positivos está ativo. Retorna FALSE para o caso contrário.

setUsePosPulseMode (bool flag);Ajuste o “flag” para TRUE para ligar o modo de pulso positivo. FALSE para chavear para o modo de pulso “off”.

Int getPosFrequency( );Retorna a frequência de “updates” dos pulsos no modo pulso positivos.

setPosFrequency ( int freq );Ajusta a frequência de “updates” no modo de pulso positivo. Se a frequência é negativa, é ajustado para 0.

Bool getUseNegPulseMode ( );Retorna TRUE se o gerador de pulso negativos está ativo. Retorna FALSE para o caso contrário.

setUseNegPulseMode ( bool flag);Ajuste o “flag” para TRUE para ligar o modo de pulso negativo. FALSE para chavear para o modo de pulso “off”.

Int getNegFrequency ( );Retorna a frequência de “updates” dos pulsos no modo pulso negativos.

setNegFrequency ( int freq);Ajusta a frequência de “updates” no modo de pulso negativo. Se a frequência é negativa, é ajustado para 0.

Bool getInvert ( );Retorna se o pulso do sensor está invertido ou não!

setInvert ( bool flag );Ajuste para TRUE para inverter a resposta do sensor e para FALSE para obter a resposta normalmente.

5.5.2 - Metodos padrão para controladores:Controladores possuem os seguintes métodos:

Actuator* getActuator (char* name);Retorna o atuador com nome (name).

List getActuators ( );Retorna uma lista python de todos os atuadores conectados.

Sensor* getSensor (char* name);Retorna um sensor com nome (name).

List getSensors ( );Retorna uma lista python de todos os sensores conectados.

5.5.3 - Metodos padrão para gameObjects:Game objects (objetos do jogo) que você captura com getOwner() possuem os seguintes

métodos:

ApplyImpulse ( list [x,y,z] , );Aplica um impulse do gameObjetc (N*s).

DisableRigidBody ( );Desabilita a dinâmica de corpo rígido para o gameObject.

enableRigidBody ( , );Habilita a dinâmica de corpo rígido para o gameObject.

setVisible ( int visible );

Ajusta a visibilidade do gameObject para visível (int visible = 1) ou invisível (int visible = 0), este estado somente terá efeito no frame seguinte. Use enableVisibility (bool usevisibility); do módulo Rasterizador para tornar todos os objetos invisíveis. Veja a seção 5.3.2.

setPosition ( [x,y,z] );Ajusta a posição do gameObject de acordo com as coordenadas X, Y e Z.

Pylist [x,y,z] getPosition ( );Captura a posição do gameObject das coordenadas X, Y e Z.

Pylist [x,y,z] getLinearVelocity ( );Retorna uma lista com as components X, Y e Z da velocidade linear. A velocidade é dada em unidades do Blender por segundo.

Pylist [x,y,z] getVelocity ( );Retorna a lista com as components X, Y e Z da velocidade. A velocidade é dada em unidades do Blender por segundo.

Float mass getMass ( );Retorna a massa do gameObject.

Pylist [x,y,z] getReactionForce ( );Retorna uma lista python de três elementos.

suspendDynamics ( );Suspende os calculos dinâmicos da gameEngine.

restoreDynamics ( );Suspende os calculos dinâmicos da gameEngine.