Now, in our callback, we drill down to get the GetUserData function. This will
actually give us a pointer to the entity that created these physics bodies that
are touching. Now from here, we start down a new magical rabbit hole. For each
of the objects that are touching, we need to signal, that a collision has
occurred to it. We do this by calling a new function, called onTouch, and
passing it in the other physics body that it's touching. So you can see that
entity A gets an onTouch function called, passing in body B, and entity B gets
an on touch function called passing in bodyA. This set up allows each
individual entity to respond to collisions in their own way. So for instance,
the onTouch of that for missile, would remove five health from the player it'
colliding with. Or if it's just hitting a wall, it may just decide to
self-destruct. But we haven't written this onTouch function yet. And in order
to do that, we need to hop all the way back to entity.js and add an onTouch
function. That allows other units to overload this function with custom logic
later. It's probably worth pointing out that you should be doing a whole series
of data checking to ensure that the information given to the post cell function
is valid. So for example, whether or not body A and body B are valid objects or
simply null. And whether or not the points of proper entity types and have
onTouch functions. Now we'll let you graffle through all of these issues in the
future. But we figured, that we let you get a glimpse at the madness behind the
mask. So, that means that anyone who defines a physics body should define an
onTouch function.
Ahora, en nuestra llamada de vuelta,
nos vamos al detalle
para obterner la función GetUserData.
Esto nos dará un puntero a la entidad
que dio origen a estos
cuerpos físicos que se tocan.
Desde aquí , iniciamos una nueva y mágica
madriguera de conejo.
Para cada uno de los objetos que se tocan,
necesitamos señalar
que ha ocurrido una colisión.
Hacemos esto llamando una nueva función,
llamada onTouch,
y pasarla al otro cuerpo físico
que está tocándolo.
Así puedes ver que la entidad A
llama a una función onTouch,
que se traspasa al cuerpo B
y la entidad B obtiene una función onTouch
que se traspasa al cuerpo A.
Esta configuración permite
a cada entidad individual
responder a las colisiones
en su forma particular.
Por ejemplo, el onTouch en un misíl,
eliminará 5 puntos de salud del jugador
con el que colisionó.
O si solo golpea un muro,
decidirá autodestruirse.
Pero no hemos escrito
la función onTouch todavía.
Y con el objeto de hacer esto,
necesitamos regresar hasta entity.js
y agregar una función onTouch.
Esto permite que otras unidades
puedan sobrecargar esta función
con una lógica propia después.
Cabe mencionar que debes hacer
una serie de revisiones de datos
para asegurar que la información
dada a la función post cell sea válida.
Por ejemplo, ya sea que el cuerpo A
y el cuerpo B sean o no objetos válidos
o simplemente nulos.
Y ya sea que los puntos
de los tipos apropiados de entidad
tengan o no la función onTouch.
Te dejaremos husmear
en estos problemas en el futuro.
Pero creemos que te hemos permitido
dar un vistazo a la locura
detrás de la máscara.
Eso significa que cualquiera
que defina un cuerpo físico
debiera también definir
una función onTouch.
コールバックではまず
GetUserDataメソッドを呼び出します
ここで接触している物体を作ったエンティティを
指定するポインタが得られます
ここからが新しい情報になります
接触しているオブジェクトに対して
衝突を知らせる信号を送らなければなりません
それにはonTouchという新しい関数を使います
エンティティAはbodyBを引数にしたonTouchを受け取り
エンティティBはbodyAを引数にした
onTouchを受け取ります
これによってそれぞれのエンティティが
個別に衝突に反応できます
例えばミサイルに当たったプレーヤーの
体力を減らしたり
壁に当たって爆発させたりもできます
しかしまだonTouch関数を記述していません
それにはentity.jsに戻ってonTouch関数を追加して
他のユニットでもこの関数を
オーバーロードできるようにします
その前にすべてのデータをチェックして
様々なメソッドに渡す情報が
有効になっていることを確かめてください
例えばbodyA、bodyBが
有効なオブジェクトなのかどうかや
ポインタが正しいエンティティを
指定しているかどうかなどです
これから実際に取り掛かってもらいますが
その前に少しだけ例をお見せします
物体の定義をするときには必ず
onTouch関数の定義が必要になるのです
No retorno de chamada, efetuamos o drill
down para obter a função GetUserData,
dando-nos um indicador da entidade
criadora dos corpos de física em contato.
Neste ponto, daremos início
a uma jornada mágica.
A cada objeto que se tocar, precisaremos
sinalizar que uma colisão ocorreu.
Para isso, chamamos
a função onTouch
transmitindo o outro corpo de física
que está sendo tocado. Você pode ver que
a entidade A recebe uma chamada de onTouch,
transmitindo o corpo B e, a entidade B
recebe uma chamada da função onTouch,
transmitindo o corpo A. Esta configuração
permite a cada entidade responder a
colisões à sua maneira. Por exemplo:
se um evento onTouch fosse um míssil,
ele removeria cinco de vida de um jogador.
Se fosse trombar contra uma parede,
ele poderia simplesmente
se autodestruir. Mas ainda não escrevemos
a função onTouch. E, para fazê-lo,
precisamos voltar lá atrás, em entity.js, e
adicionar uma função onTouch
permitindo a unidades sobrecarregarem-na
com lógica personalizada, mais tarde.
Vale a pena ressaltar que é aconselhável
verificar seus dados
para assegurar que a informação dada
à função PostSolve seja válida.
Por exemplo: o fato de bodyA e bodyB
serem objetos válidos ou nulos
e o fato de apontarem para tipos de entidades
adequados e terem funções onTouch.
Deixaremos que se ocupem
dessas questões no futuro,
mas pensamos que seria bom
se deixássemos cair a máscara.
Isso tudo quer dizer que qualquer pessoa
que defina um corpo, deverá também definir
uma função onTouch.