Tutorial de scripts para Unity 3d

limits:

var limits : JointLimits


Variable que establece/indica los límites de nuestro hingejoint (recordemos, para que tengamos más o menos claro a qué nos referimos con lo de límites, que hinge lo podemos traducir por "bisagra").

La variable es del tipo JointLimits, que es una estructura que a su vez tiene las siguientes cuatro variables:

min: Es el límite inferior del joint. Cuando el ángulo o posición del joint se
halla por debajo de este valor, el joint recibe la fuerza necesaria para
restablecerlo a ese mínimo.
max: El límite superior del joint. Si el ángulo o posición de éste está por
encima de este valor, el joint recibe fuerzas pra restablecerlo a dicho
máximo.
minBounce:La capacidad de retorno del joint a su límite inferior cuando es golpeado
por debajo de éste (pensemos en las puertas del Saloon.
maxBounce:Lo mismo que la anterior aplicado al límite superior.


El joint será limitado para que el angulo esté siempre entre limits.min y limits.max. Dicho ángulo se calcula en términos relativos al ángulo existente al principio de la simulación, esto es, si entre dos rigidbodys hay ya al inicio un ángulo de 20º, si su variable limits.min la fijamos en 10, el ángulo real será de 30º

Vamos a trastear un rato, que es la mejor manera de quedarse con los conceptos. De entrada, vamos a devolver al suelo a nuestros cubos, así que devolvemos sus transform.position.y respectivas a cero, y no nos olvidemos de desmarcar la casilla de sus constraints que marcamos en el ejemplo anterior.

Por otro lado, el script MiSegundoScript, que en el anterior capítulo le habíamos sustraido a la esfera, se lo volvemos a asignar, para que de nuevo impacte contra nuestros cubos. Le daremos algo más de fuerza (AddForce(0,0,20)). Ubicaremos a la esfera en la posición 0.3,0,-5.

Ahora vamos a intentar convertir los cubos en lo más parecido a una puerta, y le vamos a dar unos ángulos máximo y mínimo de apertura. Para evitar que el cubo que tiene asignado el hinge joint (cube) se nos mueva demasiado le asignaremos un valor a su variable mass en el rigidbody (en el inspector ) de 6.

Y tecleamos en MiPrimerScript:

var pegadoATi : Rigidbody;
hingeJoint.connectedBody = pegadoATi;

hingeJoint.axis = Vector3.up;
hingeJoint.anchor = Vector3(0.5,-0.5,0.5);
hingeJoint.limits.min = 0;
hingeJoint.limits.max = 70;
hingeJoint.limits.minBounce = 0;
hingeJoint.limits.maxBounce = 0;

Si lo probamos, veremos que al impacto de la esfera nuestro joint alcanza un grado máximo de 70 grados, sin rebote. Si quisiéramos obtener un rebote de nuestra puerta precaria, podríamos asignarle a maxBounce un valor de 4, por ejemplo.


spring:

var spring : JointSpring


Esta variable intenta alcanzar un ángulo que es su objetivo a base de añadir fuerzas de resorte y amortiguación. Podemos traducir en este contexto spring como muelle, lo que nos da una idea del tipo de impulso del que estamos hablando.

El tipo de esta variable es JointSpring, que tal como podemos suponer es de nuevo una estructura, que en este caso consta de tres variables:

spring: La fuerza tipo resorte para alcanzar la targetPosition, el
ángulo deseado. Un valor más grande hace que alcancemos la
posición más rápido.
damper: La fuerza del amortiguador usada para amortiguar la velocidad
angular. Un valor más grande hace que alcance el objetivo más
lento.
targetPosition: La posición que el joint intenta alcanzar. El spring alcanza la
targetPosition en ángulos relativos al ángulo inicial.


Pongámoslo con un ejemplo. Para ello previamente eliminamos el script vinculado a la esfera. Y luego, MiPrimerScript debería quedar como sigue:

var pegadoATi : Rigidbody;
hingeJoint.connectedBody = pegadoATi;

hingeJoint.axis = Vector3.up;
hingeJoint.anchor = Vector3(0.5,-0.5,0.5);

hingeJoint.spring.spring = 20;
hingeJoint.spring.damper = 6;
hingeJoint.spring.targetPosition = 90;

Aquí abriremos nuestra puerta precaria con un impulso inicial de 20 y una amortiguación de 6, tendiendo a alcanzar los 90 grados. Si le damos al play notaremos el evidente efecto catapulta.


useMotor:

var useMotor : boolean


Habilita/deshabilita el motor del joint.


useLimits:

var useLimits : boolean


Habilita/deshabilita los límites del joint.


useSpring:

var useSpring : boolean


Habilita/deshabilita el resorte del joint.


velocity:

var velocity : float


Devuelve la velocidad actual del joint en grados por segundo.


angle:

var angle : float


Devuelve el ángulo actual en grados del joint con respecto a la posición inicial. Es una variable de solo lectura.

Esta clase agrupa juntos 2 rigidbodies, constreñiéndolos a moverse como si estuvieran conectados por una bisagra.

Este tipo de joints es perfecto para puertas, pero también puede usarse para modelar cadenas, por ejemplo.


VARIABLES:

motor:

var motor : JointMotor


La variable motor aplicará una fuerza en aumento hasta conseguir la velocidad deseada en grados por segundo. Esta variable es de tipo JointMotor, que es una estructura que a su vez tiene las siguientes variables:

targetVelocity: Es la velocidad de desplazamiento o rotación que se pretende
conseguir.
force: Es la fuerza que aplicará el motor para conseguir la velocidad fijada en
targetVelocity.
freeSpin: Es un booleano. Si está habilitado, el motor sólo acelerará y nunca
reducirá.

Si unimos intuitivamente los conceptos junturas y motor, posiblemente se nos vengan a la cabeza engranajes, vehículos o maquinarias. Esa intuición no va muy desencaminada. Hagamos las siguientes modificaciones para prepararnos el terreno.

Eliminamos el script vinculado a la esfera. Luego vamos a colocar a nuestros cubos siameses (cubo y cube) dos unidades sobre tierra, lo que obviamente conseguiremos colocando su posición (la de los dos) en el eje X en 2. En ambos casos, además y para evitar que se nos caigan al suelo por la gravedad, en sus respectivos constrainst marcaremos Freeze Position Y.

Ahora editamos el script MiPrimerScript (que si hemos seguido las lecciones al pie de la letra debemos tener vinculado a Cube), para que luzca así:

var pegadoATi : Rigidbody;
hingeJoint.connectedBody = pegadoATi;

hingeJoint.anchor = Vector3(0,0,0);
hingeJoint.motor.force =100;
hingeJoint.motor.targetVelocity = 90;
hingeJoint.motor.freeSpin = true;

Resumamos lo que hemos hecho: El rigidbody del segundo cubo (el que no tiene asignado un hingeJoint) es asignado a la variable pegadoATi, que posteriormente es conectada al hingeJoint. El ancla entre ambos cubos (que por defecto se ubica en el eje X) la colocamos en el centro geométrico del cubo, para que el giro que pretendemos sea más natural. Luego aplicamos un motor al hingejoint con una fuerza de 100 hasta conseguir alcanzar una velocidad de 90 grados por segundo, y sin que el motor pueda reducir.

Démosle al play para comprobar que funciona.

El motor trata de alcanzar la velocidad angular de motor.targetVelocity en grados por segundo. El motor sólo será capaz de alcanzar motor.targetVelocity si motor.force es suficientemente grande. Si el joint está girando más rápido que el motor.targetVelocity el motor se romperá. Un velor negativo para motor.targetVelocity hará que el motor gire en dirección contraria.

El motor.force es la torsión máxima que el motor puede ejercer. Si es cero el motor se deshabilita. El motor frenará cuando gire más rápido que motor.targetVelocity sólo si motor.freeSpin es false. Si motor.freeSpin es true el motor no frenará.