float x = ; //0 es exactamente es exactamente la bisectriz del primer y el tercer cuadrante de la grafica de arcocoseno.
Debug.Log(Mathf.Acos(x));
//Devolvera (1/2)π radianes, que es 1,57 radianes. que en grados es 0.
//Si X fuese 0.7, Devolveria (1/4)π radianes, que es 0,785 radianes. que son 45 grados.

   
      Compara dos valores de punto flotante si son similares.
Debido a la imprecisión del punto flotante no se recomienda comparar los flotantes usando el operador igual. p.ej. 1.0 == 10.0 / 10.0 puede no devolver true.
   

[/quote]

//En vez de:
if(1.0f == 10.0f / 10.0f)...
//Hacer esto:
if(Mathf.Aproximately( 1.0f, 10.0f / 10.0f )...

 
(Supongo que esto es mejor usarlo con valores float largos como pueda ser π.)
 
Mathf.Asin
 
Este metodo devuelve el arcoseno de un valor, Recordar que lo devuelve en Radianes.
 
Que es seno: Como con arcocoseno ya explique el coseno, con arcoseno explicare el seno.
 

 
el seno es la razon entre: El cateto opuesto (a) a dicho ángulo y la hipotenusa (c) en un triangulo rectangulo.
 
esto quiere decir que sen α = a / c  (La diferencia con coseno es que coseno usa cateto adyacente, y este usa el opuesto al ángulo)
 
donde α es el valor angular con un dominio de [0,π].
 
Esta es la grafica de seno:
 
Ahora que sabemos que es el seno: 
 

   
       
   
   
      La curva del coseno (antes vista) es la curva del seno desplazada π2{\displaystyle {\frac {\pi }{2}}} a la izquierda dando lugar a la siguiente expresión: 
   
   

         ${\displaystyle \cos \alpha =\operatorname {sen} \left(\alpha +{\frac {\pi }{2}}\right)}$
      

   

       
   

[/quote]

    

Que es Arcoseno: Al igual que arcocoseno es la funcion recíproca de coseno, arcoseno es la funcion recíproca de seno. Lo que quiere decir que: SI arcsen x = α ENTONCES sen α = x
 
recordar tambien que se escribe arcsen o sen^-1
 
Es el arco cuyo seno es α.
 
(Es como el espejo de arcocoseno antes explicado)
 
arcoseno restringe el dominio de la funcion seno a (x) [-1,1] donde su codominio (α) [-π/2, π/2].
 
Os mostrare ahora una imagen de como se comportan seno y arcoseno en una grafica:
 
La gráfica de la función arcoseno es simétrica a la de la función seno respecto a la recta bisectriz del primer y tercer cuadrante (y=x)
 

float x = .5f; //.5f es el equivalente a 1/2
   
Debug.Log(Mathf.Asin(x)); //Devolvera 1/6π radianes que es 0,52 y son 30 grados.

 
Mathf.Atan
 
El metodo devuelve en arcotangente de un valor, recordar que lo devuelve en radianes.
 
Que es la Tangente: La tangente la razon entre los catetos de un triangulo rectangulo.
 
tan α = a / b Siempre como dividendo es el cateto opuesto, y como divisor el cateto adyacente.
 
Vamos a recordar que sen α = a / c y que cos α = b / c por lo tanto la tangente de α se puede expresar como tan α = sen α / cos a
 

 
Para comprender el concepto de tangente, graficamente vista en la imagen anterior, imagina una linea que su punto 0 nace desde D y tiende a infinito.
 
El dominio de la tangente es (x) [-∞,∞], donde su codominio (α) [-π/2, π/2].
 
(Tranquilos esta funcion no estan necesaria en un principio como seno y coseno, asi que no os preocupeis si os resulta mas compleja)
 
 
 
Que es Arcotangente: En este caso es la función recíproca de tangente.
 

 
Al igual que con arcoseno y arcocoseno, arcotangente es el arco cuya tangente es α.
 
En notacion matematica se puede escribir arctan o tan^-1.
 
 
 
Uso con unity de estas funciones
 
Vale, ahora que sabemos la teoria, queda lo mas interesante que es la practica de estos conceptos en unity, y aplicaciones varias.
 
El metodo que utilizare para mostrar los ejemplos sera con imagenes y codigo para que veamos la facilidad del asunto. (Recordar tambien que el objetivo es entender estos conceptos, para que podais usarlos a vuestro libre albederio)
 
En este ejemplo, vamos a ver como saber los grados que tiene que rotar un objeto para mirar a otro. (Aunque esta funcion ya trae incorporada unity como Transform.LookAt() aquí explicare como funciona internamente)
 
Lo primero que hay que saber es como conseguir la distancia entre dos puntos del plano de unity. (Yo trabajare con Vectores de dos dimensiones, "Vector2")
 

Vector2.Distance(Vector2 a, Vector2 b); //Distancia entre los dos vectores.
//Es lo mismo que hacer:
Vector2 a = new Vector2(10, 11);
Vector2 b = new Vector2(5, 8);
float dist = (a - b).magnitude;
Debug.Log(dist);

 
Ahora en el proyecto creamos dos objetos, recuerdo que estoy trabajando en 2D, en 3D seria lo mismo pero jugando con Vector3, recordar que solo rotamos en el eje Y.
 

 
Como vemos he creado dos objetos en un plano bidimensional, son dos sprites, el azul llamado objeto1 su posicion es: X=0 Y=-3.5, el negro y rojo llamado objeto2 su posicion es X=4 Y=-1.
 
Como veis he dibujado un triangulo rectangulo a partir del punto A (Objeto1) y punto B (Objeto2) ahora tenemos la incognita de C que es sencilla, es la posicion Y de A y la posicion X de B
 
Para encontrar la posición de C en Unity:
 

public Transform A, B;
//Aqui añadiremos los objetos de nuestra escena desde el inspector.
void Start () {
  Vector2 C = new Vector2(B.position.x, A.position.y); //C es la posicion X del objeto2 y la posicion Y del objeto 1
}

 
Ahora ya tenemos los 3 puntos de nuestro triangulo imaginario. Ahora hay que saber la distancia de h, de ca y de co
 
Aunque para sacar el coseno que es lo que necesitamos, no nos hacefalta co, ya que solo necesitamos cateto adyacente e hipotenusa.
 

public Transform A, B;
//Aqui añadiremos los objetos de nuestra escena desde el inspector.
void Start () {
   Vector2 C = new Vector2(B.position.x, A.position.y); //C es la posicion X del objeto2 y la posicion Y del objeto 1
   
   float h = (A.position - B.position).magnitude; //Distancia de hipotenusa
   float ca = (new Vector2(A.position.x, A.position.y) - C).magnitude; //distancia cateto adyacente
   float co = (new Vector2(B.position.x, B.position.y) - C).magnitude; //distancia cateto opuesto.
}

 
Sacaremos ahora el coseno del triangulo, para que nos de los radianes.
 

public Transform A, B;
//Aqui añadiremos los objetos de nuestra escena desde el inspector.
void Start () {
   Vector2 C = new Vector2(B.position.x, A.position.y); //C es la posicion X del objeto2 y la posicion Y del objeto 1
   
   float h = (A.position - B.position).magnitude; //Distancia de hipotenusa
   float ca = (new Vector2(A.position.x, A.position.y) - C).magnitude; //distancia cateto adyacente
   float co = (new Vector2(B.position.x, B.position.y) - C).magnitude; //distancia cateto opuesto.
   //Sabiendo que; cos α = ca / h
   float a = ca / h; //Ya tenemos alfa.
   float rad = Mathf.Cos(a); //ahora sacamos con Mathf el coseno de alfa y lo pasamos a una variable float, que sera el valor en radianes.
   Debug.Log(rad); //Nos dara 0.66
}

 
Vale ahora tenemos el valor en radianes, ahora lo pasaremos a grados.
 

public Transform A, B;
//Aqui añadiremos los objetos de nuestra escena desde el inspector.
void Start () {
   Vector2 C = new Vector2(B.position.x, A.position.y); //C es la posicion X del objeto2 y la posicion Y del objeto 1
   
   float h = (A.position - B.position).magnitude; //Distancia de hipotenusa
   float ca = (new Vector2(A.position.x, A.position.y) - C).magnitude; //distancia cateto adyacente
   float co = (new Vector2(B.position.x, B.position.y) - C).magnitude; //distancia cateto opuesto.
   //Sabiendo que; cos α = ca / h
   float a = ca / h; //Ya tenemos alfa.
   float rad = Mathf.Cos(a); //ahora sacamos con Mathf el coseno de alfa y lo pasamos a una variable float, que sera el valor en radianes.
   
   //Para pasar de radianes a grados es aplicar la regla de 3
   //-> Pi / 180 = rad / X despejamos la x
   // y la ecuacion es-> x=180*rad/Pi 
   float grados = (180 * rad) / Mathf.PI;
   Debug.Log(grados);
}

 
No os equivoqueis por que estos no son los grados que hay que rotar, estos son los a los que se encuentra el punto B respecto al punto A, os muestro una imagen para que lo comprendais.
 

 
Si nuestro sprite mirase a la derecha por defecto (que es donde comienda el grado 0) entonces 37.9 grados serian los que tendria que rotar a su izquierda, pero nosotros tenemos el offset de 90 grados por que nuestro sprite mira hacia arriba. (Por eso hay que hacer un pequeño arreglo)
 
Y ahora si por fin lo rotaremos lo necesario para que mire hacia el otro objeto.
 

void Start () {
   Vector2 C = new Vector2(B.position.x, A.position.y); //C es la posicion X del objeto2 y la posicion Y del objeto 1
   
   float h = (A.position - B.position).magnitude; //Distancia de hipotenusa
   float ca = (new Vector2(A.position.x, A.position.y) - C).magnitude; //distancia cateto adyacente
   float co = (new Vector2(B.position.x, B.position.y) - C).magnitude; //distancia cateto opuesto.
   //Sabiendo que; cos α = ca / h
   float a = ca / h; //Ya tenemos alfa.
   float rad = Mathf.Cos(a); //ahora sacamos con Mathf el coseno de alfa y lo pasamos a una variable float, que sera el valor en radianes.
   
   //Para pasar de radianes a grados es aplicar la regla de 3
   //-> Pi / 180 = rad / X despejamos la x
   // y la ecuacion es-> x=180*rad/Pi 
   float grados = (180 * rad) / Mathf.PI;
   
   float offset = 90; //Este es el offset de nuestro sprite, por que por defecto deberia de mirar a izquierda y no arriba.
   //Ahora ya si, lo rotamos
   A.Rotate(new Vector3(,,-(offset-grados)));
}

 
Recordar que el offset cambia segun si esta a izquierda o derecha de nosotros, tambien segun este arriba o abajo.
 
Esto es un ejemplo de una de las muchas utilidades de la trigonometría en los videojuegos, esta claro que para muchos unity ya da herramientas, pero para otros no, por eso estos conceptos son necesarios saberlos.
 
Un saludo y espero que les sirva esta pequeña explicación!