viagra online non prescriptionnon prescription viagra onlinenon prescription viagra online
Blender Game Engine » Python Script

By paddloPayday loans

Hierarquia no Game Engine

Requisitos: Conhecimento mínimo em programação python para Game Engine.

Uma dúvida que deixa de cabelos brancos a todos os iniciantes no python para o Game Engine, é como acessar objetos via programação. Neste artigo, vou ensinar o conceito básico sobre a hierarquia usada nos jogos do Blender.

Observe a figura abaixo:

Na verdade este diagrama está bem simplificado, pois existem outros itens que podemos incluir na hierarquia, mas vamos tomá-lo como um padrão.

Para que se consiga atingir o destino desejado, será necessário percorrer a hierarquia. Você pode fazer esse percurso tanto do nível mais alto para o mais baixo como também o inverso. Então podemos dividir a programação python em dois tipos: Crescente e Decrescente.

Programação Crescente

Esta é o tipo de programação mais usado. Ele vai subindo o diagrama até chegar no ponto mais alto possível.
A primeira coisa que precisa saber e que todo script python do game engine está ligado a um Controlador. O script python é a parte mais baixa da hierarquia.

Vejamos este LogicBrick:

Neste exemplo existe um controlador do tipo python, dois sensores(CaixaEntrada e Teclado) e dois atuadores(AdicionarJogador e Mensageiro). Todos estão nomeados devidamente. Lembrando que é muito importante nomear os seus logicbricks para que fique mais fácil de localizar via programação.

Vamos imaginar que queremos buscar o Atuador AdicionarJogador para trabalhar com ele. Pelo nosso diagrama, o caminho seria este: Script Python -> Controlador -- > Atuador.

Vamos implantar isso em Python Script:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#-----------------------------------------------------------------
#importando o módulo GameLogic. Este é o módulo mais importante
#do game engine. Em nosso diagrama principal ele não  está
#ligado a nada, mas todos os componentes de jogo de alguma forma
#estão ligados a ele.
import GameLogic

#Como todo script começa na fonte mais baixa (Script Python)
#e como também já  estamos nesta fonte. Teremos que buscar
#o próximo degrau da hierarquia: o Controlador

#A função getCurrentController() busca o controlador que
#executou o script
controlador = GameLogic.getCurrentController()

#Agora que já temos nosso controlador, temos que buscar
#nosso atuador através da função getActuator(“nome_do_atuador”)
atuador = controlador.getActuator("AdicionarJogador")
#----------------------------------------------------------------

Prontinho, já temos nosso atuador armazenado em uma variável de igual nome (atuador). Agora você já pode trabalhar ela usando suas funções e procedimentos (temas para um próximo artigo).

Mas agora, se desse mesmo logicbricks, quisermos buscar o sensor teclado? Como ficaria nosso código? Pelo nosso diagrama, o caminho seria este: Python -> Controlador -- > Sensor.

Então o código ficaria assim:

1
2
3
4
5
6
7
#------------------------------------------------
import GameLogic
controlador = GameLogic.getCurrentController()
#Agora que já temos nosso controlador, temos que buscar
#nosso sensor através da função getSensor(“nome_do_sensor”)
sensor = controlador.getSensor("Teclado")
#------------------------------------------------------------

Já vimos com acessar os sensores e atuadores, agora vamos acessar o objeto que executou o script: Script Python -> Controlador -- > Objeto.

1
2
3
4
5
6
7
#------------------------------------------------------------------
import GameLogic
controlador = GameLogic.getCurrentController()
#vamos buscar o objeto ao qual pertence o controlador que executou
#o script pela função getOwner()
proprietario = controlador.getOwner()
#------------------------------------------------------------------

Prontinho, temos o objeto armazenado na variável proprietário. No game engine, costumamos chamar o objeto que executou o script de proprietário, porque ele é dono de todos os controladores, sensores e atuadores que estão ligados a ele.

Como podemos ver, conseguimos alcançar todas as instancias “possíveis” usando o método de programação Crescente.


Programação Decrescente

A programação decrescente, embora menos comum, é usada em projetos em que objetos têm que interagir entre eles. Ela permite que script que esteja sendo executado em um objeto A possa acessar um objeto B.
Como exemplo, vamos imaginar que se tenha três objetos em cena, nos quais você devidamente os re-nomeou como: bola, quadrado e triangulo. Existe um script no objeto bola que você deseja que acesse o objeto quadrado. Para isso teremos que começar de cima para baixo, de acordo com o nosso diagrama: Cena -- > Objeto.
O script Python para acessar o objeto quadrado ficaria assim:

1
2
3
4
5
6
7
8
9
#------------------------------------------------------------------
import GameLogic

#Buscando a cena que esta sendo executada no jogo
cena = GameLogic.getCurrentScene()

#Buscando o objeto “quadrado” através da função getObjectList()
objeto = cena.getObjectList()["OBquadrado"]
#----------------------------------------------------------------

Observações:
A função getObjectList() retorna uma lista de todos os objetos que estão em cena. Quando você a usa definindo o nome ( getObjectList()["OBquadrado"]), ela busca somente o objeto em questão.
No Game Engine, mesmo que você re-nomeie seu objeto, o blender sempre vai acrescentar o prefixo “OB” no inicio.

Considerações finais:

Como se pode perceber, em ambos os métodos, nenhum alcança os extremos. Os dois só chega até o nível objeto, mas é bom saber que a união deles pode se tornar uma arma poderosa no game engine.


Maio 2007