Nesse vídeo, iniciamos um uso prático de script em Python controlando alguns itens de API da Blender GE.
Temas abordados:
– uso de scripts em Python
– controladores Python a AND
– Sensores: Collision, Property, Always.
– Actuators: Motion, Property
– captura de objetos em cena, via script.
– uso da função alignAxisToVect
– subtração de vetores.
Tópicos abordados no vídeo:
– Introdução sobre colisões, e elementos de física – Propriedades de física dos objetos – Collision Sensors – Visibility, e Property Actuators
– Compatibilidade de colisões entre entidades de física distintas
– Propriedades dos objetos
– Visualização de Física
– Visualização de Propriedades para debug
Neste segundo vídeo sobre a game engine do Blender, é hora de falar sobre os blocos lógicos (Sensors, Controllers e Actuators) e seu funcionamento. No vídeos é abordado o uso dos seguintes blocos:
– sensores de teclado;
– controlador AND;
– “atuador” de Simple Motion;
– parentescos de objetos.
Olá Pessoal!
Na próxima semana começo a ministrar no SESC Carmo, um curso sobre a game engine do Blender, e pretendo postar aqui, os vídeos e os arquivos das aulas. Assim, a galera que esteve presente nas aulas, poderão consultar esse material para tirar dúvidas, e quem não esteve… poderá aprender de alguma forma também! 🙂
Segue abaixo um pequeno vídeo introdutório, dedicado especialmente para os usuários de Mac e Linux, mas extremamente válido para usuários do Windows.
Nos próximos dias outros vídeos serão postados, e novos posts serão feitos aqui no blog.
Abraço.Olá Pessoal!
Inputs e eventos, são elementos comuns em desenvolvimento de software como um todo. Afinal todo, ou quase todo, software recebe uma ordem de execução, através de um clique, ou de um comando de teclado, e essa ordem vinda de um usuário, chamamos popularmente, de Input de usuário.
Eventos são, em geral, comandos trocados entre elementos de um software. No caso de um jogo, podemos imaginar a seguinte situação: Um personagem está andando por um castelo, onde há um “gatilho” de uma armadilha. Quando o personagem, passa pelo gatilho, o gatilho avisa a armadilha para disparar as flechas que matarão o personagem.
Nessa pequena descrição, podemos dizer que o gatilho, enviou uma mensagem para a armadilha disparar. Essa mesagem é o que chamamos de eventos.
Ambos, Inputs de usuário, e eventos entre objetos, possuem um papel primordial para a construção de um jogo.
Input de Usuário ::
Crie um novo script Javascript no painel “Project”, chamado BasicInputHandler, e acoloque o seguinte código:
[code lang=”Javascript”]
function Update () {
//Move o objeto pelo eixo Z
if(Input.GetAxis(“Vertical”) > 0){
transform.Translate(Vector3.forward * Time.deltaTime);
}
else if(Input.GetAxis(“Vertical”) < 0){
transform.Translate(- Vector3.forward * Time.deltaTime);
}
//Move o objeto pelo eixo X
if(Input.GetKey(“d”)){
transform.Translate(Vector3.right * Time.deltaTime);
}
else if(Input.GetKey(“a”)){
transform.Translate(- Vector3.right * Time.deltaTime);
}
}
[/code]
Adicione um cubo à sua cena, e arraste esse script para esse cubo.
Esse script está checando o Input de usuário de duas formas, a primeira pelo eixo “Vertical” do objeto Input, e outra pelas teclas ‘d’ e ‘a’.
Opção de Eixos.
No Unity3D, há esse objeto global chamado Input, que captura as entradas de usuário, e às torna acessíveis para outros objetos do jogo. Esse eixo “Vertical”, que o objeto Input está utilizando, é previamente configurado, para ser ativado pelas teclas W,S, seta-para-cima e seta-para-baixo: As teclas W e Seta-para-cima, fazem com que o eixo “Vertical” seja positivo; As teclas S e Seta-para-baixo, fazem que o eixo seja negativo.
ISSO É UM CONFIGURAÇÃO QUE PODE SER MODIFICADA pelo desenvolvedor. Se você preferir que outras teclas acionem o eixo Vertical, entre no menu EDIT >> Project Settings >> Input. O painel Inspector irá exibir os eixos previamente configurados no Input. Você pode modificar as configurações de cada um deles, criar e excluir os eixos (basta modificar a propriedade Size, se você aumentar terá mais eixos disponíveis, se reduzir, eixos serão deletados).
Opção de Teclas.
A outra opção de utilização do Input, é pela função GetKey. O objeto Input captura quando as teclas são pressionadas, e essa informação fica disponível para a utilização.
Ambas as formas de captura do Input são válidas. A diferença entre elas é um detalhe, que não é muito claro de início, mas que vou descrever abaixo:
No objeto Input, do Unity3D, quando uma tecla que está ligada à algum eixo, é pressionada (digamos a tecla W), o eixo em questão começa a “crescer”, seu tamanho inicial que é zero, começa a aumentar; E quando a tecla é solta, o eixo começa a diminuir, seu tamanho diminui até chegar a zero.
Imagine essa situação no nosso cubo:
Assim que o usuário pressiona, digamos a tecla W, o eixo “Vertical” começa a crescer em comprimento, e o Cubo então, começa a se deslocar, afinal nosso código desloca o objeto quando o tamanho do eixo for diferente de zero. Mas assim que o usuário solta a tecla que ativa o eixo, o eixo começa a diminuir de tamanho lentamente, o que faz com que o nosso objeto continue se movendo, e interrompa seu deslocamento, apenas quando o eixo chegar ao valor zero.
Com o código acima, você perceberá, que há uma diferença entre as animações do movimento do cubo pelo eixo X e Z. Qual é o certo de ser usado? Depende de você escolher!
“Updates”, é uma nomenclatura usada no Unity3D, que se refere: “A necessidade de prover a certos objetos de jogo, loops de execução.”
Por exemplo, ao se criar um personagem em um jogo, a programação desse personagem pode ter uma série de funções que devem ser checadas, e executadas, a cada frame do jogo.
Diferentes game engines, possuem diferentes nomenclaturas, e formas de se implementar esses procedimentos. Aqui veremos como funciona no Unity3D. Na verdade o conceito é simples, basta usar a função Update, nos seus scripts.
Cria uma cena no Unity, e adicione dois cubos à cena, e posicione-os como preferir. Mas nomeios com os nomes “Cubo1” e “Cubo2″.
[code lang=”javascript”]
private var teste:int = 0;
function Update () {
Debug.Log(“Frame : “+teste);
teste++;
}
[/code]
Obs.: Crie esse script, nomeie-o como quiser. Arraste o script, do painel “Project”, para um dos GameObjects que estejam na sua cena (de preferência um dos cubos). Ao rodar o script, você vera esses resultados na janela do “Console”.
Esse script, está contando o número de frames do seu jogo. Logo na primeira linha, criamos a variável ‘teste’, com valor 0. A função Update, será executada a cada loop do programa, e a cada loop, ela irá escrever no Console a mensagem: “Frame : 0”, “Frame : 1”; “Frame : 2″… e assim sucessivamente
Agora para fazer com que um objeto de jogo se desloque na cena, façamos o seguinte script:
[code lang=”javascript”]
private var teste:int = 0;
function Update () {
transform.Translate(Vector3.right * Time.deltaTime);
Debug.Log(“Frame: “+teste);
teste++;
}
[/code]
Execute seu jogo, e você verá, o seu cubo se deslocando aos poucos sobre o eixo X, no sentido positivo do eixo.
Veja o exemplo aqui.
Neste tutorial, iremos trabalhar com simulações simples de física. O Panda3D possui uma pequena engine de física, que serve para simulações simples. Usaremos ela para melhorar o deslocamento do nosso personagem, e implementar um salto. Também veremos o uso de Intervals no Panda3D.
Esse tutorial tem por objetivo mostrar como usar, de maneira simplificada, uma engine de física. Caso você tenha interesse em utilizar o ODE no Panda, veja este pequeno tutorial, também lhe será útil: http://paulobarbeiro.com.br/blog/?p=77
Para começar com uma má notícia… boa parte do que foi feito até o momento nos tutoriais anteriores, principalmente o que foi feito para movimentar o avatar, não servirá para as simulações de física, logo vamos jogar, no lixo! 🙂 Isso lhe servirá como uma lição: Não se apegue a seu código! 😀 E pense bem, se irá usar simulações de física ou não, porque os códigos não serão reaproveitáveis.
O trabalho será meio longo. E antes de começarmos com códigos vamos explorar um pouco de teoria, e para ter uma “visão panorâmica” do que iremos fazer.
Engines de Física ——————-
Engines de física, são softwares dedicados a realizar cálculos de física, geralmente física Newtoniana, para diversos tipos de aplicações, sendo games uma das possibilidades.
Essas engines de física tem um único trabalho: calcular física. Sim, só isso! Engines de física não fazem renderizações, não capturam inputs de usuário, não fazem síntese sonora, elas apenas calculam valores, com base em fórmulas de física.
Dentro dessas fórmulas, encontra-se muitas opções, entre elas: as três leis de Newton, molas, juntas, colisões… etc. Cada engine de física, possui suas implementações de fórmulas. Cabe a você escolher qual engine usar, baseando-se no que cada uma oferece.
Bem, sendo que uma engine de física, apenas faz cálculos, talvez você esteja se perguntando, como elas são usadas em games?
Até o presente momento, nessa série de tutoriais, nós realizamos as movimentações de nosso personagem, modificando sua posição de coordenadas a cada frame do jogo. Ou seja, para que o avatar se desloca-se para a direita, nós incrementamos sua coordenada X a cada frame, e isso é o suficiente para dar uma ilusão de deslocamento. Essa é uma abordagem plenamente possível, e utilizada em muito jogos! Não há nada de errado nisso! Porém essa movimentação, feita dessa forma, ignora, por exemplo, uma reação natural a certas forças da natureza, como a gravidade. Qualquer um que olhar nosso jogo até o presente momento, irá reparar que o avatar cai a uma velocidade constante, e isso não é um comportamento natural em nosso universo.
E para muitos tipos de jogos, buscar essa naturalidade faz parte da diversão!
Usar simulações de física é um primeiro passo para buscar realismo nos jogos. Isso é uma busca que muda de jogo para jogo. Em alguns casos o realismo pode estragar completamente o jogo!
Então, quando utilizamos engines de física, nós deixamos de manipular as coordenadas os objetos! Quando se usa simulação de física, temos que pensar os movimentos, como reação a aplicação de forças sobre os objetos. Ou seja, para que um objeto se mova para a direita, ao invés de modificar suas coordenadas, temos que aplicar uma força nesse objeto, para fazer com que ele se mova para a direita. Todo o resto fica por conta da engine de física. O que irá determinar a forma do movimento, serão os resultados dos cálculos de simulação de física. Tudo que temos de fazer, é calibrar a aplicação das forças ao nosso gosto!
Pensar o movimento sobre a óptica da aplicação de forças físicas, não é complicado. Mas nos exige um pequeno conhecimento sobre forças e sua representação matemática, os vetores. Todos já estudaram isso nas aulas de física na escola, basta relembrar, e utilizar de uma forma muito mais divertida! Aqui tem um link que pode ajudar um pouco.
Há uma quantidade bem grande de explicações sobre vetores, cálculos vetorias, forças e forças vetoriais pela internet como um todo. Caso o link não lhe ajude, busque pela internet.
Agora, sabemos conceitualmente como as engines de física funcionam. Agora vamos pensar conceitualmente como isso se aplicaria ao nosso game.
Até o presente momento, temos movimentos em três direções, à direita, à esquerda, e para baixo. Então, para que nosso avatar se desloque temos que aplicar forças nele, ou seja:
– para baixo: teremos a força da gravidade;
– para direita: uma força que o empurre para direita;
– para esquerda: uma força que o empurre para a esquerda.
E caso queiramos um salto, teremos uma força que empurre nosso avatar para o alto! Veja o diagrama abaixo:
Nesse diagrama também temos os valores vetoriais para cada uma dessas forças. Esses valores vetoriais, representam a direção e intensidade da força. Por exemplo, a gravidade: Vec3(0,0,-9.81).
Esses três valores que forma o vetor, são coordenadas x,y,z. No caso da gravidade, x=0, y=0, e z=-9.81, ou seja, ela é uma força que aponta para baixo, com intensidade 9.81. Neste tutorial todas as forças são bem simples: apontam para direções nos eixos x, y, ou z, veja as outras:
– pushRight: Vec3(10,0,0): aponta para a “direita” (x positivo), intensidade 10
– pushLeft: Vec3(-10,0,0): aponta para a “esquerda” (x negativo), intensidade 10
– pushUp: Vec3(0,0,20): aponta para cima (z positivo), intensidade 20
O que nós faremos no nosso código, é uma implementação a engine de física do Panda3D, que irá aplicar essas forças em nosso avatar, de acordo com os inputs do usuário. Durante o processo, veremos a implementação dos elementos necessários, e problemas de lógica que teremos de achar soluções.
Essa engine de física que usaremos, é “embutida” no Panda3D, ela é muito simples, e com poucos recursos se comparada a outras engines de física, mas possui o que precisamos para nosso jogo. Devido a essas limitação, os desenvolvedores do Panda3D, também implementaram uma outra engine de física, a ODE (Open Dynamics Engine) um software já consagrado. Mas nada impede que outras engines sejam usadas. Outra possibilidade, é a PhysX, também implementada por alguns usuários!
Vamos aos passos iniciais. No arquivo Panda-tut-00.py, não teremos grandes modificações. Nesse arquivo principal, temos que importar e iniciar o PhysicsCollisionHandler, que será o grande responsável pela detecção de colisões, nesse caso, utilizando a simulação de física do Panda3D.
[code lang=”python”]
from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)
import direct.directbase.DirectStart
from pandac.PandaModules import *
from direct.task.Task import Task
from direct.showbase.DirectObject import DirectObject
from avatar import Avatar
#game class
class Game(DirectObject):
def __init__(self):
#init collider system
traverser = CollisionTraverser()
base.cTrav = traverser
base.cTrav.setRespectPrevTransform(True)
base.pusher = CollisionHandlerPusher()
base.pusher.addInPattern(“%fn-into-%in”)
base.pusher.addOutPattern(“%fn-out-%in”)
base.physics = PhysicsCollisionHandler()
base.physics.addInPattern(“%fn-into-%in”)
base.physics.addOutPattern(“%fn-out-%in”)
base.enableParticles()
#load platform model
self.plataforma = loader.loadModel(“../assets/eggs/plataformaBase”)
self.plataforma.reparentTo(render)
self.plataforma.setPos(0,10,0)
#load background sky
self.wall = loader.loadModel(‘../assets/eggs/papelParede’)
self.wall.reparentTo(render)
self.wall.setScale(1)
self.wall.setPos(-5, 30, -2)
#avatar
avatar = Avatar()
avatar.setCollision(traverser)
game = Game()
run()
[/code]
Observe que nesse código, apenas adicionamos as linhas 24, 25, 26 e 27. O PhysicsCollisionHandler funciona de forma muito semelhante aos outros “collision handlers”, a maior diferença é a obrigatoriedade de se ativar o sistema de partículas (linha 27).
As linhas relativas ao CollisionHandlerPusher, podem ser apagadas, elas não possuem mais uso, só as mantenho lá, para que você possa comparar.
Agora na classe Avatar, teremos grandes modificações! Vou colocar todo o código abaixo, e depois seguir nas explicações de cada alteração.
código classe avatar
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
from direct.task import Task
from pandac.PandaModules import *
from direct.interval.IntervalGlobal import *
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActorNode = ActorNode(‘personaActorNode’)
self.personaActorNode.getPhysicsObject().setMass(35)
self.personaActorNP = self.persona.attachNewNode(self.personaActorNode)
base.physicsMgr.attachPhysicalNode(self.personaActorNode)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setScale(1)
self.personaActor.setPos(0,0,5)
self.personaActor.reparentTo(self.personaActorNP)
self.persona.setPos(0,10,10)
self.persona.setScale(.15)
self.persona.setH(90)
self.state = { ‘left’ :False,
‘right’ :False,
‘ground’:False,
‘canJump’ :False
}
taskMgr.add(self.movement, “Avatar Movement”)
#timer for jump
self.startCallforJump = 0
self.timer = LerpFunc(self.performJump,
fromData = 0,
toData =1,
duration = 0.25,
blendType=’easeIn’,
extraArgs=[],
name=None)
#capture keyboard events
self.accept(‘arrow_left’, self.changeState, [‘left’,True])
self.accept(‘arrow_left-up’, self.changeState, [‘left’,False])
self.accept(‘arrow_right’, self.changeState, [‘right’,True])
self.accept(‘arrow_right-up’, self.changeState, [‘right’,False])
self.accept(‘space’, self.changeState,[‘jump’,True])
self.accept(‘space-up’, self.changeState,[‘jump’,False])
#capture collision events
self.accept(‘bola0CN-into-plataforma’, self.changeState, [‘ground’,True ])
self.accept(‘bola0CN-out-plataforma’, self.changeState , [‘ground’,False])
#Persona physics forces
self.pushUp=LinearVectorForce(0,0,20)
self.pushUpFN = ForceNode(‘pushup-force’)
self.pushUpFNP = render.attachNewNode(self.pushUpFN)
self.pushUpFN.addForce(self.pushUp)
self.pushLeft=LinearVectorForce(-10,0,0)
self.pushLeftFN = ForceNode(‘pushleft-force’)
self.pushLeftFNP = render.attachNewNode(self.pushLeftFN)
self.pushLeftFN.addForce(self.pushLeft)
self.pushRight=LinearVectorForce(10,0,0)
self.pushRightFN = ForceNode(‘pushright-force’)
self.pushRightFNP = render.attachNewNode(self.pushRightFN)
self.pushRightFN.addForce(self.pushRight)
self.gravityFN=ForceNode(‘world-forces’)
self.gravityFNP=render.attachNewNode(self.gravityFN)
self.gravityForce=LinearVectorForce(0,0,-9.81) #gravity acceleration
self.gravityFN.addForce(self.gravityForce)
base.physicsMgr.addLinearForce(self.gravityForce)
def setCollision(self, trav):
#colision nodes and solids
self.ball0 = CollisionSphere(0,0,1.5,1.5)
self.ball0NP = self.personaActorNP.attachNewNode(CollisionNode(‘bola0CN’))
self.ball0NP.node().addSolid(self.ball0)
self.ball0NP.show()
base.physics.addCollider(self.ball0NP, self.personaActorNP)
base.cTrav.addCollider(self.ball0NP, base.physics)
def movement(self, task):
#print self.personaActorNode.getPhysical(0).getLinearForces()
if(self.state[‘left’] == True):
if(len(self.personaActorNode.getPhysical(0).getLinearForces()) == 0):
self.personaActorNode.getPhysical(0).addLinearForce(self.pushLeft)
else:
self.personaActorNode.getPhysical(0).removeLinearForce(self.pushLeft)
if(self.state[‘right’] == True):
if(len(self.personaActorNode.getPhysical(0).getLinearForces()) == 0):
self.personaActorNode.getPhysical(0).addLinearForce(self.pushRight)
else:
self.personaActorNode.getPhysical(0).removeLinearForce(self.pushRight)
return Task.cont
def changeState(self, key, value, col=None):
if(self.state[‘canJump’] == True and key == ‘jump’):
if(value==True):
self.startCallForJump = globalClock.getRealTime()
if(value == False):
preparationTime = globalClock.getRealTime() – self.startCallForJump
if (preparationTime > 0.4): preparationTime = 0.4
elif(preparationTime < 0.2): preparationTime = 0.2
upforce = 1000*preparationTime
self.pushUp.setVector(0,0,upforce)
self.timer.start()
self.startCallForJump = 0
else:
self.state[key] = value
if(self.state[‘ground’] == True):
self.state[‘canJump’]=True
elif(self.state[‘ground’] == False):
self.state[‘canJump’]=False
def performJump(self, data):
if(data == 0):
self.personaActorNode.getPhysical(0).addLinearForce(self.pushUp)
elif(data == 1):
self.personaActorNode.getPhysical(0).removeLinearForce(self.pushUp)
[/code]
Vamos começar pela função __init__(self):
A primeira alteração é adicionar aos nodes e nodepaths que compõe nosso avatar, um ActorNode. O ActorNode é uma classe para um nó que interage com o sistema de física. Não confunda com a classe Actor, destinada à utilização de modelos “riggados”. Primeiro nós criamos o ActorNode (linha 5), configuramos a massa do nosso objeto; Adicionamos o ActorNode ao persona node; e o nodepath do ActorNode, dentro do persona node, é adicionado ao handler physics.
Observe outro detalhe importante na linha 17: O node personaActor, com o modelo do personagem, passa a ser ligado ao ActorNode. É essa ligação que fará com que o modelo, se movimente pela tela com as simulações de física.
Nas linhas 32 e 32, temos uma pequena lógica para realizar um salto. Veremos esse processo com mais detalhes em breve.
Nas linhas 46 e 47, temos uma captura de input de usuário com a tecla de espaço.
Das linhas 52 à 71, temos a configurações das forças que atuarão sobre nosso personagem, que discutimos anteriormente. E na linha 71, em especial vemos como fazer a aplicação da força ao ActorNode, no caso, a única força que será onipresente, a gravidade!
A criação dessas forças, é feita coma criação de um vetor de força, no caso, LinearVectorForce, que contém a direção e intensidade da força em questão. Com o LinearVectorForce criado, temos que criar um ForceNode, que será anexado ao render. Nesse momento, as forças ficam disponíveis para uso, basta aplicá-las.
A função setCollision:
Neste função temos poucas alterações, a única diferença é a necessidade, óbvia, de ligar os collisionNodes ao PhysicsCollisionHanlder.
A função movement:
Na função movement, temos a lógica que realiza o movimento do personagem aplicando as forçar apropriadas. Basicamente quando o estado do personagem muda para a direita ou esquerda, a função aplica e remove as forças, para que a simulação represente o que desejamos. Os comando addLinearForce() e removeLinearForce(), são bem auto-explicativos, não?
A função changeState:
Na função changeState temos uma lógica especial para a realização do salto do avatar.
Primeiro, o objetivo dessa função é filtrar o input de usuário pela tecla de espaço, para a realização do salto. O “filtro” consiste em realizar um salto mais forte, ou mais fraco, dependendo do tempo que o jogador pressiona a tecla de espaço.
Quando a barra de espaço é pressionada, a função avalia se o avatar pode saltar(canJump), ou seja, se ele está tocando a plataforma. Então ele avalia se a tecla de espaço foi pressionada ou desapertada; Se foi apertada, a função guarda o tempo em que ela foi apertada; Quando a tecla for solta, a função calcula o tempo em que ela ficou pressionada, e divide esse valor de 1000, o resultado é aplicado ao vetor de forca linear self.pushUp, e um timer é ativado, que executa a aplicação e remoção da força.
A função performJump:
Essa função é uma LerpFunction, declarada na linha 40, na função __init__. Essa função ira realizar uma espécie de timer, que usaremos para aplicar a força do salto, e bem pouco tempo depois, remover essa força. Um salto de uma humano, ou outro animal terrestre, é basicamente um único impulso bem forte, e não uma aplicação constante de força. Logo, para simular um salto humano, temos que fazer isso, uma aplicação de força em um curtíssimo período de tempo.
Quem assistiu São Paulo 2 x Corinthians 1, viu um capítulo histórico do futebol!
Só quero neste post, parabenizar o protagonista Rogério Ceni!
Parabéns Rogério!
A melhor matéria que li sobre o fato, foi da Folha de São Paulo:
http://www1.folha.uol.com.br/esporte/894692-rogerio-faz-100-do-jeito-que-queria-e-se-consagra-no-futebol.shtml
A melhor homenagem, foi do Estado de São Paulo, um poster no caderno de Economia página B9.
O melhor vídeo:
Gol 100 – Rogério Ceni – Narração Éder Luiz – Transamérica
A melhor sacanagem:
Tem troco pra cem?
Agora precisamos definir colisões para nosso personagem!
Colisões entre objetos em jogos, são um ponto absurdamente importante. Importante por se tratar de algo fundamental para a mecânica do jogo, e também por ser um tópico delicado em termos computacionais. E esse fator técnico nos obriga a algumas reflexões.
Calcular colisões entre objetos, com eficiência, envolve uma série de algoritmos complexos – os quais não vou entrar em detalhes – e que consomem um processamento considerável do computador, e para permitir que essas colisões sejam possíveis em tempo real, é necessário realizar algumas simplificações na descrição dos nossos elementos. Por exemplo: Se temos um modelo de uma cabeça, colisões não serão calculadas para cada depressão ou volume facial, mas simplificamos o formato da cabeça para uma esfera, ou um tubo, uma forma geométrica mais simples. Dessa forma as colisões conseguem ser calculadas de forma a não travar o bom desempenho da renderização.
Essas formas geométricas simples (esferas, cubos, tubos) são tratadas nas game engines como sólidos de colisão, pois serão esses objetos usados para cálculos de colisão.
Cada game engine possui seus próprios sólidos de colisão, e precisamos usá-los para criar uma descrição simplificada de nossos objetos.
No caso de nosso avatar, fiz a escolha de utilizar uma séria de esferas para suas colisões. Veja abaixo:
Porém, essa imagem acima é meramente ilustrativa, no nosso caso, não precisaremos de tanta definição, e vamos colocar esses sólidos de colisão na medida que forem necessários, começaremos apenas com uma esfera aos pés do avatar, para detectar colisões com a plataforma.
Criar um sólido de colisão, não é tudo. É necessário configurar os cálculos de colisões. No Panda3D, temos que adicionar outros dois objetos, um “Collision Traverser”, e um “collision handler”. Vamos adicionar esses objetos todos, e nos preocupar com os problemas depois 🙂 Sim teremos problemas, mas todos solucionáveis. Primeiro vamos criar o “Collision Traverser” e o “collision handler”, no arquivo Panda-tut-00.py:
[code lang=”python”]
from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)
import direct.directbase.DirectStart
from pandac.PandaModules import *
from direct.task.Task import Task
from direct.showbase.DirectObject import DirectObject
from avatar import Avatar
#game class
class Game(DirectObject):
def __init__(self):
#init collider system
traverser = CollisionTraverser()
base.cTrav = traverser
base.pusher = CollisionHandlerPusher()
base.pusher.addInPattern(“%fn-into-%in”)
base.pusher.addOutPattern(“%fn-out-%in”)
#load platform model
self.plataforma = loader.loadModel(“../assets/eggs/plataformaBase”)
self.plataforma.reparentTo(render)
self.plataforma.setPos(0,10,0)
#load background sky
self.wall = loader.loadModel(‘../assets/eggs/papelParede’)
self.wall.reparentTo(render)
self.wall.setScale(1)
self.wall.setPos(-5, 30, -2)
#avatar
avatar = Avatar()
avatar.setCollision(traverser)
game = Game()
run()
[/code]
O que temos de novo:
– logo no inicio da função __init__(self), temo a criação dos elementos traverser e do base.pusher, que são respectivamente, o “Collision traverser” e o “collision handler”
– logo abaixo da construção do Avatar, temos a linha: avatar.setCollision(traverser). Aqui é o ponto onde criamos no avatar as configurações necessárias para que o mesmo colida com outros objetos.
Vamos a classe Avatar:
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
from direct.task import Task
from pandac.PandaModules import *
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setScale(1)
self.personaActor.setPos(0,0,5)
self.personaActor.reparentTo(self.persona)
self.persona.setPos(0,10,0)
self.persona.setScale(.15)
self.persona.setH(90)
self.state = { ‘flying’:True,
‘left’ :False,
‘right’ :False
}
taskMgr.add(self.movement, “Avatar Movement”)
#capture keyboard events
self.accept(‘arrow_left’, self.changeState, [‘left’,True])
self.accept(‘arrow_left-up’, self.changeState, [‘left’,False])
self.accept(‘arrow_right’, self.changeState, [‘right’,True])
self.accept(‘arrow_right-up’, self.changeState, [‘right’,False])
def setCollision(self, trav):
#colision nodes and solids
self.ball0 = CollisionSphere(0,0,1.5,1.5)
self.ball0NP = self.persona.attachNewNode(CollisionNode(‘ball0CN’))
self.ball0NP.node().addSolid(self.ball0)
self.ball0NP.show()
trav.addCollider(self.ball0NP, base.pusher)
base.pusher.addCollider(self.ball0NP, self.persona)
def movement(self, task):
if(self.state[‘flying’] == True):
self.persona.setZ( self.persona.getZ() – 0.1 )
if(self.persona.getZ() < -2.3):
self.state[‘flying’]=False
#move sideways
else:
if(self.state[‘left’]):
self.persona.setX( self.persona.getX() – 0.1 )
elif(self.state[‘right’]):
self.persona.setX( self.persona.getX() + 0.1 )
return Task.cont
def changeState(self, key, value):
self.state[key] = value
[/code]
O que há de novo nessa classe:
– logo nas primeiras linhas: from pandac.PandaModules import * . Nesta linha importamos alguns módulos necessários para realizar as configurações de colisão.
– abaixo da função __init__ e antes da função movement, inserimos a função setCollision.
– na função setCollision criamos dois sub nós ao no persona.
Após essas alterações será fácil perceber que o o avatar irá de deslocar de maneira estranha pela plataforma, porém ficará claro que ele está “esbarrando” na plataforma. Esse é o comportamento normal do Collision Handler Pusher. Ele impede que os objetos atravessem uns aos outros.
Outro detalhe importantíssimo! ESPECIALMENTE QUANDO VOCÊ FOR UTILIZAR SEUS PRÓPRIOS MODELOS 3D!!!
Até aqui, foi configurado os objetos traverser e handler, e também a configuração de colisão para o avatar. NÃO FOI FEITA NENHUMA CONFIGURAÇÃO DE COLISÃO PARA A PLATAFORMA!!
Na verdade verdadeira, o arquivo da plataforma já está configurado para colisões, por isso não foi necessário fazê-lo. Vou explicar como foi feito, para que este tutorial não fique incompleto, e que quando você for utilizar seus próprios modelos 3D, possa fazer o mesmo.
Para a plataforma, poder-se-ia (rsrsrsrs) usar sólidos de colisão, mas optei por usar Collision Mesh. Collision Mesh, é utilizar o próprio modelo 3D como sólido de colisão. A limitação é: Seu modelo deve ser simples, e não côncavo!
Quando você converte seus modelos 3D para o formato do Panda3D( .egg), o arquivo final, é essencialmente um arquivo de texto, que você pode abrir em qualquer editor de texto simples, e modificá-lo. Para fazer com que um modelo, simples e não côncavo, seja sensível à colisão, precisamos adicionar uma linha a cada “group”: <Collide>{Polyset keep descend}
Os arquivos .egg são um texto estruturado tal como um XML. Inicialmente, no .egg, é configurado os materiais existentes na geometria. Então iniciam-se os grupos. Um “Group”, é iniciado com sua matriz (informação de posicionamento, e rotação); Logo após, inicia-se uma lista (VertexPool) com informações de todos os vértices que compõe aquela geometria; Finalmente, temos uma lista com informações dos polígonos que compõe a geometria.
Logo, a linha <Collide>{Polyset keep descend}, deve ser colocada no inicio de cada Group. Abra o arquivo plataforma.egg e veja como ele funciona.
[code lang=”xml”]
piso {
{Polyset keep descend}
{
{
1.000000 0.000000 0.000000 0.000000
0.000000 11.226257 0.000000 0.000000
0.000000 0.000000 0.182287 0.000000
0.000000 0.000000 0.000000 1.000000
}
}
piso {
0 {
1.000000 11.226256 -0.182287
}
1 {
1.000000 -11.226257 -0.182287
}
[…]
22 {
-1.000000 11.226261 -0.182287
}
23 {
-1.000000 11.226257 0.182287
}
}
{
{ Material }
{ 0.000000 0.000000 -1.000000 }
{ 0 1 2 3 { piso } }
}
[ … ]
{
{ Material }
{ 0.000003 1.000000 0.000012 }
{ 20 21 22 23 { piso } }
}
}
[/code]
Antes da implementação, vamos entender do que se trata esse tal de CollisionHandlerPusher, e como as colisões serão encaixadas no nosso jogo.
O CollisionHandlerPusher, é um “tratador” de colisões no Panda3D, que não permite que os objetos atravessem uns os outros. Ele desloca o objeto que está se movendo para trás, ou para o lado, desviando-o da intersecção dos objetos.
Outra possibilidade do Collision Handler Pusher, é gerar eventos! Ou seja, quando objetos colidem, ele pode gerar eventos notificando o sistema da colisão. Essa é uma funcionalidade do Collision Handler Event, donde o Collision Handler Pusher é derivado. Logo ele herda essa funcionalidade do Handler Event. A geração de eventos do Collision Handler Pusher, é habilitada nas linhas 20 e 21, do arquivo Panda-tut-00.py.
Implementação —————
Agora que temos nossa colisão básica configurada, falta trabalhar nos detalhes de implementação.
A primeira colisão que temos nessa cena, é quando o avatar cai na plataforma. Até o presente momento, nós fazemos esse cálculo baseado em uma posição no eixo Z. Mas para deixar nosso jogo mais correto, vamos fazer isso com colisão, entre a esfera e a plataforma.
Antes de realizar a implementação
Para começar, vamos apagar as linhas 49 e 50:
[code lang=”python”]
if(self.persona.getZ() < -2.3):
self.state[‘flying’]=False
[/code]
A partir de agora o que irá mudar o state[‘flying’] para False, será a colisão entre a esfera e a plataforma. Vamos criar um novo accept no nosso avatar, para capturar o evento gerado pela colisão (‘ball0CN-into-plataforma’):
[code lang=”python”]
self.accept(‘ball0CN-into-plataforma’, self.changeState, [‘flying’,False])
[/code]
Nesta linha acima, definimos que a colisão entre a esfera e a plataforma, será tratada pela mesma função self.changeState. Observe com detalhe o nome do evento: ‘ball0CN-into-plataforma’. Observe a linha 20 do Panda-tut-00.py, base.pusher.addInPattern(“%fn-into-%in”).
Quando configuramos a geração de eventos pelo pusher, e usamos essa combinação “%fn-into-%in”, o pusher irá gerar eventos com os nomes dos colliders, no nosso caso, a “bolla0CN”, e a “plataforma”.
Porém temos um problema. Toda função que trata uma colisão, obrigatoriamente, tem que receber as informações da colisão. Essa informação é transmitida à função como um parâmetro, logo a função tem que estar preparada para recebê-lo. O que não acontece com nossa função self.changeState. Bem, você pode pensar que: “ah… blz, vamos colocar uma variável ali nos argumentos da função, que fica tudo certo!”. Não… Isso não é tão simples… e como fica a chamada da função nos eventos de teclado, que não enviam um terceiro parâmetro? Esqueceu disso? Se uma função for chamada, com mais ou menos parâmetros os quais ela possui, acontece um erro, e o programa é encerrado.
Felizmente, tem uma manhã em python para lidar com isso. Inserimos um parâmetro ‘col’ (diminutivo de ‘colisão’ rsrsrs) e dizemos que ele é igual a ‘None’ (nulo em python), caso a função não receba esse argumento!! Engenhoso não? Veja:
[code lang=”python”]
def changeState(self, key, value, col=None):
self.state[key] = value
[/code]
Ao final desse processo, teremos nosso avatar, parando de cair ao tocar a plataforma, porém ainda teremos um problema, veja que ele parece patinar sobre a plataforma! Isso acontece pq o pusher quer repelir o avatar da plataforma! Podemos solucionar esse problema, forçando o personagem na posição X e Y que queremos! Veja a solução no código completo abaixo:
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
from direct.task import Task
from pandac.PandaModules import *
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setScale(1)
self.personaActor.setPos(0,0,5)
self.personaActor.reparentTo(self.persona)
self.persona.setPos(0,10,0)
self.persona.setScale(.15)
self.persona.setH(90)
self.state = { ‘flying’:True,
‘left’ :False,
‘right’ :False
}
self.lastXpos = 0;
taskMgr.add(self.movement, “Avatar Movement”)
#capture keyboard events
self.accept(‘arrow_left’, self.changeState, [‘left’,True])
self.accept(‘arrow_left-up’, self.changeState, [‘left’,False])
self.accept(‘arrow_right’, self.changeState, [‘right’,True])
self.accept(‘arrow_right-up’, self.changeState, [‘right’,False])
self.accept(‘ball0CN-into-plataforma’, self.changeState, [‘flying’,False])
self.accept(‘ball0CN-out-plataforma’, self.changeState, [‘flying’,True])
def setCollision(self, trav):
#colision nodes and solids
self.ball0 = CollisionSphere(0,0,1.5,1.5)
self.ball0NP = self.persona.attachNewNode(CollisionNode(‘ball0CN’))
self.ball0NP.node().addSolid(self.ball0)
self.ball0NP.show()
trav.addCollider(self.ball0NP, base.pusher)
base.pusher.addCollider(self.ball0NP, self.persona)
def movement(self, task):
if(self.state[‘flying’] == True):
self.persona.setZ( self.persona.getZ() – 0.06 )
#move sideways
else:
if(self.state[‘left’]):
self.persona.setX( self.persona.getX() – 0.1 )
elif(self.state[‘right’]):
self.persona.setX( self.persona.getX() + 0.1 )
else:
self.persona.setX(self.lastXpos)
if(self.persona.getY() != 10):
self.persona.setY(10)
return Task.cont
def changeState(self, key, value, col=None):
self.state[key] = value
if(value == 0):
self.lastXpos = self.persona.getX()
[/code]
Basicamente, na função movement, checamos se a posição Y do avatar não for igual a 10, então ela é corrigida para 10. Isso resolve a “patinação” do avatar para frente e para tráz. Mas ele ainda patina para os lados. Para resolver isso, criamos uma variável chamada lastXpos. Essa variável irá fazer o trabalho de posicionar o avatar sempre no ponto X correto, e não permitir de ele patine para os lados. Observe na função movement, que quando o avatar estiver tocando na plataforma, e não estiver se movendo para a direita ou esquerda, ele será posicionado sempre na posição lastXpos. Essa variável tem seu valor atualizado, sempre que o avatar para de se mover: Veja na função self.changeState, sempre que o ‘value’ for igual a zero, atualizamos a variável lastXpos.
Neste segundo tutorial criaremos nosso avatar, e habilitaremos algumas funcionalidades de interação do Panda3D: tasks e inputs de usuário.
Em termos de código python, veremos como trabalhar com módulos, condicionais e dicionários.
Porque precisamos desses módulos python? Bem, nosso código começará a ganhar tamanho, e manter nossas classes em arquivos diferentes, é altamente recomendável para facilitar nosso desenvolvimento. Essa coisa de módulos é super simples: basta criar um novo arquivo de código na nossa pasta Panda-project/src e nameá-lo avatar.py, e teremos nele o código abaixo:
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setPos(0,0,4.6)
self.personaActor.reparentTo(self.persona)
self.persona.setPos(0,10,0)
self.persona.setH(90)
self.persona.setScale(.1)
[/code]
Vejamos as coisas novas:
1 – from direct.actor.Actor import Actor
::> Essa é a classe do Panda3D que lida com modelos “riggados”. Que é o caso do nosso modelo.
2 – self.persona = render.attachNewNode(‘persona’)
::> Aqui um novo ‘nó’ é criado, que irá abrigar o ‘nó’ para o modelo 3D. Precisaremos fazer isso, porque teremos outros nós a serem criados, e logo, devemos manter esses nós organizados.
3 – self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
::> Nessa linha criamos o Actor, baseados no arquivo do personagem.egg.
4 – {‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
::> Nessas linhas informamos ao Actor, quais animações queremos no nosso personagem. O que vemos aqui é um dicionário python. Podemos notar que ‘idle’ é a chave, para o valor ‘./assets/eggs/personagem-parado’, ou seja a animação ‘idle’, será a animação do arquivo “personagem-parado.egg”. Esse pequeno processo se repete para todas as animações que quisermos.
5 – self.persona.setH(90)
::> Este comando rotaciona o nó persona. Tente comentar essa linha e veja o que vai acontecer.
Para facilitar a compreenção do que foi feito, veja no gráfico abaixo, como que está organizado esse node relativo ao Avatar:
No diagrama acima, temos um esquema ilustrando que o nó do personaActor, nó que guarda nossa geometria, está linkado ao nó persona. E está posicionado na posição (0,0,4.6) relativo ao nó persona, ou seja, levemente acima.
Neste próximo diagrama, temos a demonstração de como vai funcionar nosso grafo a partir de agora:
Agora, temos a segunda parte… importar esse módulo no arquivo principal Panda-tut-00.py, onde precisamos importar a classe Avatar do módulo avatar:
[code lang=”python”]
from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)
import direct.directbase.DirectStart
from pandac.PandaModules import *
from direct.task.Task import Task
from direct.showbase.DirectObject import DirectObject
from avatar import Avatar
#classe para o jogo
class Game(DirectObject):
def __init__(self):
#carregar o modelo da plataforma
self.plataforma = loader.loadModel(“../assets/eggs/plataformaBase”)
self.plataforma.reparentTo(render)
self.plataforma.setPos(0,10,0)
#plano de fundo
self.parede = loader.loadModel(‘../assets/eggs/papelParede’)
self.parede.reparentTo(render)
self.parede.setScale(1)
self.parede.setPos(-5, 30, -2)
#avatar
self.avatar = Avatar()
game = Game()
run()
[/code]
Ao final teremos algo como essa imagem ao lado.
De agora em diante, todos os comandos relativos ao Avatar serão escritos nesse arquivo Avatar.py. Vamos iniciar com uma lógica bem simples, imperfeita para nossas finalidades, mas boa para introduzir quem esta começando. Vamos fazer com que nosso personagem caia até a plataforma, e então possa se deslocar lateralmente sobre a mesma.
Façamos nesta ordem:
– avatar cai, se não estiver tocando a plataforma;
– quando tocar a plataforma para de cair;
– quando estiver na plataforma, ele pode se deslocar para os lados;
– quando o usuário pressionar as setas para direita ou esquerda, o avatar se desloca;
Para essa pequena lógica, vamos criar uma função que analise os ‘estados’ do avatar, para então decidir se ele deve cair, ou não; se deve ir para os lados, ou não. E vamos criar os estados também!
E teremos algo novo também, uma tarefa! Tarefa é uma nomenclatura usada no Panda3D, que se refere: A necessidade de prover a certos objetos de jogo, loops de execução. Isso nos permite criar uma ação que se repetirá a cada frame do jogo! Veja maiores detalhes aqui.
O código do módulo avatar ficará assim:
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
from direct.task import Task
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setScale(.3)
self.personaActor.setPos(0,0,1.5)
self.personaActor.reparentTo(self.persona)
self.persona.setPos(0,30,0)
self.persona.setH(90)
self.state = { ‘flying’:True,
‘left’ :False,
‘right’ :False
}
taskMgr.add(self.movement, “Avatar Movement”)
def movement(self, task):
if(self.state[‘flying’] == True):
self.persona.setZ( self.persona.getZ() – 0.1 )
return Task.cont
[/code]
O que temos de novo:
1 – um dicionário de estados: self.state = {‘flying’:True, ‘left’:False, ‘right’:False}
::> Ele guardará as informações se o avatar esta voando (‘flying’), ou seja não está tocando a plataforma; E ainda se o avatar esta se deslocando para a esquerda(‘left’) ou direita(‘right’). O estado ‘flying’ é o único marcado como True, porque assim que o jogo começa, nosso personagem está no alto.
2 – Temos um gerenciador de tarefas: taskMgr.add(self.movement, “Avatar Movement”)
::> Nesse gerenciador, definimos a função self.movement, como a função que será executada a cada quadro, e nomeamos essa tarefa como “Avatar Movement”.
3 – Uma nova função: def movement(self, task):
::> Essa é a função que será executada pelo gerenciador de tarefas a cada frame do jogo.
Nessa função, pelo fato dela ser chamada pelo gerenciador de tarefas, obrigatoriamente ela deve receber o argumento ‘task’, e retornar uma constante de Task, no caso Task.cont, para continuar a tarefa no próximo frame.
Também temos uma pequena lógica na função. Ela avalia se o estado ‘flying’ é verdadeiro, e se for, o posicionamento do avatar no eixo Z será modificado, reduzindo o valor, e a ilusão com isso, será que o avatar está caindo.
Até o dado momento, o avatar será “jogado para baixo” infinitamente. Vamos fazer com que ele para quando sua altura for igual a altura da plataforma, altera a função movement dessa forma:
[code lang=”python”]
def movement(self, task):
if(self.state[‘flying’] == True):
self.persona.setZ( self.persona.getZ() – 0.1 )
if(self.persona.getZ() < -2.25):
self.state[‘flying’]=False
[/code]
Nessa alteração, modificamos a função de forma que assim que o nodepath persona, chegar na altura da plataforma, o estado ‘flying’ se torna Falso (‘False’), e então, o avatar para de cair.
Aqui temos um exemplo bem simples de como construir uma lógica com base em valores, inteiros e boleanos. Em breve modificaremos esse código para solucionar um problema que veremos em breve.
Inputs de Usuário ————
Vamos adicionar a possibilidade do usuário pressionar as tecla direcionais e o avatar se deslocar pela tela, para a direita e esquerda. Isso é o que chamamos de Inputs de usuário, para outros detalhes clique aqui.
Inputs de usuários são eventos dentro do Panda3D. Para capturar esses eventos, devemos:
– declarar quais objetos devem ser notificados de certos eventos: accept()
– definir funções para executar ações;
veja abaixo as alterações no módulo avatar, discutiremos as alterações posteriormente:
[code lang=”python”]
from direct.showbase.DirectObject import DirectObject
from direct.actor.Actor import Actor
from direct.task import Task
#modulo da classe Avatar
class Avatar(DirectObject):
def __init__(self):
self.persona = render.attachNewNode(‘persona’)
self.personaActor = Actor(‘../assets/eggs/personagem.egg’,
{‘idle’:’../assets/eggs/personagem-parado’,
‘run’ :’../assets/eggs/personagem-correr’,
‘jump’:’../assets/eggs/personagem-pular’}
)
self.personaActor.setScale(1)
self.personaActor.setPos(0,0,5)
self.personaActor.reparentTo(self.persona)
self.smiley = loader.loadModel(‘smiley’)
self.smiley.reparentTo(self.persona)
self.smiley.setPos(0,0,0)
self.smiley.setScale(.2)
self.persona.setPos(0,10,0)
self.persona.setScale(.15)
self.persona.setH(90)
self.state = { ‘flying’:True,
‘left’ :False,
‘right’ :False
}
taskMgr.add(self.movement, “Avatar Movement”)
#capture keyboard events
self.accept(‘arrow_left’, self.changeState, [‘left’,True])
self.accept(‘arrow_left-up’, self.changeState, [‘left’,False])
self.accept(‘arrow_right’, self.changeState, [‘right’,True])
self.accept(‘arrow_right-up’, self.changeState, [‘right’,False])
def movement(self, task):
if(self.state[‘flying’] == True):
self.persona.setZ( self.persona.getZ() – 0.1 )
if(self.persona.getZ() < -2.3):
self.state[‘flying’]=False
#move sideways
else:
if(self.state[‘left’]):
self.persona.setX( self.persona.getX() – 0.1 )
elif(self.state[‘right’]):
self.persona.setX( self.persona.getX() + 0.1 )
return Task.cont
def changeState(self, key, value):
self.state[key] = value
[/code]
As novidades ficam após a linha 34.
Nas linhas 35, 36, 37 e 38, notificamos ao Panda3D, que nosso avatar deve ser notificado quando as teclas direcionais direita e esquerda forem pressionadas e soltas. Os eventos ‘arrow_left’ e ‘arrow_right’ acontecem quando o usuário pressiona as teclas. Os eventos ‘arrow_left-up’, e ‘arrow_right-up’, acontecem quando o usuário solta as teclas.
Posteriormente, dizemos que a função self.changeState é a função que será executada, a cada vez que nosso objeto avatar for notificado dos eventos. Para finalizar esses “accepts”, passamos as listas [‘left’,True], [‘left’,False], [‘right’,True] e [‘right’,False]. Essas listas serão utilizadas na função self.changeState, como parâmetros.
A função changeState, possui uma tarefa muito simples: mudar o estado do nosso avatar.
Ela está preparada com dois argumentos, key e value, que se referem aos estados no dicionário self.state, veja, self.state[key], ou seja o argumento ‘key’, deverá obrigatoriamente ser uma string (palavra) ‘left’ ou ‘right’, e os valores que serão definidos para o estado será sempre True ou False. Repare que os argumentos ‘key’ e ‘value’, enviados para a função, são aquelas listas [‘left’, True] e [‘right’,False]!!
Para finalizar essa implementação, e de fato fazer o avatar se deslocar pela tela, colocamos na função movement, uma lógica que observa se os estados ‘left’ e ‘right’ são verdadeiros para então deslocar o personagem pelo eixo X.
Sim!! Temos uma interatividade! Interatividade muito tosca… mas já é alguma coisa. Agora quando nosso avatar chega na plataforma, ele pode se deslocar!
Colisões ———-
No próximo post vamos melhorar significamente nosso código!
Se você reparar temos um grande problema: nosso avatar passa direto pelos obstáculos! Temos que implementar colisões!
Precisamos implementar uma colisão com a plataforma e com os obstáculos. Para isso usaremos algumas técnicas.
AVISO: No próximo post nosso código ganhará um pouco de complexidade!