// 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);
}
