Ejemplo n.º 1
0
 public void EnqueueMessage(rdtTcpMessage message)
 {
     if (this.m_writeThread != null)
     {
         this.m_writeThread.EnqueueMessage(message);
     }
 }
Ejemplo n.º 2
0
        private void OnReadMessage(rdtTcpMessage message)
        {
            if (message is rdtTcpMessageLog)
            {
                rdtTcpMessageLog log = (rdtTcpMessageLog)message;
                switch (log.m_logType)
                {
                case LogType.Error:
                    Debug.LogError(log);
                    break;

                case LogType.Assert:
                    Debug.LogError(log);
                    break;

                case LogType.Warning:
                    Debug.LogWarning(log);
                    break;

                case LogType.Log:
                    Debug.Log(log);
                    break;

                case LogType.Exception:
                    Debug.LogError(log);
                    break;
                }
            }
            if (this.m_messageCallbacks.ContainsKey(message.GetType()))
            {
                this.m_messageCallbacks[message.GetType()](message);
            }
        }
Ejemplo n.º 3
0
 private void OnReadMessage(rdtTcpMessage message)
 {
     if (this.m_messageCallbacks.ContainsKey(message.GetType()))
     {
         this.m_messagesToProcess.Add(message);
     }
 }
Ejemplo n.º 4
0
        private void OnUpdateComponentProperties(rdtTcpMessage message)
        {
            rdtDebug.Debug(this, "OnUpdateComponentProperties", new object[0]);
            rdtTcpMessageUpdateComponentProperties properties = (rdtTcpMessageUpdateComponentProperties)message;
            GameObject gob = this.FindGameObject(properties.m_gameObjectInstanceId);

            if (gob != null)
            {
                UnityEngine.Component owner = this.FindComponent(gob, properties.m_componentInstanceId);
                if (owner == null)
                {
                    rdtDebug.Error(this, "Tried to update component with id {0} (name={1}) but couldn't find it!", new object[] { properties.m_componentInstanceId, properties.m_componentName });
                }
                else
                {
                    if (owner is Behaviour)
                    {
                        ((Behaviour)owner).enabled = properties.m_enabled;
                    }
                    else if (owner is Renderer)
                    {
                        ((Renderer)owner).enabled = properties.m_enabled;
                    }
                    else if (owner is Collider)
                    {
                        ((Collider)owner).enabled = properties.m_enabled;
                    }
                    if (properties.m_properties != null)
                    {
                        this.m_server.SerializerRegistry.WriteAllFields(owner, properties.m_properties);
                    }
                }
            }
        }
Ejemplo n.º 5
0
        private void OnMessageGameObjectComponents(rdtTcpMessage message)
        {
            this.m_components = new rdtTcpMessageComponents?((rdtTcpMessageComponents)message);
            List <rdtTcpMessageComponents.Component> components = this.m_components.Value.m_components;

            for (int i = 0; i < components.Count; i++)
            {
                rdtTcpMessageComponents.Component component = components[i];
                if (component.m_properties == null)
                {
                    rdtDebug.Debug(this, "Component '{0}' has no properties", new object[] { component.m_name });
                }
                else
                {
                    for (int j = 0; j < component.m_properties.Count; j++)
                    {
                        rdtTcpMessageComponents.Property property = component.m_properties[j];
                        property.Deserialise(this.m_serializerRegistry);
                        component.m_properties[j] = property;
                    }
                    components[i] = component;
                }
            }
            base.Repaint();
        }
Ejemplo n.º 6
0
        private void OnUpdateGameObjectProperties(rdtTcpMessage message)
        {
            rdtTcpMessageUpdateGameObjectProperties properties = (rdtTcpMessageUpdateGameObjectProperties)message;
            GameObject obj2 = this.FindGameObject(properties.m_instanceId);

            if (obj2 != null)
            {
                obj2.SetActive(properties.m_enabled);
                obj2.layer = properties.m_layer;
                obj2.tag   = properties.m_tag;
            }
        }
Ejemplo n.º 7
0
 public void EnqueueMessage(rdtTcpMessage message)
 {
     lock (this.m_messageQueue)
     {
         using (MemoryStream stream = new MemoryStream())
         {
             new BinaryFormatter().Serialize(stream, message);
             byte[] item = stream.ToArray();
             this.m_messageQueue.Enqueue(item);
         }
     }
     this.m_event.Set();
 }
Ejemplo n.º 8
0
 private void OnConnected()
 {
     if (this.m_listener.Pending())
     {
         this.m_listener.AcceptTcpClient().Close();
     }
     if ((!this.m_client.Connected || !this.m_readThread.IsConnected) || !this.m_writeThread.IsConnected)
     {
         this.SetState(State.Disconnected);
     }
     else
     {
         this.m_dispatcher.Update();
         bool flag  = false;
         bool flag2 = false;
         for (int i = 0; i < this.m_messagesToProcess.Count; i++)
         {
             System.Type type = this.m_messagesToProcess[i].GetType();
             if (type == typeof(rdtTcpMessageGetGameObjects))
             {
                 if (flag)
                 {
                     this.m_messagesToProcess.RemoveAt(i);
                     i--;
                 }
                 else
                 {
                     flag = true;
                 }
             }
             else if (type == typeof(rdtTcpMessageGetComponents))
             {
                 if (flag2)
                 {
                     this.m_messagesToProcess.RemoveAt(i);
                     i--;
                 }
                 else
                 {
                     flag2 = true;
                 }
             }
         }
         while (this.m_messagesToProcess.Count > 0)
         {
             rdtTcpMessage message2 = this.m_messagesToProcess[0];
             this.m_messagesToProcess.RemoveAt(0);
             this.m_messageCallbacks[message2.GetType()](message2);
         }
     }
 }
Ejemplo n.º 9
0
        private void OnMessageGameObjects(rdtTcpMessage message)
        {
            rdtTcpMessageGameObjects objects = (rdtTcpMessageGameObjects)message;

            this.m_gameObjects = objects.m_allGobs;
            this.m_tree.Clear();
            this.BuildTree();
            if (this.m_selected.HasValue)
            {
                this.m_tree.SetSelected(this.m_selected.Value, true, false, false);
            }
            else
            {
                this.m_tree.ClearSelected(true, false, false);
            }
            base.Repaint();
        }
Ejemplo n.º 10
0
        private void OnRequestGameObjects(rdtTcpMessage message)
        {
            rdtTcpMessageGameObjects objects = new rdtTcpMessageGameObjects();

#if UNITY_5
            Scene activeScene = SceneManager.GetActiveScene();
            if (activeScene.rootCount > this.m_gameObjects.Capacity)
            {
                this.m_gameObjects.Capacity = activeScene.rootCount;
            }
            this.m_gameObjects.Clear();
            activeScene.GetRootGameObjects(this.m_gameObjects);
#else
            m_gameObjects.Clear();
            Transform[] allTrans = GameObject.FindObjectsOfType <Transform>();
            for (int ii = 0; ii < allTrans.Length; ++ii)
            {
                Transform tran = allTrans[ii];
                if (tran.parent != null)
                {
                    continue;
                }
                m_gameObjects.Add(tran.gameObject);
            }
#endif
            int count = this.m_gameObjects.Count;
            List <GameObject> gameObjects = this.m_gameObjects;
            if (count > this.m_allGobs.Capacity)
            {
                this.m_allGobs.Capacity = count;
            }
            this.m_allGobs.Clear();
            for (int i = 0; i < count; i++)
            {
                GameObject g = gameObjects[i];
                if ((g.hideFlags == HideFlags.None) && (g.transform.hideFlags == HideFlags.None))
                {
                    this.AddGameObject(g, this.m_allGobs);
                }
            }
            objects.m_allGobs = this.m_allGobs;
            this.m_server.EnqueueMessage(objects);
            this.m_gameObjects.Clear();
        }
Ejemplo n.º 11
0
 private void OnReading()
 {
     try
     {
         bool   flag   = true;
         int    count  = this.m_reader.ReadInt32();
         byte[] buffer = this.m_reader.ReadBytes(count);
         flag = false;
         using (MemoryStream stream = new MemoryStream(buffer))
         {
             Action          action    = null;
             BinaryFormatter formatter = new BinaryFormatter();
             rdtTcpMessage   message   = formatter.Deserialize(stream) as rdtTcpMessage;
             if (message != null)
             {
                 if (action == null)
                 {
                     action = delegate {
                         this.m_callback(message);
                     };
                 }
                 this.m_dispatcher.Enqueue(action);
             }
             else
             {
                 rdtDebug.Error(this, "Ignoring invalid message", new object[0]);
             }
         }
         if (flag)
         {
             this.m_state = State.LostConnection;
         }
     }
     catch (SocketException exception)
     {
         rdtDebug.Log(this, exception, rdtDebug.LogLevel.Debug, "{0} socket exception", new object[] { this.m_name });
         rdtDebug.Debug(this, "{3} ErrorCode={0} SocketErrorCode={1} NativeErrorCode={2}", new object[] { exception.ErrorCode, exception.SocketErrorCode, exception.NativeErrorCode, this.m_name });
         this.m_state = State.LostConnection;
     }
     catch (IOException exception2)
     {
         SocketException innerException = exception2.InnerException as SocketException;
         if (innerException != null)
         {
             rdtDebug.Log(this, innerException, rdtDebug.LogLevel.Debug, "{0} socket exception", new object[] { this.m_name });
             rdtDebug.Debug(this, "{3} ErrorCode={0} SocketErrorCode={1} NativeErrorCode={2}", new object[] { innerException.ErrorCode, innerException.SocketErrorCode, innerException.NativeErrorCode, this.m_name });
         }
         else
         {
             rdtDebug.Log(this, exception2, rdtDebug.LogLevel.Debug, "{0} thread lost connection", new object[] { this.m_name });
         }
         this.m_state = State.LostConnection;
     }
     catch (ObjectDisposedException)
     {
         rdtDebug.Debug(this, "{0} thread object disposed, lost connection", new object[] { this.m_name });
         this.m_state = State.LostConnection;
     }
     catch (Exception exception4)
     {
         rdtDebug.Error(this, exception4, "{0} thread unknown exception", new object[] { this.m_name });
     }
 }
Ejemplo n.º 12
0
        private void OnRequestGameObjectComponents(rdtTcpMessage message)
        {
            rdtTcpMessageGetComponents components = (rdtTcpMessageGetComponents)message;

            if (components.m_instanceId != 0)
            {
                GameObject obj2 = this.FindGameObject(components.m_instanceId);
                if (obj2 != null)
                {
                    rdtTcpMessageComponents components2 = new rdtTcpMessageComponents();
                    components2.m_instanceId = components.m_instanceId;
                    components2.m_components = new List <rdtTcpMessageComponents.Component>();
                    components2.m_layer      = obj2.layer;
                    components2.m_tag        = obj2.tag;
                    components2.m_enabled    = obj2.activeSelf;
                    this.m_components.Clear();
                    obj2.GetComponents <UnityEngine.Component>(this.m_unityComponents);
                    if (this.m_unityComponents.Count > this.m_components.Capacity)
                    {
                        this.m_components.Capacity = this.m_unityComponents.Count;
                    }
                    for (int i = 0; i < this.m_unityComponents.Count; i++)
                    {
                        UnityEngine.Component owner = this.m_unityComponents[i];
                        if (owner == null)
                        {
                            rdtDebug.Debug(this, "Component is null, skipping", new object[0]);
                        }
                        else
                        {
                            List <rdtTcpMessageComponents.Property> list = this.m_server.SerializerRegistry.ReadAllFields(owner);
                            if (list == null)
                            {
                                rdtDebug.Debug(this, "Properties are null, skipping", new object[0]);
                            }
                            else
                            {
                                rdtTcpMessageComponents.Component item = new rdtTcpMessageComponents.Component();
                                if (owner is Behaviour)
                                {
                                    item.m_canBeDisabled = true;
                                    item.m_enabled       = ((Behaviour)owner).enabled;
                                }
                                else if (owner is Renderer)
                                {
                                    item.m_canBeDisabled = true;
                                    item.m_enabled       = ((Renderer)owner).enabled;
                                }
                                else if (owner is Collider)
                                {
                                    item.m_canBeDisabled = true;
                                    item.m_enabled       = ((Collider)owner).enabled;
                                }
                                else
                                {
                                    item.m_canBeDisabled = false;
                                    item.m_enabled       = true;
                                }
                                System.Type type = owner.GetType();
                                item.m_name         = type.Name;
                                item.m_assemblyName = type.AssemblyQualifiedName;
                                item.m_instanceId   = owner.GetInstanceID();
                                item.m_properties   = list;
                                this.m_components.Add(item);
                            }
                        }
                    }
                    components2.m_components = this.m_components;
                    this.m_unityComponents.Clear();
                    this.m_server.EnqueueMessage(components2);
                }
            }
        }