public static ByteStream GetSetFieldCommand(string _FieldName, object _Value)
 {
     ByteStream stream = new ByteStream();
     stream.Write(2);
     Converter.Write(_FieldName, stream);
     Converter.Write(_Value, stream);
     return stream;
 }
示例#2
0
 public static void Write(object _Object, ByteStream _TargetStream)
 {
     Initialize();
     Type t = _Object.GetType();
     if (Converters.ContainsKey(t))
     {
         Converters[typeof(string)].WriteObject(t.FullName, _TargetStream);
         Converters[t].WriteObject(_Object, _TargetStream);
     }
     else
         Log.Write("Converter", "Cant find converter for Type {0}", t.Name);
 }
 public static ByteStream GetInvokeCommand(string _Name, params object[] _Parameters)
 {
     ByteStream stream = new ByteStream();
     stream.Write(1);
     Converter.Write(_Name, stream);
     Converter.Write((ushort)_Parameters.Length, stream);
     foreach (object o in _Parameters)
     {
         Converter.Write(o, stream);
     }
     return stream;
 }
示例#4
0
 public static object Read(ByteStream _Stream)
 {
     Initialize();
     if (_Stream.Length > 0)
     {
         string typename = (string)Converters[typeof(string)].ReadObject(_Stream);
         Type t = Type.GetType(typename);
         if (t != null)
         {
             if (Converters.ContainsKey(t)) return Converters[t].ReadObject(_Stream);
         }
         else { Log.Write("Converter", "Cant find Type {0}", typename); }
     }
     else { Log.Write("Converter", "Cant read from stream, stream is empty"); }
     return null;
 }
示例#5
0
 public virtual void Send(ByteStream _RawData)
 {
 }
示例#6
0
            public void RequestNetworkMap()
            {
                Log.Write("Networking", "NetworkMap request received");
                //send connections
                foreach (Connection connection in NetworkManager.LocalNode.Connections)
                {
                    SendToAll("MapConnection", NetworkManager.LocalNode.NodeID, connection.RemoteNodeID);
                }
                //send classes
                foreach (NetworkClassMaster networkclass in NetworkManager.LocalNode.NetworkClasses.Values)
                {
                    SendToAll("MapClass", NetworkManager.LocalNode.NodeID, networkclass.Name, networkclass.TypeName);

                    //send methods
                    foreach (string methodname in networkclass.GetNetworkMethods())
                    {
                        string parameters = "";
                        foreach (ParameterInfo i in networkclass.GetNetworkMethodInfo(methodname).GetParameters())
                            parameters += i.Name + " ";
                        SendToAll("MapClassMethod", NetworkManager.LocalNode.NodeID, networkclass.Name, methodname, parameters);
                    }

                    //send fields
                    foreach (string fieldname in networkclass.GetNetworkFields())
                    {
                        FieldInfo info = networkclass.GetNetworkFieldInfo(fieldname);
                        object value = networkclass.GetField(fieldname);
                        if (value != null)
                        {
                            ByteStream valuestream = new ByteStream();
                            Converter.Write(value, valuestream);
                            SendToAll("MapClassField", NetworkManager.LocalNode.NodeID, networkclass.Name, fieldname, info.FieldType.FullName, valuestream);
                        }
                        else { Log.Write("Networking", Log.Line.Type.Error, "cant send field : {0}", fieldname); }
                    }
                }
            }
示例#7
0
 public void ExecuteRemoteCommand(string _TargetClass, ByteStream _Command)
 {
     bool found = false;
     foreach (NetworkNodeRemote node in NetworkManager.RemoteNodes.Values)
     {
         foreach (NetworkClassSlave clas in node.LocalDevices.Values)
         {
             if (clas.Name == _TargetClass)
             {
                 clas.EnqueueCommand(_Command);
                 found = true;
             }
         }
     }
     if (!found) Log.Write("Networking", Log.Line.Type.Warning, "not NetworkClassSlave found with name {0}, try to refresh network map", _TargetClass);
 }
示例#8
0
 public void ExecuteLocalCommand(string _TargetClass, ByteStream _Command)
 {
     if (NetworkManager.LocalNode.NetworkClasses.ContainsKey(_TargetClass))
         NetworkManager.LocalNode.NetworkClasses[_TargetClass].EnqueueCommand(_Command);
     else
         Log.Write("Networking", Log.Line.Type.Warning, "Network class {0} not found", _TargetClass);
 }
 internal virtual void ExecuteCommand(ByteStream _Stream)
 {
     byte command = _Stream.Read();
     switch (command)
     {
         case 1://invoke method
             {
                 string methodname = (string)Converter.Read(_Stream);
                 MethodInfo info = GetNetworkMethodInfo(methodname);
                 if (info != null)
                 {
                     int paramcount = (ushort)Converter.Read(_Stream);
                     object[] parameters = new object[paramcount];
                     for (int i = 0; i < paramcount; i++)
                         parameters[i] = Converter.Read(_Stream);
                     InvokeMethod(methodname, parameters);
                 }
                 else Log.Write("NetworkClass", Log.Line.Type.Error, "Cant find method with name {0}", methodname);
             }
             break;
         case 2://set field
             {
                 string fieldname = (string)Converter.Read(_Stream);
                 FieldInfo info = GetNetworkFieldInfo(fieldname);
                 if (info != null)
                 {
                     object value = Converter.Read(_Stream);
                     SetField(fieldname, value);
                 }
                 else Log.Write("NetworkClass", Log.Line.Type.Error, "Cant find field with name {0}", fieldname);
             }
             break;
     }
 }
示例#10
0
 public override void Update()
 {
     while (true)
     {
         if (currentpacketsize == 0)
         {
             //read new packetype
             if (ReceiveBuffer.Length < 2) return; //there is no data available so we cant read any
             currentpacketsize = BitConverter.ToUInt16(ReceiveBuffer.Read(2), 0);
         }
         if (currentpacketsize != 0)
         {
             if (ReceiveBuffer.Length >= currentpacketsize)
             {
                 byte[] buffer = ReceiveBuffer.Read(currentpacketsize);
                 ByteStream packet = new ByteStream(buffer);
                 bool broadcast = packet.Read() != 0;
                 uint action = (uint)Converter.Read(packet);
                 if (!NetworkManager.ActionBlackList.Contains(action))
                 {
                     NetworkManager.ActionBlackList.Add(action);
                     if (broadcast)
                     {
                         foreach (Connection c in NetworkManager.LocalNode.Connections)
                         {
                             if (c != this) c.Send(new ByteStream(buffer));
                         }
                     }
                     methods.ExecuteCommand(packet);
                 }
                 currentpacketsize = 0;
             }
             else return;
         }
     }
 }
示例#11
0
 public override void Send(ByteStream _RawData)
 {
     byte[] data = _RawData.ReadAll();
     mutex.WaitOne();
     SendBuffer.Write(BitConverter.GetBytes((ushort)data.Length));
     SendBuffer.Write(data);
     mutex.ReleaseMutex();
 }
示例#12
0
        public override void Send(bool _BroadCast, uint _ActionID, string _FunctionName, params object[] _Parameters)
        {
            ByteStream s = new ByteStream();
            s.Write((byte)(_BroadCast ? 255 : 0));
            Converter.Write(_ActionID, s);
            s.Write(NetworkClassMaster.GetInvokeCommand(_FunctionName, _Parameters));

            Send(s);
        }
示例#13
0
 public void Write(ByteStream _Stream)
 {
     Write(_Stream.ReadAll());
 }
示例#14
0
 public abstract object ReadObject(ByteStream _Stream);
示例#15
0
            public void AddClassField(string _NodeID, string _ClassName, string _FieldName, string _FieldType, ByteStream _Value)
            {
                NetworkManager.AddRemoteNode(_NodeID);
                NetworkNodeRemote node = NetworkManager.RemoteNodes[_NodeID];

                if (node.LocalDevices.ContainsKey(_ClassName))
                {
                    NetworkClassSlave parent = node.LocalDevices[_ClassName];
                    if (!parent.Fields.ContainsKey(_FieldName))
                    {
                        object value = Converter.Read(_Value);

                        NetworkClassSlave.Field field = new NetworkClassSlave.Field(_FieldName, parent, value);
                        parent.Fields.Add(_FieldName, field);
                        Log.Write("Networking", "Network field added {0}", field.ToString());
                    }
                    else Log.Write("Networking", Log.Line.Type.Warning, "{0} already has a field : {1}", _ClassName, _FieldName);
                }
                else Log.Write("Networking", Log.Line.Type.Warning, "Cant find NetworkClass {0}", _ClassName);
            }
示例#16
0
 public abstract void WriteObject(object _Object, ByteStream _TargetStream);
示例#17
0
 internal void EnqueueCommand(ByteStream _Stream)
 {
     lock (CommandQueue)
     {
         CommandQueue.Enqueue(_Stream);
     }
 }