Hola muchachos, bueno basicamente necesito que me tiren algunos tips de como me puede comunicar con otros scripts, a lo que me refiero con esto, es a manejar variables de un script en particular de un GameObject por ejemplo, bueno yo no soy tan novato, reconosco que puedo instanciar un GameObject creando una variable que almacene mi GameObject, pero lo que me esta costando, es el poder comunicarme con determinado script de ese GameObject que yo tenga almacenado en una variable, y poder mani***rlo comodo, y sin gastar mucho requisito en esa comunicacion....
 
No me quedo muy claro, pero estube revisando y los GetComponent<>() gastan bastante requisito, o estoy equivocado?, porfavor aclarenme eso, no estoy seguro, el GameObjectFind tengo entendido que si ese gasta mucho ya que revisa todo lode la escena.
 
Bueno en fin, miren aca tengo un ejemplo, esto es lo que hago con lo que yo se hasta ahora....
 

   public ParticleSystem particleSys;
private RaycastHit hitInfo;
private const float rayDistance = 0.3f;
private const float resetTime = 1.3f;
private void Update() {
   NewRayCast(Vector3.forward);
   NewRayCast(Vector3.back);
   NewRayCast(Vector3.right);
   NewRayCast(Vector3.left);
   NewRayCast(Vector3.up);
   NewRayCast(Vector3.down);
}
private void NewRayCast(Vector3 dir) {
   if (Physics.Raycast(new Ray(transform.position, dir), out hitInfo, rayDistance)) {
      OnCrush();
   }
}
private void OnCrush() {
   if (hitInfo.collider.name.Substring(, 7) == "Barrier" ||
      hitInfo.collider.name.Substring(, 5) == "Inner") 
   {
      // Ignore Raycast
   } else {
      if (transform.gameObject.GetComponent<MeshRenderer>().enabled == true)
         _OnCrush();
   }
}
private void _OnCrush() {
   particleSys.transform.position = transform.position;
   particleSys.Play();
   transform.gameObject.GetComponent<Player_Movement>().noMove = true;
   transform.gameObject.GetComponent<Player_Movement>().isRotate = false;
   transform.gameObject.GetComponent<Rigidbody>().isKinematic = true;
   transform.gameObject.GetComponent<MeshRenderer>().enabled = false;
   StartCoroutine("_Reset");
}
private IEnumerator _Reset() {
   yield return new WaitForSeconds(resetTime);
   Debug.Log("Reset");
   transform.gameObject.GetComponent<Player_Movement>().ResetCrush();
   transform.gameObject.GetComponent<Player_Movement>().noMove = false;
//      transform.gameObject.GetComponent<Rigidbody>().isKinematic = false;
   transform.gameObject.GetComponent<MeshRenderer>().enabled = true;
}

 
Bueno no hace falta que lo entiendan del todo al script, solo miren mi consulta, fijense como uso todos esos GetComponent, y no estoy seguro si lo estoy haciendo bien...
 
En este caso, este script va en mi target(objetivo) osea que no es necesario almacenar en una variable mi GameObject por que es este script es un componente mas de mi objecto a mani***r, entonces:
El "transform.gameObject" vendria a ser la "variable" tipo GameObject que podria yo crear para almacenar mi transform.gameObject, tipo un "GameObject targetPlayer" y escribir "targetPlayer".GetCom.... bla bla, en fin.
 
La cuestion NECESITO que me aclaren si lo estoy haciendo bien, si esto no es para nada practico, esto afeecta mucho el rendimiento? en el caso de ser asi, como puedo mejorarlo?, muchos me van a decir que puedo crear variables con un targetPlayer.GetComponent<>() pero de que tipo son esas variables? siempre me dan error nose si son tipo gameobject nose como llamar a las variables igual a GetComponent.
 
En el caso de crear variables especificas para ese GetComponent, cambia mucho el rendimiento o algo?
O es simplemente comodidad? para escribir menos codigo? tipo un copiar pegar escrita en un "targetPlayerMiScript"
 
De paso les deje un invento de Ignore cast bastante ingenioso  nombrando gameobject que quieran ignorar con esos nombres al principio, muy recomendado jajaja.
 
Abrazo, espero que me saquen dudas y ayuden, gracias!

Si recoges las variables de esos GameObjects ANTES del bucle principal, por ejemplo, dentro del Start(), no tendrás problemas de rendimiento. Por lo general lo más rápido es:
 
1.Recoge/Asigna la variable a un valor: 
 

   
      //
      string mitexto =  hitInfo.collider.name.Substring(0, 7);
      //
      MeshRenderer mimeshrenderer = transform.gameObject.GetComponent<MeshRenderer>();
   

[/quote]
 
2.Evalúa ese valor: Si es null, si es "tal valor", si alguna de sus propiedades ha cambiado, etc etc...

Cita de: enelmenu date=1500593262No me quedo muy claro, pero estube revisando y los GetComponent<>() gastan bastante requisito, o estoy equivocado?,
   

Si lo usas cuadro a cuadro si, no te va a romper el juego pero es preferible hacer caching que es como dice pioj, tener la referencia antes de entrar en los bucles (update,fixedupdate,etc).
 
 
 
Fijate que podes hacer esto:
 

gameObject.GetComponent<Player_Movement>();

 
 
 

Cita de: enelmenu date=1500593262La cuestion NECESITO que me aclaren si lo estoy haciendo bien, si esto no es para nada practico, esto afeecta mucho el rendimiento? en el caso de ser asi, como puedo mejorarlo?, muchos me van a decir que puedo crear variables con un targetPlayer.GetComponent<>() pero de que tipo son esas variables? siempre me dan error nose si son tipo gameobject nose como llamar a las variables igual a GetComponent.
   

https://docs.unity3d.com/ScriptReference/Component.GetComponent.html
 
getcomponent es un metodo publico de la clase COmponent que devuelve un tipo especifico:
 


      
   

"GetComponent

Returns the component of Type type if the game object has one attached, null if it doesn't".

Recorre todos los componentes del gameObject y te devuelve la referencia al componente que pedis si existe, pero los recorre a todos.
 
Tan simple como leer la documentacion, te esta diciendo que retorna, es decir que si haces un GetComponent<Pepe>() te va a devolver un tipo Pepe.
 

Cita de: enelmenu date=1500593262De paso les deje un invento de Ignore cast bastante ingenioso  nombrando gameobject que quieran ignorar con esos nombres al principio, muy recomendado jajaja.
   

Ingenioso, quizas, pero cero practico, tenes que hacer uso de las layers (no de los tags!) para discriminar colisiones, por dos grandes motivos, orden y eficiencia. Cuando seteas la correcta matriz de colisiones(o separas y especificas una layermask) estas diciendo al motor fisico "mira amigo motor, no me hagas colisiones para las 32 capas, mas vale si sos capa player podes colisionar solo con estas dos capas y nada mas", matas a dos grandisimos pajaros de un tiro de Magnum Sniper AWP
 
Tene cuidado cuando usas nombres porque si haces un cast en un objeto que se llame "Pepe" vas a hacerle un Substring(, 7), --> null reference seguro. Yo te diria que elimines todo lo relacionado a nombres, las strings usalas solo para informacion como nombres y datos estadsisticos, cosas asi, pero no a la hora de chequear un raycast ni nada te diria, es mucho riesgo y te encasilla en una forma de hacer las cosas.
 
Una anecdota, una vez hice un programa servidor-cliente con consola para un profesor de la facultad(sistemas operativos y redes era la materia), el primer argumento era un numero, el tipo agarro y de argumento puso "7835y48q77hsdhf", el programa se quebró, desaprobado, es decir que el paso 1 todo estaba mal porque no pense en las tipicas pifias que se puede mandar el usuario o yo mismo, ya se que esto es diferente, el desarrollador sos vos pero estas magnificando las probabilidades de error al cuete.
 
Ja siempre en tus post me voy de mambo

como bien a dicho pioj, asigna el componente a un atributo del script en vez de hacer getcomponent todo el tiempo, incluso si tienes que recojer otro componente de la misma clase, de otro objeto puedes sobre escribir
 
el anterior, pero vigila en recordar cada vez cual estas usando xD

@lightbug Muchas gracias!
 
Siempre me haces ver bien a la API y sacrle ese jugito que tiene Juan,
 
yo a la primera q lo leo nunca lo cazo del todo jajajaja tengo que dejar de enrroscarme mal, soy muy complicado aveces, ir mas a lo concreto y a la cuestion por que posta que en la API esta todo, hay que saber verlo jajajaja
 
Bueno me quedo bastante claro. Yo pensaba que lo de almacenar una variable con un return Component, era tipo copiar y pegar codigo, por el solo echo de envez de ver tantos GetComponents, ver "targetPlayerMove" "targetPlayerMeshRenderer" etc etc, eso por lo que entendi no solo da comodidad, sino que almacena cierto cachesito que cuando lo usas no llamas una y otra ves el metodo de formas totalmente paralelas, sino que llamas la variable almacenada, cosa que lo veo mucho mas razonable, bien, la clave esta en almacenar cache de informacion para reusarla como corresponde y que fluya mas todo.
 

Cita de: lightbug date=1500638029el tipo agarro y de argumento puso "7835y48q77hsdhf"
   

Jajajaja de la cara culeaaa, encima re boludo el error, hay que pensar en esas cosas siempree jaajajaja que boludoo adfasdfasdkfj
 

Cita de: lightbug date=1500638029siempre en tus post me voy de mambo
   

Pasa que mis post son muy clave ahh jajajajaja tiro preguntas picantessss 
 
Buenisimo! Abarzo enorme!