Cita de: hammer date=1476821573Ni idea de online asi que tampoco me hagas mucho caso xD, y si antes de cargar las respectivas escenas creas un gameobject con algun script donde guardar los datos que necesites con un DontDestroyOnLoad y luego cargas las diferentes escenas???Ese gameobject se mantendria entre la carga de escenas,hasta que lo destruyas tu,asi lo utilizarias como un manager de la partida y solo tendrias que tener sincronizado los datos de ese gameobject.
   
   
      Repito que n idea de online XD pero supongo que tendria que funcionar.
   
   
      Saludos!
   

Nah, de hecho es buena idea lo que me comentas, no lo había pensado. El único problema es que, luego ese script se tiene que relacionar con otros scripts y elementos de la escena. Pero como precisamente son 2 escenas diferentes con elementos diferentes, en cada una hay una cosa. ¿Me explico? El mismo script que permite a un jugador moverse por el mapa tendría que ser el mismo que mostrara la información del otro jugador en pantalla. Entonces todo sería el mismo script, y seria la misma escena... Pero buena idea, gracias. Seguro que dándole vueltas se puede lograr.
 
Igualmente, he logrado hacerlo bastante bien y fácil con el viejo sistema de RPC, me alegro mucho que Unity a pesar de nombrarlo obsoleto lo deje funcionando, ya que para cosas como estas me parece más simple este método. Me voy a quedar con este.

Al final lo estoy haciendo con el sistema viejo de RPC, que me avisa que está obsoleto pero sigue funcionando. Con ese sistema, es realmente fácil hacer lo que propongo, y no estoy teniendo ningún problema. Aún así me gustaría saber cómo hacerlo con el nuevo sistema.
 
Respondiendo a @iRobb, gracias pero todo lo que me has contestado ya lo sabía, pero no me contestas la pregunta de cómo hacerlo si estoy en escenas diferentes, con scripts diferentes.
 
Y a @juanma_teso, primero, necesito que estén en escenas separadas porque en una hay muchas cosas (suelo, player, objetos, muchos scripts etc) mientras que el otro está vacío, muestro la información por GUI, así que solo tengo una cámara con un script. Por supuesto puedo hacer que el cliente también tenga la escena del servidor y tapar la vista con el GUI, pero me parece estúpido que el cliente tenga que tener todos esos objetos innecesariamente, para nada... no es muy eficiente.
 
Para que entendáis mejor lo que quiero hacer, el juego es un buscaminas en 3D. Un jugador es un soldado que camina por un campo de tierra y tiene que llegar hasta la salida sin pisar ninguna mina. Lo que el otro jugador, su compañero, ve en pantalla es la cuadrícula resuelta del buscaminas, con los números y marcas donde hay minas. Cada uno no puede ver la pantalla del otro, así que el Client que ve la cuadrícula/mapa en su pantalla tiene que darle indicaciones al Server, que mueve al soldado 3D por el campo de minas, para que se mueva sin pisar ninguna.
 
Por lo que además, no necesito que el client y el server estén comunicándose y sincronizándose contínuamente, solo necesito que el servidor le envía una matriz (el campo de minas) al client al principio de la conexión y ya.
 
Es parecido al juego (no sé si lo conocéis) de desactivar una bomba, en que un jugador ve la bomba y el otro las instrucciones para desactivarla, y tienen que hablarse para lograrlo. La idea es la misma.

Lo que quiero hacer es en realidad muy simple, pero no encuentro la forma de hacerlo.
 
Estoy desarrollando un juego multijugador pero cada jugador se encuentra en una escena distinta con scripts diferentes. El juego consiste en que un jugador juega sin nada de información, y el otro jugador ve la información en su pantalla. Por lo que ambos tienen que hablar, sin poder ver la pantalla del otro, para poder ganar. Es un juego de colaboración.
 
Por lo tanto, necesito pasar valores del servidor al cliente, solo eso. Necesito enviarle una matriz de enteros al cliente. Que un script "s1" en la escena A del servidor llame a una función del script "s2" en la escena B del cliente, pasándole enteros. Nada complicado. Enviar ints de servidor a cliente es lo más básico.
 
Conocía el antiguo sistema de network de unity (llamadas RPC), pero ahora que han cambiado al nuevo sistema "UNET" toda la información que encuentro en internet es sobre sincronizar transforms para poder tener distintos players en una misma escena, como si quisiera hacer un Counter Strike, yo no quiero hacer nada de eso.
 
Así que, sabeis cómo enviar valores de servidor a cliente, que se encuentran en diferentes escenas con diferentes scripts?
 
Otra cosa que no me queda clara son las nuevas componentes: network manager, network identity, network transfrm... Cuáles necesito para hacer esto y dónde?
 
Gracias de antemano por la ayuda.

Estoy desarrollando un juego de geolocalización para android, es decir, que carga las coordenadas y el mapa de google, etc.
 
Funciona perfectamente, y la verdad es que me está quedando bien, todo perfecto. El problema que tengo es que cuando está buscando la localización, el juego se queda colgado, solo por 2-3 seg mientras busca las coordenadas, pero es molesto, obviamente. Además porque mi juego consulta cada 5 seg para ver si te has movido del sitio. Así que un juego que cada 5 seg se queda colgado... como que no.
 
Ya realizo la busca de coordenadas en una cuarentena, para que se haga en paralelo, pero aún así se queda colgado.
 
Si lo necesitáis, os pongo el código entero, pero de momento paso porque es mucho código. Pongo un resumen del algoritmo:
 

if (temporizador > 5f)
{
StartCoroutine(Refresh());
}
IEnumerator Refresh()
{
cargar coordenadas ();
if (está desactivado sistema gps)
   yield break;   // salir de la cuarentena
    while (no encuentra coordenadas && esperado < tiempoEspera)
    {
       yield new WaitForSeconds (1);
        ++ esperado          // contar los segundos esperados
    }
    if (esperado >= tiempoEspera)  // si se ha superado el tiempo de espera salir
      yield break;
      
    sacar coordendas y sacar distancia a coordenadas anteriores
    if (distancia > x) // te has movido lo suficiente
       cargar mapas de google
    else
      terminar (no hace faltar cargar los mapas si estamos en el mismo sitio)
}

 
Como veis, solo descargo los mapas de google de internet si me he movido de la posición, pero el juego se me queda colgado aunque no me mueva. Y sé que no los descarga, porque tengo booleanos por ahí puestos y ya lo he comprobado. Así que eso no es.
 
Es al cargar la posición, que la app se queda colgada hasta que la encuentre.

Ya lo había pensado, pero no. En Dialog no asigno jamás DialogEvents. Aparte, resulta que si hago algún cambio en las componentes del objeto, sí que me guarda la lista. Es decir, si hago algún cambio en la lista y luego al objeto le añado cualquier componente, un script, lo que sea. Al cerrar y abrir Unity sí se han guardado los cambios.
 
Así que de momento, hasta que averigüe que pasa, para guardar los cambios añado una componente cualquiera y luego se la quito.
 
Te enseñaría el código de Dialog, pero es largo y contiene muchas cosas más. Aun así si quieres verlo dímelo y te lo pongo. Pero Dialog solo accede a la lista, no la modifica.
 
 

Hola a todos!
 
Me llamo Oscar, soy de Valencia (Castellón más concreto) y estudio el grado de Diseño y Desarrollo de Videojuegos. Mi especialidad es la programación, aunque también toco lo demás (grafismo, 3D, etc) y hace años ya que uso Unity.
 
Bueno, encantado y espero poder colaborar en el foro!

Pues resulta que he hecho un script de Editor/Inspector de unity para hacer que una lista, que puede modificarse desde el inspector, sea ordenable. Para esto hay muchos tutoriales en internet. El script funciona bien, adjunto una imagen del inspector.
 
El problema es que al cerrar Unity y volver a abrirlo, los cambios han desaparecido, no se guardan. Es decir, cualquier cambio que le haga en la lista (añadir, quitar o modificar valores) se mantiene hasta que cierre Unity. Cuando vuelvo a abrir los cambios han desaparecido... Os dejo aquí el código, a ver si me podéis ayudar:
 

[CustomEditor(typeof(Dialog))]
public class DialogEventInspector : Editor {
    private ReorderableList reorderableList;
    private float[] sizes;
    private float[] steps;
    private float[] spaces;
    private Dialog dialog
    {
        get
        {
            return target as Dialog;
        }
    }
    private void OnEnable()
    {
        reorderableList = new ReorderableList(dialog.DialogEvents, typeof(DialogEvent), true, true, true, true);
        // for rects in draw
        sizes = new float[] { 0.19f, 0.19f, 0.19f, 0.08f, 0.03f, 0.18f, 0.08f};
        steps = new float[sizes.Length];
        float sum = 0.03f;
        for(int i = 0; i<sizes.Length; ++i)
        {
            steps = sum;
            sum += sizes;
 
        }
        spaces = new float[] { 0.5f, 0.8f, 0.85f, 0.55f, 0.23f, 0.4f, 0.45f};
        // Add listeners to draw events
        reorderableList.drawHeaderCallback += DrawHeader;
        reorderableList.drawElementCallback += DrawElement;
        reorderableList.onAddCallback += AddItem;
        reorderableList.onRemoveCallback += RemoveItem;
    }
    private void OnDisable()
    {
        // Make sure we don't get memory leaks etc.
        reorderableList.drawHeaderCallback -= DrawHeader;
        reorderableList.drawElementCallback -= DrawElement;
        reorderableList.onAddCallback -= AddItem;
        reorderableList.onRemoveCallback -= RemoveItem;
    }
    private void DrawHeader(Rect rect)
    {
        
        GUI.Label(rect, getSpaceOf(0, rect) + "Name" + getSpaceOf(1, rect) + "Type"+ getSpaceOf(2, rect) + "Item"+ getSpaceOf(3, rect)+"GT" + getSpaceOf(4, rect) + "N"+ getSpaceOf(5, rect) + "Text" + getSpaceOf(6, rect) + "Darken");
    }
    private string getSpaceOf(int i, Rect rect)
    {
        string space = "";
        int Spaces = (int)(rect.width / 20 * spaces);
        for (int k = 0; k < Spaces; ++k)
            space += ' ';
        return space;
    }
    private void DrawElement(Rect rect, int index, bool active, bool focused)
    {
        DialogEvent item = dialog.DialogEvents[index];
        EditorGUI.BeginChangeCheck();
        EditorGUI.LabelField(new Rect(rect.x, rect.y, rect.width * 0.03f, rect.height), index.ToString());
        item.Name = EditorGUI.TextField(new Rect(rect.x + steps[0]*rect.width, rect.y, sizes[0]*rect.width, rect.height), item.Name);
        item.eventType = (DialogEvent.EventType) EditorGUI.EnumPopup(new Rect(rect.x + steps[1]*rect.width, rect.y, rect.width*sizes[1], rect.height), item.eventType);
        item.Item = (DialogResource) EditorGUI.ObjectField(new Rect(rect.x + steps[2]*rect.width, rect.y, rect.width*sizes[2], rect.height), item.Item, typeof(DialogResource), true);
        item.GradualTime = EditorGUI.FloatField(new Rect(rect.x + steps[3] * rect.width, rect.y, rect.width * sizes[3] *0.75f, rect.height), item.GradualTime);
        item.PassToNext = EditorGUI.Toggle(new Rect(rect.x + steps[4] * rect.width, rect.y, rect.width * sizes[2], rect.height), item.PassToNext);
        item.Text = (DialogText)EditorGUI.ObjectField(new Rect(rect.x + steps[5] * rect.width, rect.y, rect.width * sizes[5], rect.height), item.Text, typeof(DialogText), true);
        item.Darken = EditorGUI.Toggle(new Rect(rect.x + steps[6] * rect.width*1.02f, rect.y, rect.width * sizes[6], rect.height), item.Darken);
        if (EditorGUI.EndChangeCheck())
        {
            EditorUtility.SetDirty(target);
        }
    }
    private void AddItem(ReorderableList list)
    {
        dialog.DialogEvents.Add(new DialogEvent());
        EditorUtility.SetDirty(target);
    }
    private void RemoveItem(ReorderableList list)
    {
        dialog.DialogEvents.RemoveAt(list.index);
        EditorUtility.SetDirty(target);
    }
    public override void OnInspectorGUI()
    {
        serializedObject.Update();
        base.OnInspectorGUI();
        // Actually draw the list in the inspector
        reorderableList.DoLayoutList();
        serializedObject.ApplyModifiedProperties();
    }
}