Cita de: ProgramacionWH date=1487199054Pues nada no actualizaremos a partir de la 5. y sino tiraremos de "versiones no tan oficiales"
Vamos... un buen crack no? jajajaja
Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
Mostrar Mensajes MenúCita de: ProgramacionWH date=1487199054Pues nada no actualizaremos a partir de la 5. y sino tiraremos de "versiones no tan oficiales"
Cita de: lightbug date=1487203627Muchas gracias, lindo aporte, bien completo, al parecer es bastante sencillo usar plugins en Unity, te pregunto: por que usas los gameobjects referenciados cuando pones el componente PluginsLoader en un gameObject? osea, podrias usar directamente gameObject si quisieras (algo como "this.gameObject"), pregunto porq nunca trabaje con plugins.
Me gusto el plugin del ++ xD.
En que caso pensas que seria util e indispensable utilizar plugins? se que se puede implementar plugins en C++ lo cual tiene como objetivo obvio mejorar sectores en los que la performance es un problema y no alcanza con c# y su garbage collector.
using System;
using System.Reflection;
namespace APILoader
{
public static class Loader
{
}
}
using System;
using System.Reflection;
using System.IO;
using System.Collections.Generic;
namespace APILoader
{
/*Dentro de cada plugin podra habra dos funciones obligatorias que seran llamadas al inicio del juego y en cada frame
* igual que haces en unity en void Start y void Update, nosotros haremos lo mismo con nuestros plugins
*/
public delegate void FunctionAtStart();//Creamos los delegados para añadir esas funciones y llamarlas cuando queramos.
public delegate void FunctionAtUpdate();
public static class Loader
{
public static FunctionAtStart callAtStart;//Instanciamos los delegados
public static FunctionAtUpdate callAtUpdate;
//Ruta de la carpeta donde guardaremos los plugins en este caso es: donde se ejecute el programa + \Plugins\
public static string _PATH = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) + "\\Plugins\\";
public static void LoadExternalAssembled()
{
foreach (var eAssemb in Directory.GetFiles(_PATH)) //Hacemos un bucle para cargar todos los plugins de la carpeta
{
Assembly _current = Assembly.LoadFile(eAssemb);//Cargamos el plugin
Type _typeof = _current.GetType("Plugin.External"); //Donde Plugin es el nombre el namespace del plugin y
//external es la clase del plugin que cargaremos nosotros
_typeof.GetMethod("load").Invoke(Activator.CreateInstance(_typeof), null);
//Cargaremos la funcion load dentro del plugin, para que este se añada a los delegados y asi se ejecute segun corresponda
}
}
}
}
using System;
using UnityEngine;
namespace API
{
class Functions
{
}
}
using System;
using System.Collections.Generic;
using UnityEngine;
namespace API
{
public static class Functions
{
public static List<GameObject> reference; //Imaginaros que quereis hacer que el jugador tenga funciones en api
//Lo añadiriamos desde unity aqui, para que cualquier plugin pueda hacerle
//referencia. (Hare una funcion como ejemplo)
public static GameObject getReference(string name) //retornara el gameobject segun un nombre si existe en la lista.
{
return reference.Find(g => g.name == name);
}
public static void changeColorOfMaterial(GameObject go, Color newColor)
{
go.GetComponent<Renderer>().material.color = newColor;
//Esta funcion la usaremos para buscar un objeto en la lista "reference" y cambiarle el color.
}
public static void IntegerPlusPlus(ref int i)
{
i++;
//Esta funcion incrementa 1 a la variable que le pasemos, la llamaremos dentro del update del plugin para
//que veamos como se ejecuta.
}
public static string sayHelloWord()
{
return @"Hello World from APi"; //Esta es sencilla, solo retorna ese string.
}
}
}
using UnityEngine;
using APILoader; //AQUI ESTOY LLAMANDO AL DLL QUE HEMOS CREADO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
public class pluginsLoader : MonoBehaviour {
void Awake ()
{
Loader.LoadExternalAssembled(); //Llamamos a nuestra funcion creada dentro del dll para que cargue los plugins.
}
void Start () {
Loader.callAtStart(); //Aqui estamos llamando a las funciones de los plugins start.
}
void Update () {
Loader.callAtUpdate(); //Aqui llamamos a las funciones de los plugins update.
}
}
using UnityEngine;
using System.Collections.Generic;
using APILoader; //AQUI ESTOY LLAMANDO AL DLL QUE HEMOS CREADO!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
using API;
public class pluginsLoader : MonoBehaviour {
public GameObject[] prefabsToReference;
void Awake ()
{
Loader.LoadExternalAssembled(); //Llamamos a nuestra funcion creada dentro del dll para que cargue los plugins.
Functions.reference = new List<GameObject>();
Functions.reference.AddRange(prefabsToReference);
}
void Start () {
Loader.callAtStart(); //Aqui estamos llamando a las funciones de los plugins start.
}
void Update () {
Loader.callAtUpdate(); //Aqui llamamos a las funciones de los plugins update.
}
}

using API;
using APILoader;
using UnityEngine;
namespace Plugin //Si recuerdan en el primer DLL para unity, dijimos que el nombre de espacios seria Plugin, y la clase External
{//Si ustedes quieren cambiar estos datos, para que el nombre de espacios sea otro, tambien tienen que cambiarlo en la DLL de API
public class External
{
static int i;
public static void load()//Esta funcion es llamada desde el juego.
{
APILoader.Loader.callAtStart += start; //Y aqui añadimos las funciones a los delegados de nuestra api para que puedan ser
APILoader.Loader.callAtUpdate += update;// llamadas a su momento.
}
static void start()//PONEMOS EN STATIC!!
{
API.Functions.changeColorOfMaterial(API.Functions.getReference("cubito"), Color.red);
//Al comienzo de la escena, cambiara el color de cubito a rojo, si recordais, añadimos cubito a la referencia de objetos de la api
}
static void update()
{
i++;
if(i>100)//Pasados 100 frames el cubo sera azul!
API.Functions.changeColorOfMaterial(API.Functions.getReference("cubito"), Color.blue);
}
}
}

Color c = GetComponent<Renderer>().material.color;
c.a = 0.0f; //aqui pones 1 o 0
GetComponent<Renderer>().material.color = c;
Debug.Log(Mathf.Abs(-2045.34f));
//Vemos que estamos pasando el valor -2045.34f, el valor retornado sera 2045.34
//Si el valor que le pasamos a Mathf.Abs() es -10, este nos retornara 10.
//En definicion, Abs retornara el valor positivo.
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 desplazadaa la izquierda dando lugar a la siguiente expresión:
[/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!