Arquivos simulação - Paulo Barbeiro

Baseado nos textos de Daniel Shiffman (http://www.shiffman.net/teaching/nature/)

Update – (26/10/2011):
Outros bons links com textos sobre vetores e jogos:
– Uso de vetores em jogos, por Vinícius Godoy de Mendonça; PontoV
– Uma breve explicação sobre vetores, por gamedevbrasil

Para realizar simulações de movimento em jogos, basicamente, basta fazer alterações das coordenadas de um dado objeto durante os ciclos de execução do programa, dessa forma então, cria-se a ilusão de animação.
Existem algumas formas clássicas para essa alteração de coordenadas:
– Apenas mudar os valores de coordenadas;
– Usar vetores;
– Simular cinemática;
– Simular Física;

Essas formas foram elencadas acima, com o intuito de criar uma espécia de linha evolutiva de complexidade. Isso não que dizer que a mais complexa é a mais útil que as demais, isso varia de projeto para projeto. Porém, é certo que as bases de um dos itens, influem sobre o seguinte.

Exemplo 1:

[code lang=”python”]
from direct.showbase.ShowBase import ShowBase
from direct.task import Task

class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)
self.taskMgr.add(self.funcaoDeTarefa, “Tarefa de teste”)
self.cubo = self.loader.loadModel(“box”);
self.cubo.reparentTo(self.render)
self.cubo.setScale(1)
self.cubo.setPos(-3,10,-2)

def funcaoDeTarefa(self, task):
print “A posicao do cubo e: “, self.cubo.getPos()
self.cubo.setX(self.cubo.getX()+0.01)
return Task.cont

app = MyApp()
app.run()
[/code]

Nesse exemplo, temos uma simples variação de valor de coordenadas do cubo. Observe que na função de tarefa (funcaoDeTarefa) o valor da coordenada ‘x’ do cubo é incrementada em 0.01 a cada execução da tarefa.

Exemplo 2:

[code lang=”python”]

from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from pandac.PandaModules import Vec3

class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)

self.vector_left = Vec3(-0.01,0, 0)
self.vector_right= Vec3( 0.01,0, 0)
self.vector_up = Vec3( 0 ,0, 0.01)
self.vector_down = Vec3( 0 ,0,-0.01)
self.main_vec = Vec3(0,0,0)

self.taskMgr.add(self.funcaoDeTarefa, “Tarefa de teste”)
self.cubo = self.loader.loadModel(“box”);
self.cubo.reparentTo(self.render)
self.cubo.setScale(1)
self.cubo.setPos(-3,10,-2)

self.accept(‘d’, self.changeDirection, [self.vector_right])
self.accept(‘a’, self.changeDirection, [self.vector_left])
self.accept(‘w’, self.changeDirection, [self.vector_up])
self.accept(‘s’, self.changeDirection, [self.vector_down])

def changeDirection(self, direction):
self.main_vec = direction

def funcaoDeTarefa(self, task):
self.cubo.setPos(self.cubo.getPos()+self.main_vec)
return Task.cont

app = MyApp()
app.run()

[/code]

Neste segundo exemplo temos o uso de vetores para o deslocamento de um objeto.
Vejamos ver o uso dos vetores mais detalhadamente.

Vetores: ========================================
referências:

baseado em Daniel Shiffman
http://www.cienciamao.usp.br/tudo/exibir.php?midia=tex&cod=_vetores
http://educar.sc.usp.br/fisica/vetores.html

Para animar um objeto em um espaço virtual, precisamos de uma maneira de armazenar a informação sobre a localização do objeto, movimento, etc. Num espaço de duas dimensões (como a nossa tela de computador), a localização é expressa por coordenadas X e Y – em um espaço de três dimensões, a localização é expressa por coordenadas X, Y e Z – Este par (ou trio) de informação é o elemento essencial para os sistemas que criaremos. Teremos “pontos” e “vetores”. Um ponto representa um local e um vetor representa o deslocamento entre dois pontos.

Considere um retângulo que se desloca através da tela. Em um dado instante tem a seguinte descrição:
[quote]
Posição – a localização do objeto, expressa em duas dimensões como um ponto.
Velocidade – a taxa na qual objeto muda de posição por unidade de tempo, expressa em duas dimensões do vetor.
Aceleração – a taxa na qual objeto muda a velocidade por unidade de tempo, expressa como um vetor de duas dimensões.
[/quote]
Obs.: Caso a descrição do espaço seja em três dimensões, os pontos e vetores envolvidos, devem ter também três dimensões.

Tecnicamente, a posição é um ponto; velocidade / aceleração são vetores. Para nossos propósitos, entretanto, vamos considerar todos os três como vetores para simplificar a nosso código. Examine o seguinte pseudo código. Suponha três vetores: aceleração, velocidade e localização. Este algoritmo simples será a base para os nossos exemplos.

[quote]
velocidade = velocidade + aceleração
Localização = localização + velocidade
Desenha a coisa na localização
[/quote]

Uma vez que vetores representam pares de valores, não podemos simplesmente usar a adição ou multiplicação tradicional. Em vez disso, precisaremos fazer operações com vetores.

Felizmente as game engines nos fornecem comandos para simplificar essas operações.

Então na prática, podemos dizer que um vetor armazena informações de:
– posicionamento (coordenadas)
– direção
– intensidade (comprimento)

Todas essas informações, e operações que os vetores nos fornecem, fazem os vetores serem tão populares no desenvolvimento de jogos; Pois são muito úteis e práticos para as simulações, sejam simulações de deslocamento de objetos, ou simulações de física, ou ainda, em simulações de comportamentos, por que vetores são formas de expressar matematicamente movimentos. Como dito anteriormente, eles armazenam informações de direção, intensidade (comprimento do vetor) e posicionamento; Como se não o bastasse, existem as chamadas “operações vetoriais” que são operações matemáticas feitas com vetores, e as mesmas são muito úteis.

Talvês o exemplo mais comum seja a subtração de vetores. Podemos usá-la para fazer com que um objeto siga outro (Para maiores detalhes matemáticos sobre subtração de vetores, veja os links selecionados nas referências.), a mágica acontesse porque, quando subtraímos um vetor A, por um vetor B, o resultado é um vetor C, que parte do vetor A, até o vetor B, assim temos no vetor C, a direção, e a distância entre A e B.

Observe o exemplo abaixo. Temos uma esfera que percorre o caminho entre os cubos. Todo esse trabalho acontesse na função update da esfera.

[code lang=”python”]
from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)

from direct.showbase.ShowBase import ShowBase
from direct.showbase.DirectObject import DirectObject
from direct.task import Task
from pandac.PandaModules import *

class Cubo(DirectObject):
loc = Vec3(0,0,0)
vel = Vec3(0,0,0)
acc = Vec3(0,0,0)
mass = 1;
maxVel = 1;

def __init__(self, pos):
self.loc = pos
self.carregaModelos()

def carregaModelos(self):
self.cubo = loader.loadModel(‘box’)
self.cubo.setPos(self.loc)
self.cubo.reparentTo(render)

# Class smiley ————————————
class Smiley(DirectObject):
loc = Vec3(0,0,1)
vel = Vec3(0,0,0)
acc = Vec3(0,0,0)
mass = 1
maxForca = 0.1

def __init__(self, pathToFollow):
self.carregaModelos()
self.way = pathToFollow
self.nextIt = 1;
self.next = self.way[1].loc
print “next pos: “, self.next

def carregaModelos(self):
self.smiley = loader.loadModel(‘smiley’)
self.smiley.setPos(self.loc)
self.smiley.reparentTo(render)

def update(self):
target = self.next
direction = target – self.loc
distancia = direction.length()
direction.normalize()
direction *= self.maxForca

self.loc += direction
if(distancia = len(self.way) ):
self.nextIt=0
self.next = self.way[self.nextIt].loc
self.smiley.setPos(self.loc)

#Classe do jogo —————————————
class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)

self.box0 = Cubo(Vec3(0,0,1))
self.box1 = Cubo(Vec3(10,0,1))
self.box2 = Cubo(Vec3(5,10,1))
self.box3 = Cubo(Vec3(-10,10,1))
self.box4 = Cubo(Vec3(-10,-5,1))
self.box5 = Cubo(Vec3(0,-10,1))

self.wayPoints = (self.box0, self.box1, self.box2, self.box3, self.box4, self.box5)

self.smileyForca = 0.5
self.smiley = Smiley(self.wayPoints)

#Codigo para o piso
self.cm = CardMaker(“ground”)
self.cm.setFrame(-20, 20, -20, 20)
self.ground = render.attachNewNode(self.cm.generate())
self.ground.setPos(0, 0, 0)
self.ground.lookAt(0, 0, -1)

self.taskMgr.doMethodLater(4, self.update, “update task”)

# Set the camera position
base.disableMouse()
base.camera.setPos(15, -30, 20)
base.camera.lookAt(0, 0, 0)

self.fiatLux()

def update(self, task):
self.smiley.update()
return Task.cont

def fiatLux(self):

# Directional light 01
self.directionalLight = DirectionalLight(‘directionalLight’)
self.directionalLight.setColor(Vec4(0.95, 0.95, 0.8, 1))
self.directionalLightNP = render.attachNewNode(self.directionalLight)
# This light is facing backwards, towards the camera.
self.directionalLightNP.setHpr(45, -15, 0)
render.setLight(self.directionalLightNP)

game = MyApp()

run()
[/code]

CINEMÁTICA ===========================================
Para começar vejamos uma simulação de cinemática. Cinemática é a um ramo da física clássica que se ocupa da descrição dos movimentos dos corpos, sem se preocupar com a análise de suas causas.

Exemplo 3:
[code lang=”python”]
from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)

from direct.showbase.ShowBase import ShowBase
from direct.showbase.DirectObject import DirectObject
from direct.task import Task
from pandac.PandaModules import Vec3

class Cubo(DirectObject):
loc = Vec3(0,30,0)
vel = Vec3(0,0,0)
acc = Vec3(0,0,0)

def __init__(self):
self.carregaModelos()

def carregaModelos(self):
self.cubo = loader.loadModel(‘box’)
self.cubo.setPos(self.loc)
self.cubo.reparentTo(render)

def update(self):
self.vel += self.acc
self.loc += self.vel
self.cubo.setPos(self.loc)
self.acc *= 0

class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)

self.vector_left = Vec3(-0.01,0, 0)
self.vector_right= Vec3( 0.01,0, 0)
self.vector_up = Vec3( 0 ,0, 0.01)
self.vector_down = Vec3( 0 ,0,-0.01)

self.taskMgr.add(self.funcaoDeTarefa, “Tarefa de teste”)
self.box = Cubo()

def changeDirection(self, direction):
self.box.acc += direction

def funcaoDeTarefa(self, task):
self.box.update()
return Task.cont

app = MyApp()
app.run()
[/code]

Neste exemplo, temos duas classes, a classe do Cubo, e outra da aplicação. A classe Cubo, possui as informações para o comportamento do cubo, os vetores de localização, velocidade e aceleração, e a rotina de atualização (descrita anteriormente) :

[quote]
velocidade = velocidade + aceleração
Localização = localização + velocidade
Desenha a coisa na localização
aceleração = aceleração * 0
[/quote]

Essa pequena rotina, é descrita pelas regras de cinemática, e usada na aplicação da segunda lei de Newton. Basicamente, a aceleração é o vetor que direciona o objeto. Quando a aceleração muda de direção, com o tempo, o objeto também muda de direção.

Depois de observada as bases da cinemática, temos duas formas de aplicações que derivam das mesmas bases: Física e comportamentos de movimentos(Inteligência Artificial para Games.)

Física ========================================

É plenamente possível realizar os cálculos necessários para simulação de física, porém esse é um tópico de alta complexidade. E para simplificar o trabalho, existem softwares especializados nesses cálculos, são as chamadas “engines de física”. No Panda3D, a mais usada é a ODE.
Essas engines de física, realizão os cálculos de simulação de forças, colisões, “juntas”, e outras fórmulas de física mecânica, e já atualizam a exibição dos objetos (só para Unity3D. No Panda3D é necessário colocar a atualização dos dados em uma tarefa ).

Exemplo 4:
[code lang=”python”]

from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)

from direct.showbase.ShowBase import ShowBase
from direct.showbase.DirectObject import DirectObject
from direct.task import Task
from pandac.PandaModules import *

class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)

self.fiatLux()

#Cria o mundo de fisica
self.world = OdeWorld()
self.world.setGravity(0,0,-9.81)

#estabelece configuracoes de reacao
self.world.initSurfaceTable(1)
self.world.setSurfaceEntry(0, 0, 150, 0.0, 9.1, 0.9, 0.00001, 0.0, 0.002)

#cria um ‘espaco’ para colisoes automaticas
self.space = OdeSimpleSpace()
self.space.setAutoCollideWorld(self.world)
self.contactgroup = OdeJointGroup()
self.space.setAutoCollideJointGroup(self.contactgroup)

#cria renderizacao de um cubo
self.box = loader.loadModel(‘../assets/eggs/box_c.egg’)
self.box.reparentTo(render)
self.box.setPos(0,9.5,7)
self.box.setHpr(5,35,57)
#self.box.setScale(1)
self.box.setColor(0.5, 0.5, 0.5, 1)

#cria um ‘body’ para representar o cubo no universo de fisica
self.boxBody = OdeBody(self.world)
self.boxMass = OdeMass()
self.boxMass.setBox(100,1,1,1)
self.boxBody.setMass(self.boxMass)
self.boxBody.setPosition(self.box.getPos(render))
print self.box.getQuat(render)
self.boxBody.setQuaternion(self.box.getQuat(render))
print self.boxBody.getQuaternion()
#cria um solido de colisao para realizar as colisoes no universo de fisica
self.boxGeom = OdeBoxGeom(self.space, 2,2,2)
self.boxGeom.setBody(self.boxBody)

# Set the camera position
base.disableMouse()
base.camera.setPos(40, 40, 20)
base.camera.lookAt(0, 0, 0)

self.taskMgr.doMethodLater(4, self.update, “update task”)

def update(self, task):
#obrigatorio
self.space.autoCollide()
self.world.quickStep(globalClock.getDt())

#atualiza a renderizacao do cubo, com base nas atualizacoes da fisica
self.box.setPosQuat(render, self.boxBody.getPosition(), Quat(self.boxBody.getQuaternion()))

#obrigatorio qdo houver colisoes
self.contactgroup.empty()
return Task.cont

def fiatLux(self):

game = MyApp()

run()

[/code]

No exemplo acima, temos uma cena bem simples onde um cubo, cai sobre um plano. O código exibe a forma básica de configuração de elementos de jogo, com a integração de simulações realizadas pela engine de física. No Panda3D, a engine ODE é a padrão, mas nada impede de utilizar outras; No Unity3D, a engine padrão é a Physx.

Além de simular a força da gravidade agindo sobre objetos, podemos também fazer com que “forças” atuem sobre nosso objeto, como acontece em situações como: um chute em uma bola; um arremesso de uma pedra; o impacto de uma explosão, etc. Veja a aplicação de uma força simples:

[code lang=”python”]

from pandac.PandaModules import loadPrcFileData
loadPrcFileData(”,’show-frame-rate-meter 1′)

from direct.showbase.ShowBase import ShowBase
from direct.showbase.DirectObject import DirectObject
from direct.task import Task
from pandac.PandaModules import *

class MyApp(ShowBase):

def __init__(self):
ShowBase.__init__(self)

self.fiatLux()

#Cria o mundo de fisica
self.world = OdeWorld()
self.world.setGravity(0,0,-9.81)

#estabelece configuracoes de reacao
self.world.initSurfaceTable(1)
self.world.setSurfaceEntry(0, 0, 150, 0.0, 9.1, 0.9, 0.00001, 0.0, 0.002)

#cria um ‘body’ para representar o cubo no universo de fisica
self.boxBody = OdeBody(self.world)
self.boxMass = OdeMass()
self.boxMass.setBox(100,1,1,1)
self.boxBody.setMass(self.boxMass)
self.boxBody.setPosition(self.box.getPos(render))
self.boxBody.setQuaternion(self.box.getQuat(render))
#cria um solido de colisao para realizar as colisoes no universo de fisica
self.boxGeom = OdeBoxGeom(self.space, 2,2,2)
self.boxGeom.setBody(self.boxBody)

# Set the camera position
base.disableMouse()
base.camera.setPos(40, 40, 20)
base.camera.lookAt(0, 0, 0)

#captura entrada de teclado
self.accept(‘f’, self.aplicaForca)

self.taskMgr.doMethodLater(4, self.update, “update task”)

def update(self, task):
#obrigatorio
self.space.autoCollide()
self.world.quickStep(globalClock.getDt())

#atualiza a renderizacao do cubo, com base nas atualizacoes da fisica
self.box.setPosQuat(render, self.boxBody.getPosition(), Quat(self.boxBody.getQuaternion()))

#obrigatorio qdo houver colisoes
self.contactgroup.empty()
return Task.cont

def fiatLux(self):

def aplicaForca(self):
print “aplica forca!”
print self.boxBody.getMass()
self.boxBody.setForce(100000,0,0)

game = MyApp()

run()

[/code]

Tag: simulação

Vetores & Física :: Gamedev receitas Panda3D