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.12
Usage: 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 -y
bash-2.00$

-g fixedtime
Esta 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 vertexarrays
Desabilita 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 noaudio
Desabilita o som.

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

-g linermipmap
Ajusta 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:

Actor
Ativando “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 Body
O “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 Fh
Este 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 Fh
Com 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. (?)

Mass
A 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

Damp
Amortecimento 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.

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

Anisotropic
Quando 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.

Float
Armazena um número de ponto flutuante.

String
Armazena uma cadeia de caracteres.

Timer
Este 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).

Restitut
Este 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.

Friction
Este 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 Force
Em 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 Damp
Controla o “arrasto” dentro da área “Fh”. Valores acima de 0.0 vai causar um “arrasto” no
movimento do objeto dentro da área “Fh”.

Fh Norm
Com 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:

Spec
Ajusta o controle de intensidade de especularidade.

Hard
Ajusta o controle do tamanho da especularidade.

Spec color
Ativando 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.

Hemi
A 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 Example

Integer numbers 15
Float number 12.23224
Booleans TRUE, FALSE
Strings "Eu sou uma string!"
Properties propname
Sensornames sensorname (um nome no LogicBrick)
Expressões aritméticas

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

Operações booleanas

Operation Example
NOT EXPR Not EXPR
EXPR1 OR EXPR2 logical OR
EXPR1 AND EXPR2 logical AND
EXPR1 == EXPR2 EXPR1 equals EXPR2

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

Exemplos de expressões:

Expressão Resultado Explicação

12+12 24 Adição
property=="Carsten" TRUE or String comparação entre uma
FALSE 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 - Always
Este é 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] Equal
2] Not Equal
3] Interval
4] 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.

dLoc
Move o objeto como já foi explicado anteriormente.

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

linV
Ajusta a velocidade do objeto para um dado valor.

angV
Ajusta 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:

Play
Executa 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 Pong
Executa 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”.

Flipper
Executa 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 Stop
Executa o IPO em loop a enquando o pulso for positivo. Ele para na posição corrente se o pulso for
negative (cessar).

Loop End
Executa 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.

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

Atualmente os seguintes IPOs são suportados pela gameEngine:

Mesh Objects
Loc, Rot, Size e Col

Lamps
Loc, Rot, RGB, Energy

Cameras
Loc, 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 Stop
Executa o som enquanto ouver um pulso positivo.

Play End
Executa um som até o final quando um pulso positive é recebido.
Loop Stop
Executa e repete o som quando um pulso positivo é fornecido.

Loop End
Toca 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:

Assign
Assume 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 (“...”).

Add
Adicione 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:

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

Iris
Iris (.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 – C
Copia para o buffer o conteúdo do texto selecionado.

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

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

ALT – O
Lê um texto. Vai aparecer uma janela de arquivos.
CTRL – R
Relê o texto atual, muito usual para edição com editores externos.

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

ALT – J
Abre 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 – A
Marca 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.