Cita de: lightbug date=1567693052Jajaj totalmente, acá el uso práctico hace la diferencia. Según Wikipedia:
   
   
      "In mathematics, the quaternions are a number system that extends the complex numbers."    --->    a +b i + c j + d k
   
   
      Un número complejo se puede expresar en 2 dimensiones, una para la parte real (que NO acompaña a la "i") y otra para la parte imaginaria (que acompaña a la "i"). Entonces acá se puede decir que un Quaterion se puede expresar con 4 dimensiones.
   
   
      Revisando el código de Unity, un Quaterion es efectivamente un vector de 4x1,:
   
   

public Quaternion(float x, float y, float z, float w)
    {
      this.x = x;
      this.y = y;
      this.z = z;
      this.w = w;
    }

   
      En el mundo matricial la multiplicación de una matriz de (M filas xN columnas ) x (I filas x j columnas):
   
   
      ( M x N )  x  (I x J )   ....     Es válida o realizable si N = I, es decir   --->( M x N )  x  ( I x J )  ...   y el resultado tiene dimensión MxJ (Extremos)  ---> ( M x N )  x  (I x J )
   
   
      Acá dejo un poco de código de Quaternions (sacado del código de Unity). Lo interesante es que estos valores se puede arreglar de tal o tal forma y resultar en vectores, quaternions o directamente matrices de 4x4 (ejemplo: parte las matrices que usan los shader, MVP en OpenGL, WVP en D3D , necesitan agregar una componente a la posición, de Vec3 a Vec4). Basicamente lo que hace Unity es afectar a los factores de tal forma de generar el resultado querido.
   
   
      Acá el operador *(Q,V) ... la regla que mencioné arriba:
   
   

public static Vector3 operator *(Quaternion rotation, Vector3 point)
    {
      float num1 = rotation.x * 2f;
      float num2 = rotation.y * 2f;
      float num3 = rotation.z * 2f;
      float num4 = rotation.x * num1;
      float num5 = rotation.y * num2;
      float num6 = rotation.z * num3;
      float num7 = rotation.x * num2;
      float num8 = rotation.x * num3;
      float num9 = rotation.y * num3;
      float num10 = rotation.w * num1;
      float num11 = rotation.w * num2;
      float num12 = rotation.w * num3;
      Vector3 vector3;
      vector3.x = (float) ((1.0 - ((double) num5 + (double) num6)) * (double) point.x + ((double) num7 - (double) num12) * (double) point.y + ((double) num8 + (double) num11) * (double) point.z);
      vector3.y = (float) (((double) num7 + (double) num12) * (double) point.x + (1.0 - ((double) num4 + (double) num6)) * (double) point.y + ((double) num9 - (double) num10) * (double) point.z);
      vector3.z = (float) (((double) num8 - (double) num11) * (double) point.x + ((double) num9 + (double) num10) * (double) point.y + (1.0 - ((double) num4 + (double) num5)) * (double) point.z);
      return vector3;
    }

   
      Acá el operador* (Q,Q), Multiplicación de Quaternions (otras reglas):
   
   

public static Quaternion operator *(Quaternion lhs, Quaternion rhs)
{
return new Quaternion(
   (float) ((double) lhs.w * (double) rhs.x + (double) lhs.x * (double) rhs.w + (double) lhs.y * (double) rhs.z - (double) lhs.z * (double) rhs.y), 
         (float) ((double) lhs.w * (double) rhs.y + (double) lhs.y * (double) rhs.w + (double) lhs.z * (double) rhs.x - (double) lhs.x * (double) rhs.z),
   (float) ((double) lhs.w * (double) rhs.z + (double) lhs.z * (double) rhs.w + (double) lhs.x * (double) rhs.y - (double) lhs.y * (double) rhs.x), 
   (float) ((double) lhs.w * (double) rhs.w - (double) lhs.x * (double) rhs.x - (double) lhs.y * (double) rhs.y - (double) lhs.z * (double) rhs.z)
);
}

   
       
   
   
      Da miedo ...
   
   
      Lo importante es leer el manual y saber que hace cada método del Quaternion. Cuando apretás el botón del ascensor que hace que el ascensor funcione (para un usuario promedio), lo que importa es saber a qué piso querés ir.
   

Muchas gracias.  Voy a ver a que piso voy xD

Cita de: iRobb date=1567518567Pues una regla más a la lista. Las 4 reglas de oro 

Me anoto las cuatro, aunque aún no se ponerlas en práctica.  Es más, el tema qu aternion no termino de entenderlo.  He visto algún tutorial pr youtube pero me quedo igual que estaba, pues con la hipotenusa, ecuaciones y demás me pierdo. De momento para mi son como una especie de vector. 
 
Descartando el tema giroscopio y retomando el acelerómetro y su rotación de la gravedad voy encontrando mas problemas sobre lo mismo.
 
de momento estoy haciendo lo posible por ver si los soluciono por mi mismo sin molestaros más. 
 
Gracias

No he encontrado ningún tutorial sobre el tema con el que propones, pero buscando he encontrado otro script con unos modificadores que modifican un edge collider. Los modificadores también van en desfase con el edge collider, como ocurría con el script anterior que encontré,  y cuesta trabajo trabajar así, pero hasta que no aprenda otro modo o incluso a realizar un script como este, creo que será mi mejor opción. 
 
Gracias

Buenas noches,
 
¿Hay algún modo funcional de hacer los colliders 2d curvos? He utilizado los edge collider, con muchos puntos pero la bola hace extraños y además me salta la vibración del movil casi por segmento.
 
He encontrado unos scripts de custom colliders 2d, pero no funciona bien, digamos que las barras editoras aparecen en un punto y las curvas muy lejos. No he conseguido modificar el código.
 
Un saludo,

Hola de nuevo,
 
tras varias horas de intensas peleas con el giroscopio, que en muchas ocasiones ha requerido reiniciar el s5, porque se le iba la pinza, he conseguido que funcione, pero no consigo el efecto deseado.
 
Omitiendo varias funciones de calibración que no he conseguido tampoco hacer que funcionen, el código que tengo es este:
 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class Giroscopio : MonoBehaviour
{
    public GameObject pista;
    private float posicionInicialZ = 0f;
    private float posicionGiroZ = 0f;
     
    // Start is called before the first frame update
    void Start()
    {
        Input.gyro.enabled = true;
       // posicionInicialZ = pista.transform.eulerAngles.z;
    }
    // Update is called once per frame
    void FixedUpdate()
    {
        transform.position = new Vector3(-2.43f, -22.43f, 0);
        RotacionGiroscopio();  
    }
    void RotacionGiroscopio()
    {
        pista.transform.rotation = Input.gyro.attitude;
        pista.transform.Rotate(0, 0, 2.65f, Space.World);       
    }
}

 
El GameObject llamado pista, rota sobre el eje Z con el gyroscopio. No consigo anclar los ejes X e Y.
 
Aunque no lo voy a usar, con el fin de aprender, quisiera saber como bloquear los ejes.
 
Gracias y un saludo,
 
.

Cita de: iRobb date=1567408244El acelerómetro, como su nombre indica, detecta cambios de aceleración. Los cambios de posición con movimiento que afecten al dispositivo. Ahora bien, como detecta aceleraciones y estamos en la Tierra, las rotaciones que afecten al eje Y serán detectadas debido a la gravedad. Y si es rotado solo horizontalmente no habrá aceleraciones que detectar.

      En cambio el giróscopo detecta rotaciones en todos los ejes.
   
   
      ¿Por qué a veces se utiliza el acelerómetro para medir la rotación? Aunque es más complejo utilizarlo para rotaciones al incluir la gravedad en el mismo vector y no para todos los ejes, tiene un coste de proceso (leáse batería) muy inferior al giróscopo. Se puede decir que es un "hack" ya que no se utiliza para lo que fue diseñado.
   
   
      Por último, la posición sería detectada por el GPS.
   

Buenas noches. 
 
Me queda bastante más claro, pero aún así me parece un tema complejo. 
 
Creo que estoy enfocando mal el juego desde el principio. Rotar la gravedad con el acelerómetro me dio un resultado aceptable, pero surge un nuevo problema.
 
Cuando la pelota está en el aire, se puede seguir girando la gravedad, por lo que la pelota cambia la trayectoria. Es fácil de solucionar, sólo tengo que hacer que detecte cuando está tocando una base y entonces pueda rotar y cuando esté en el aire no, pero eso creo que no me sirve. Me resulta difícil de cabeza, está madrugada haré unas pruebas.
 
Un saludo 

 muchas gracias

Cita de: pioj date=1567356530¿Le ha explicado alguien la diferencia entre ACELERÓMETRO y GIROSCOPIO? Es importante para entender cómo funciona lo que trata de hacer...
   

Efectivamente hasta tu mensaje no lo distinguía.  De echo creo que aún no lo tengo claro. 
 
¿Acelerómetro detecta la posición del terminal y giroscopio es el encargado de hacerlo girar? 
 
¿Entonces lo estoy enfocando mal? 

Cita de: Deaymon date=1567206565Nota sobre esto: speedX cambia la gravedad de TODO, no solo la "velocidad" de la pelota, así que creo que deberías de dejar ese factor como un valor constante, ya sea 9.8f, que es el valor por defecto de la gravedad, o bien cambiarlo a otro valor que te dé mejor resultado (a no ser que quieras cambiar la fuerza de la gravedad a mitad de juego, en cuyo caso, no lo hagas constante, claro).
   
   
      En cualquier caso, si hasta ahora te ha funcionado decentemente ese enfoque, lo que haría yo sería
   
   

const float GRAVEDAD = 9.8f;
private void FixedUpdate() {
// Convertimos Input.acceleration.x del rango "-1 ~ 1" a "0 ~ π" radianes para simplificar cálculos
float angulo = (Input.acceleration.x + 1f) * Mathf.PI * 0.5f;
// Aplicamos trigonometría para "rotar" la gravedad
Physics2D.gravity = new Vector2( -Mathf.Cos(angulo), Mathf.Sin(angulo) ) * GRAVEDAD;
}

   
      EDIT: Sobre cambiar la fuerza de la gravedad a mitad de juego, puedes usar Rigidbody2D.gravityScale para cambiar cuánto afecta la gravedad a ese Rigidbody en particular.

      EDIT2: ¡Mathf.Sin(angulo) hará que la gravedad vaya hacia arriba! Ponle un '-' delante para invertirlo (xD Socorro, qué fallo más básico)
   

Si, en cuanto ha empezado a flotar la pelota hacia arriba me he dado cuenta, pero me ha servido para detectar que cuando el dispositivo android estaba del revés, la pelota no caía, y para ello he añadido este código:
 

float gradosY;
gradosY = Input.acceleration.y;
        if (gradosY < 0)
        {
            Physics2D.gravity = new Vector2(-Mathf.Cos(angulo), -Mathf.Sin(angulo)) * Gravedad;
        }
        else
        {
            Physics2D.gravity = new Vector2(-Mathf.Cos(angulo), Mathf.Sin(angulo)) * Gravedad;
        }

 
Muchas gracias

Muchas gracias a todos!!
 
De momento he logrado que funcione cambiando el FixedUpdate, que ahora contiene solo esta línea: 
 

Physics2D.gravity = new Vector3((Input.acceleration.x)* speedX, ejey, 0);

 
Así funciona, pero ahora me encuentro con varios problemas. De este modo la pelota queda sin gravedad, así que he creado una variable: "ejey" que utilizo en negativo para crear una falsa gravedad, y funciona bien, pero cuando aplico un physics2d materials para un pequeño rebote que quiero conseguir, pero queda continuamente vibrando la pelota. Si disminuyo el valor del eje Y no vibra la pelota, pero tarda mucho en bajar. 
 
Deaymon lo de los ejes me volvió loco ayer, pero al final me dí cuenta que efectivamente mis ejes no coincidían con los del acelerómetro. Fue cuestión de ir probando en los tres lugares del vector y con distintos ejes.
 
Mañana probaré el código de Lightbug,
 
Lo digo, muchísimas gracias a todos!!

Cita de: iRobb date=1567095469Más datos. Aparte de que el problema es de Newton y no nuestro
   
   
      Datos del rigidbody de la esfera. Cuando dices problema de acelerómetro, como lo utilizas? Código.
   
   
       
   

Haciendo pruebas el acelerómetro parece estar bien. Las pruebas las estoy realizando con un Samsung s5, conectado por medio de unity remote 5.
 
Este es el código (Si es que se puede llamar código) XD: 
 

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class BallMove : MonoBehaviour
{
    public float SpeedD = 40f;
    // Start is called before the first frame update
    void Start()
    {
        
    }
    // Update is called once per frame
    void Update()
    {
        transform.position += new Vector3(Input.acceleration.x * Time.deltaTime, 0, 0) * SpeedD;
    }
}

 
El Rigidbody tiene todos los datos conforme se crea, lo único que he modificado la masa, la escala de la gravedad y el Linear Drag sin éxito, por lo que lo he vuelto a dejar todo igual.
 
Creo que la solución va estar en rotar la gravedad, porque creo que es eso realmente lo que quiero.
 
Muchas gracias

Gracias zelleGAmes,
 
lo he probado, pero entonces lo que giro es la plataforma y no es lo que quiero.
 
un saludo,

Buenas tardes,
 
espero saber explicarme.
 
Soy muy novato, y estoy realizando pruebas para un juego que quiero hacer 2d para android con unity (en c #). Con el movimiento por teclas me resulta más fácil, pero ahora con el acelerómetro del teléfono estoy aún más perdido.
 
Os planteo la situación:
 
Una pelota y una rampa. Aplico rigibody 2d en la pelota, y un collaider para la rampa. Cuando comienza la aplicación, la pelota cae a la rampa y la gravedad hace el resto.
 
Si el acelerómetro maneja la pelota en el eje x funciona bien, pero cuando el móvil la rampa está totalmente horizontal, la pelota sigue actuando como si tuviese inclinación.
 
Adjunto a pequeños dibujos para aclarar el problema. La imagen 1 es conforme comienza el juego correctamente. La imagen 2 es con la base horizontal aún sigue habiendo gravedad. Edito el mensaje porque me acabo de dar cuenta que las imágenes 1 y 2 están cambiadas entre sí.
 
¿Será cosa del acelerómetro?
 
Creando los dibujos se me ha ocurrido una posible solución. Ir restando a la fuerza de la gravedad una cantidad limitada del ángulo de inclinación, pero no se si es posible.
 
Gracias anticipadas,
 

 

Buenas tardes,
 
estas vacaciones me ha dado de nuevo por el gusanillo de la programación en c#, pero a diferencia de otras veces, voy a ver si me centro en los videojuegos, y aprendo un poquillo. 
 
Buscando ayuda he llegado al foro. 
 
Nos vemos por aquí, 
 
Un saludo,