// Broadcast data to all clients public void Broadcast(MessageBase msg) { try { // Serialize the message byte[] bytes = msg.Serialize(); // Process all clients foreach (Socket client in clients) { try { // Send the message if (client.Connected) { client.BeginSend(bytes, 0, bytes.Length, 0, SendCallback, client); } else { HandleClientDisconnect(client); } } catch (SocketException) { HandleClientDisconnect(client); } } } catch (Exception e) { // Serialization error Console.WriteLine(e.ToString()); } }
public void SendMsg(MessageBase msg) { short msgType = 0; if (msg.GetType().Name == "TextMessage") { msgType = MRTMsgType.Text; } else if (msg.GetType().Name == "AnchorMessage") { msgType = MRTMsgType.Anchor; } else if (msg.GetType().Name == "SpawnMessage") { msgType = MRTMsgType.Spawn; } NetworkWriter writer = new NetworkWriter(); writer.StartMessage(msgType); msg.Serialize(writer); writer.FinishMessage(); // send message to server stream.Write(writer.ToArray(), 0, writer.ToArray().Length); }
public void Send(MessageBase msg, CallbackHandler callback) { if (!transport.ClientConnected()) { logger.LogError("[InsightClient] - Client not connected!"); return; } NetworkWriter writer = new NetworkWriter(); int msgType = GetId(default(MessageBase) != null ? typeof(MessageBase) : msg.GetType()); writer.WriteUInt16((ushort)msgType); int callbackId = 0; if (callback != null) { callbackId = ++callbackIdIndex; // pre-increment to ensure that id 0 is never used. callbacks.Add(callbackId, new CallbackData() { callback = callback, timeout = Time.realtimeSinceStartup + callbackTimeout }); } writer.WriteInt32(callbackId); msg.Serialize(writer); transport.ClientSend(0, new ArraySegment <byte>(writer.ToArray())); }
protected void Send(Connection connection, byte id, MessageBase message = null) { byte[] buffer; if (message != null) { var writer = new NetworkWriter(); message.Serialize(writer); var data = Math.Compress(writer.AsArray()); buffer = new byte[data.Length + 1]; buffer[0] = id; for (int i = 0; i < data.Length; i++) { buffer[i + 1] = data[i]; } } else { buffer = new byte[] { id }; } connection.Send(buffer); }
public static NetworkWriter getWriter(MessageBase messageable) { NetworkWriter writer = new NetworkWriter(); messageable.Serialize(writer); return(writer); }
public void Send(short msgType, MessageBase msg, CallbackHandler callback) { if (!transport.ClientConnected()) { Debug.LogError("[InsightClient] - Client not connected!"); return; } NetworkWriter writer = new NetworkWriter(); writer.Write(msgType); int callbackId = 0; if (callback != null) { callbackId = ++callbackIdIndex; // pre-increment to ensure that id 0 is never used. callbacks.Add(callbackId, new CallbackData() { callback = callback, timeout = Time.realtimeSinceStartup + callbackTimeout }); } writer.Write(callbackId); msg.Serialize(writer); transport.ClientSend(0, writer.ToArray()); }
public void Send(MessageBase msg) { try { // Serialize the message byte[] bytes = msg.Serialize(); if (this.Connected) { // Send the message this.BeginSend(bytes, 0, bytes.Length, 0, SendCallback, this); } else { Reconnect(); } } catch (SocketException sox) { // Attempt server reconnect Reconnect(); } catch (Exception ex) { int i = 0; } }
public override void Serialize(NetworkWriter writer) { writer.WriteInt32(connectionId); writer.WriteBool(toServer); if (extra != null) extra.Serialize(writer); }
public bool SendToClient(int connectionId, short msgType, MessageBase msg, CallbackHandler callback) { if (transport.ServerActive()) { NetworkWriter writer = new NetworkWriter(); writer.Write(msgType); int callbackId = 0; if (callback != null) { callbackId = ++callbackIdIndex; // pre-increment to ensure that id 0 is never used. callbacks.Add(callbackId, new CallbackData() { callback = callback, timeout = Time.realtimeSinceStartup + callbackTimeout }); } writer.Write(callbackId); msg.Serialize(writer); return(connections[connectionId].Send(writer.ToArray())); } Debug.LogError("Server.Send: not connected!", this); return(false); }
public static void Send(int hostId, int connectionId, int channelId, MessageBase message, short messageType) { NetworkWriter writer = new NetworkWriter(); writer.StartMessage(messageType); message.Serialize(writer); writer.FinishMessage(); byte[] writerData = writer.ToArray(); int bufferLength = P2PController.bufferLength; bufferLength = writerData.Length; //Debug.Log("Send packet with size: " + bufferLength); NetworkTransport.Send(hostId, connectionId, channelId, writerData, bufferLength, out P2PController.error); P2PController.CheckError("Send"); if (Recorder.session != null) { Recorder.session.messagesSent++; Recorder.session.AddLeavingBandwidth(bufferLength); if (channelId == P2PChannels.ReliableChannelId) { Recorder.session.importantMessagesSent++; } } }
public virtual void SendByChannel(short msgType, MessageBase msg, int channelId) { m_Writer.StartMessage(msgType); msg.Serialize(m_Writer); m_Writer.FinishMessage(); SendWriter(m_Writer, channelId); }
public void SendMessage(MessageBase message) { using BigEndianWriter writer = new BigEndianWriter(); message.Serialize(writer); var buffer = writer.Data; _socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendMessageCallBack), _socket); }
private void SendTo(int connID, short msgType, MessageBase msg, int channel = 0) { NetworkWriter netWriter = new NetworkWriter(); netWriter.StartMessage(msgType); msg.Serialize(netWriter); netWriter.FinishMessage(); netServer.SendWriterTo(connID, netWriter, channel); }
public virtual bool Send(short msgType, MessageBase msg) { NetworkWriter writer = new NetworkWriter(); msg.Serialize(writer); // pack message and send byte[] message = Protocol.PackMessage((ushort)msgType, writer.ToArray()); return(SendBytes(message)); }
public static void Send(this INetworkConnection connection, byte header, MessageBase message, NetworkReliablity reliablity = NetworkReliablity.Reliable) { var writer = new NetworkWriter(); writer.Write(header); message.Serialize(writer); connection.SendBytes(writer.AsArray(), writer.Position, reliablity); (message as IDisposable)?.Dispose(); }
public void Reply(short msgId, MessageBase msg) { var writer = new NetworkWriter(); writer.WriteInt16(msgId); writer.WriteInt32(callbackId); msg.Serialize(writer); conn.Send(writer.ToArray()); }
public override void Serialize(NetworkWriter writer) { writer.WriteBool(toServer); writer.WriteNetworkObjectId(objectId); writer.WriteNetworkInstanceId(instanceId); if (parameter != null) { parameter.Serialize(writer); } }
public void Send(MessageBase message) { if (message == null) { return; } cachedWriter.Reset(); message.Serialize(cachedWriter); NetMan.SendToAll(cachedWriter, message.TransportType); }
public void Reply(MessageBase msg) { NetworkWriter writer = new NetworkWriter(); int msgType = conn.GetActiveInsight().GetId(default(MessageBase) != null ? typeof(MessageBase) : msg.GetType()); writer.WriteUInt16((ushort)msgType); writer.WriteInt32(callbackId); msg.Serialize(writer); conn.Send(writer.ToArray()); }
public static void Send(EMessageType type, MessageBase message, int hostId, int channelId, int connId) { // serialize the message, prepend the message type NetworkWriter writer = new NetworkWriter(); writer.Write((short)type); message.Serialize(writer); byte error; byte[] msgBytes = writer.AsArray(); NetworkTransport.Send(hostId, connId, channelId, msgBytes, msgBytes.Length * sizeof(char), out error); }
public WrappedMessage(short messageType, MessageBase extraMessage) { this.messageType = messageType; if (extraMessage != null) { NetworkWriter w = new NetworkWriter(); extraMessage.Serialize(w); msgData = w.ToArray(); msgSize = w.Position; extraReader = new NetworkReader(msgData); } }
public static void SendToAll(this IEnumerable <INetworkConnection> connections, byte header, MessageBase message, NetworkReliablity reliablity = NetworkReliablity.Reliable) { var writer = new NetworkWriter(); writer.Write(header); message.Serialize(writer); var bufferSize = writer.Position; var buffer = writer.AsArray(); foreach (var connection in connections) { connection.SendBytes(buffer, bufferSize, reliablity); } (message as IDisposable)?.Dispose(); }
/// <summary> /// Method serializes message and sends it to server. /// </summary> /// <param name="msgType">Type of message. This specifies /// the type of the payload. This is important in /// networked scenarios, when proper deseriaization into /// the correct type requires knowing what was /// used to serialize the object originally. /// </param> /// <param name="msg">The message to send. /// This utilises UNET's MessageBase so it is /// Auto [de]serialized by UNET. /// This also allows us to send messages that are not /// part of Mercury XM</param> public virtual void MmSendMessageToServer(short msgType, MessageBase msg) { if (MmNetworkManager.Instance.NetworkClient == null) { MmLogger.LogFramework("No client present on host"); return; } NetworkWriter writer = new NetworkWriter(); writer.StartMessage(msgType); msg.Serialize(writer); writer.FinishMessage(); MmNetworkManager.Instance.NetworkClient.SendWriter(writer, Channels.DefaultReliable); }
public void SendMessage(MessageBase message) { try { using IDataWriter writer = new BigEndianWriter(); message.Serialize(writer); byte[] buffer = writer.Data; _socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendMessageCallback), _socket); Logger.Debug(string.Format("Sending {0} message", message.GetType())); } catch (Exception e) { Logger.Error(e); } }
public StatusMessage(bool accepted, string scene, DualNetworkManager.GameState gameState, MessageBase extraMessage) { this.accepted = accepted; this.scene = scene; this.gameState = gameState; if (extraMessage != null) { NetworkWriter w = new NetworkWriter(); extraMessage.Serialize(w); msgData = w.ToArray(); msgSize = w.Position; extraReader = new NetworkReader(msgData); } }
//Send message to all : abstract client/server distinction from basic UNet module public void SendToAll(short _msgType, MessageBase _msg) { if (!IsClientConnected()) { return; } if (m_isHost) { NetworkServer.SendToAll(_msgType, _msg); } else { client.Send(_msgType, _msg); } NetworkWriter writer = new NetworkWriter(); _msg.Serialize(writer); upload += writer.Position; }
// Send data to a specific client public void Send(Socket socket, MessageBase msg) { try { // Serialize the message byte[] bytes = msg.Serialize(); if (socket.Connected) { // Send the message socket.BeginSend(bytes, 0, bytes.Length, 0, SendCallback, socket); } else { HandleClientDisconnect(socket); } } catch (SocketException) { HandleClientDisconnect(socket); } }
public static void Send(string header, MessageBase msg, uint peerId, PacketFlags flags = PacketFlags.None) { Send(header, msg.Serialize(), peerId, flags); }
/// <summary> /// Serializes a standard uNet message /// </summary> /// <param name="opCode"></param> /// <param name="message"></param> /// <returns></returns> public static IMessage Create(short opCode, MessageBase message) { _writer.SeekZero(); message.Serialize(_writer); return(_factory.Create(opCode, _writer.ToArray())); }
public static void Send(string header, MessageBase msg, PacketFlags flags = PacketFlags.None, bool filter = true) { Send(header, msg.Serialize(), flags, filter); }