public void Start()
{
server = new NetworkServerSimple();
serverOnClientConnect += ServerOnClientConnect;
serverOnClientDisconnect += ServerOnClientDisconnect;
serverOnData += ServerOnData;
server.RegisterHandler(MsgType.Connect, serverOnClientConnect);
server.RegisterHandler(MsgType.Disconnect, serverOnClientDisconnect);
server.RegisterHandler(TerminalMsgID, serverOnData);
client = new NetworkClient();
clientOnConnect += ClientOnConnect;
clientOnDisconnect += ClientOnDisconnect;
clientOnData += ClientOnData;
client.RegisterHandler(MsgType.Connect, clientOnConnect);
client.RegisterHandler(MsgType.Disconnect, clientOnDisconnect);
client.RegisterHandler(TerminalMsgID, clientOnData);
ConnectionConfig myConfig = new ConnectionConfig();
reliableChannelId = myConfig.AddChannel(QosType.Reliable);
unreliableChannelId = myConfig.AddChannel(QosType.Unreliable);
server.Configure(myConfig, maxConnections);
client.Configure(myConfig, maxConnections);
}
void GenerateError(byte error)
{
NetworkMessageDelegate msgDelegate = m_MessageHandlers.GetHandler(MsgType.Error);
if (msgDelegate == null)
{
msgDelegate = m_MessageHandlers.GetHandler(MsgType.Error);
}
if (msgDelegate != null)
{
ErrorMessage msg = new ErrorMessage();
msg.errorCode = error;
// write the message to a local buffer
byte[] errorBuffer = new byte[200];
NetworkWriter writer = new NetworkWriter(errorBuffer);
msg.Serialize(writer);
// pass a reader (attached to local buffer) to handler
NetworkReader reader = new NetworkReader(errorBuffer);
NetworkMessage netMsg = new NetworkMessage();
netMsg.msgType = MsgType.Error;
netMsg.reader = reader;
netMsg.conn = m_Connection;
netMsg.channelId = 0;
msgDelegate(netMsg);
}
}
public static AddMessageDelegate SetHandler(int channel, NetworkMessageDelegate handler, Action <ulong> disconnectPeerOnError,
MyReceiveQueue.Mode mode = MyReceiveQueue.Mode.Synchronized, Func <MyTimeSpan> timestampProvider = null)
{
ChannelInfo info;
if (m_channels.TryGetValue(channel, out info))
{
if (info.Queue.ReadMode == mode)
{
info.Handler = handler;
return(info.Queue.AddMessage);
}
else
{
info.Queue.Dispose();
}
}
info = new ChannelInfo
{
Handler = handler,
Queue = new MyReceiveQueue(channel, disconnectPeerOnError, mode, mode == MyReceiveQueue.Mode.Synchronized ? 1 : 50, timestampProvider)
};
m_channels[channel] = info;
return(info.Queue.AddMessage);
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (NetConfig.logFilter >= LogFilter.Error)
{
Log.Error("RegisterHandler id:" + msgType + " handler is null");
}
return;
}
if (m_MsgHandlers.ContainsKey(msgType))
{
if (NetConfig.logFilter >= LogFilter.Developer)
{
Log.Debug("RegisterHandler replacing " + msgType);
}
m_MsgHandlers.Remove(msgType);
}
if (NetConfig.logFilter >= LogFilter.Developer)
{
Log.Debug("RegisterHandler id:" + msgType + " handler:" + handler.GetMethodName());
}
m_MsgHandlers.Add(msgType, handler);
}
public void connect(string server, NetworkMessageDelegate onConnect)
{
client = new NetworkClient ();
if(onConnect != null)
client.RegisterHandler (MsgType.Connect, onConnect);
client.Connect (server, PORT);
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler id:" + msgType + " handler is null");
}
}
else if (msgType <= 0x1f)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler: Cannot replace system message handler " + msgType);
}
}
else
{
if (this.m_MsgHandlers.ContainsKey(msgType))
{
if (LogFilter.logDebug)
{
Debug.Log("RegisterHandler replacing " + msgType);
}
this.m_MsgHandlers.Remove(msgType);
}
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "RegisterHandler id:", msgType, " handler:", DotNetCompatibility.GetMethodName(handler) }));
}
this.m_MsgHandlers.Add(msgType, handler);
}
}
new public bool InvokeHandler(short msgType, NetworkReader reader, int channelId)
{
if (m_MessageHandlersDict.ContainsKey(msgType))
{
m_MessageInfo.msgType = msgType;
m_MessageInfo.conn = this;
m_MessageInfo.reader = reader;
m_MessageInfo.channelId = channelId;
NetworkMessageDelegate msgDelegate = m_MessageHandlersDict[msgType];
if (msgDelegate == null)
{
if (LogFilter.logError)
{
Debug.LogError("NetworkConnection InvokeHandler no handler for " + msgType);
}
return(false);
}
msgDelegate(m_MessageInfo);
return(true);
}
return(false);
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler id:" + msgType + " handler is null");
}
return;
}
if (msgType <= MsgType.InternalHighest)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler: Cannot replace system message handler " + msgType);
}
return;
}
if (m_MsgHandlers.ContainsKey(msgType))
{
if (LogFilter.logDebug)
{
Debug.Log("RegisterHandler replacing " + msgType);
}
m_MsgHandlers.Remove(msgType);
}
if (LogFilter.logDebug)
{
Debug.Log("RegisterHandler id:" + msgType + " handler:" + handler.GetMethodName());
}
m_MsgHandlers.Add(msgType, handler);
}
private void ProcessMessages(NetworkMessageDelegate handler, MyTimeSpan delay)
{
long delayTicks = (long)Math.Round(delay.Seconds * Stopwatch.Frequency);
var processTime = MyTimeSpan.FromTicks(Stopwatch.GetTimestamp() - delayTicks);
Message msg;
int count = m_receiveQueue.Count;
while (m_receiveQueue.TryPeek(out msg) && (processTime > msg.ReceivedTime) && count != 0)
{
count--;
if (m_receiveQueue.TryDequeue(out msg)) // Can fail when queue was cleared
{
if (msg.Timestamp != MyTimeSpan.Zero)
{
msg.Timestamp += delay;
}
try
{
handler(msg.Data, msg.Length, msg.UserId, msg.Timestamp, msg.ReceivedTime);
}
catch (Exception ex)
{
MyLog.Default.WriteLine(ex);
if (!Sandbox.Game.Multiplayer.Sync.IsServer)
{
throw;
}
m_disconnectPeerOnError(msg.UserId);
}
m_messagePool.Return(msg);
}
}
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (!LogFilter.logError)
return;
Debug.LogError((object) ("RegisterHandler id:" + (object) msgType + " handler is null"));
}
else if ((int) msgType <= 31)
{
if (!LogFilter.logError)
return;
Debug.LogError((object) ("RegisterHandler: Cannot replace system message handler " + (object) msgType));
}
else
{
if (this.m_MsgHandlers.ContainsKey(msgType))
{
if (LogFilter.logDebug)
Debug.Log((object) ("RegisterHandler replacing " + (object) msgType));
this.m_MsgHandlers.Remove(msgType);
}
if (LogFilter.logDebug)
Debug.Log((object) ("RegisterHandler id:" + (object) msgType + " handler:" + handler.Method.Name));
this.m_MsgHandlers.Add(msgType, handler);
}
}
/// <summary>
/// Registers a new handler callback for event based system
/// </summary>
/// <param name="opcode"></param>
/// <param name="handler"></param>
public void RegisterHandler(short opcode, NetworkMessageDelegate handler)
{
var op = new Dictionary <short, NetworkMessageDelegate>();
op.Add(opcode, handler);
this.handlersMap.Add(op);
}
protected override void Initialize()
{
if ((int)this.UnreliableChannel >= NetworkManager.singleton.channels.Count)
{
throw this.Log.CreateUserErrorException("configured 'unreliable' channel is out of range", "set the wrong channel number in the HLAPI Comms Network component", "https://dissonance.readthedocs.io/en/latest/Basics/Quick-Start-UNet-HLAPI/", "B19B4916-8709-490B-8152-A646CCAD788E");
}
QosType qosType = NetworkManager.singleton.channels[(int)this.UnreliableChannel];
if (qosType != QosType.Unreliable)
{
throw this.Log.CreateUserErrorException(string.Format("configured 'unreliable' channel has QoS type '{0}'", qosType), "not creating the channel with the correct QoS type", "https://dissonance.readthedocs.io/en/latest/Basics/Quick-Start-UNet-HLAPI/", "24ee53b1-7517-4672-8a4a-64a3e3c87ef6");
}
if ((int)this.ReliableSequencedChannel >= NetworkManager.singleton.channels.Count)
{
throw this.Log.CreateUserErrorException("configured 'reliable' channel is out of range", "set the wrong channel number in the HLAPI Comms Network component", "https://dissonance.readthedocs.io/en/latest/Basics/Quick-Start-UNet-HLAPI/", "5F5F2875-ECC8-433D-B0CB-97C151B8094D");
}
QosType qosType2 = NetworkManager.singleton.channels[(int)this.ReliableSequencedChannel];
if (qosType2 != QosType.ReliableSequenced)
{
throw this.Log.CreateUserErrorException(string.Format("configured 'reliable sequenced' channel has QoS type '{0}'", qosType2), "not creating the channel with the correct QoS type", "https://dissonance.readthedocs.io/en/latest/Basics/Quick-Start-UNet-HLAPI/", "035773ec-aef3-477a-8eeb-c234d416171c");
}
short typeCode = this.TypeCode;
if (HlapiCommsNetwork.< > f__mg$cache0 == null)
{
HlapiCommsNetwork.< > f__mg$cache0 = new NetworkMessageDelegate(HlapiCommsNetwork.NullMessageReceivedHandler);
}
NetworkServer.RegisterHandler(typeCode, HlapiCommsNetwork.< > f__mg$cache0);
base.Initialize();
}
private void GenerateError(int error)
{
NetworkError netError = (NetworkError)error;
if (LogFilter.logError)
{
Debug.LogError("Client Net Error: " + netError);
}
NetworkMessageDelegate msgDelegate = handlers.ContainsKey(MsgType.Error) ? handlers[MsgType.Error] : null;
if (msgDelegate != null)
{
ErrorMessage msg = new ErrorMessage();
msg.errorCode = error;
// write the message to a local buffer
byte[] errorBuffer = new byte[200];
NetworkWriter writer = new NetworkWriter(errorBuffer);
msg.Serialize(writer);
// pass a reader (attached to local buffer) to handler
NetworkReader reader = new NetworkReader(errorBuffer);
NetworkMessage netMsg = new NetworkMessage();
netMsg.msgType = MsgType.Error;
netMsg.reader = reader;
netMsg.conn = m_myConnection;
netMsg.channelId = 0;
msgDelegate(netMsg);
}
}
public void startServer(NetworkMessageDelegate onConnect)
{
NetworkServer.Listen (PORT);
if (onConnect != null) {
NetworkServer.RegisterHandler (MsgType.Connect, onConnect);
}
}
public GameMessage(NetworkMessageDelegate method)
{
index = MessageManager.LastIndex;
this.method = method;
MessageManager.LastIndex++;
MessageManager.ToRegister.Add(this);
}
// ===========================================================================
// ========================= UTILITY FUNCTIONS =========================
// ===========================================================================
void registerAllCallbacks(NetworkClient nc, NetworkMessageDelegate nmd)
{
foreach (Message.ID MsgId in System.Enum.GetValues(typeof(Message.ID))) // Register all the callbacks
{
nc.RegisterHandler((short)MsgId, nmd);
}
}
internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (NetConfig.logFilter >= LogFilter.Error)
{
Log.Error("RegisterHandlerSafe id:" + msgType + " handler is null");
}
return;
}
if (NetConfig.logFilter >= LogFilter.Developer)
{
Log.Debug("RegisterHandlerSafe id:" + msgType + " handler:" + handler.GetMethodName());
}
if (m_MsgHandlers.ContainsKey(msgType))
{
if (NetConfig.logFilter >= LogFilter.Error)
{
Log.Error("RegisterHandlerSafe id:" + msgType + " handler:" + handler.GetMethodName() + " conflict");
}
return;
}
m_MsgHandlers.Add(msgType, handler);
}
/// <summary>
/// Send message to server to update a player
/// Cannot change the actual playerKey. if that is desired, remove player / add new player
/// </summary>
/// <param name="playerKey"></param>
/// <param name="playerValue"></param>
/// <param name="flags"></param>
/// <param name="response"></param>
public void UpdatePlayer(string playerKey, string playerValue, int flags, NetworkMessageDelegate response = null)
{
if (IsConnected)
{
if (IsDebug)
{
Debug.Log("<ClientHost> Updating Player [" + playerKey + "]");
}
var msg = new MessageTypes.UpdatePlayerMessage();
msg.playerKey = playerKey;
msg.playerValue = playerValue;
msg.flags = flags;
Client.Send(MessageTypes.UpdatePlayer, msg);
// use response type for handler!
if (response != null)
{
RegisterHandler(MessageTypes.UpdatePlayerResponse, response);
}
}
else
{
Debug.LogError("<ClientHost> UpdatePlayer failed, host not connected to MasterServer");
}
}
public static void RegisterHandler(int msgType, NetworkMessageDelegate handler)
{
if (handlers.ContainsKey(msgType))
{
if (LogFilter.Debug) Debug.Log("NetworkServer.RegisterHandler replacing " + msgType);
}
handlers[msgType] = handler;
}
/// <summary>
/// Sets a message handler.
/// </summary>
/// <param name="msgType">Message type.</param>
/// <param name="handler">Handler.</param>
public virtual void SetMessageHandler(short msgType, NetworkMessageDelegate handler)
{
#if SERVER
NetworkServer.
#else
client.
#endif
RegisterHandler(msgType, handler);
}
public void Init()
{
m_Delegates = new Dictionary <DelegateType, Delegate>();
NetworkMessageDelegate networkMessageDelegate = null;
ConnectionErrorDelegate connectionErrorDelegate = null;
m_Delegates.Add(DelegateType.ConnectionError, connectionErrorDelegate);
m_Delegates.Add(DelegateType.NetworkMessage, networkMessageDelegate);
}
public override void RegisterMessaging(short msgType, [NotNull] NetworkMessageDelegate callback)
{
if (_client.handlers.ContainsKey(msgType))
{
Debug.LogError($"MsgId: {msgType}, already exists, overriding . . .");
}
_client.RegisterHandler(msgType, callback);
}
private void RegisterEvent(NetworkClient p_client, short msg_id, NetworkMessageDelegate p_callback)
{
if (_client == null)
{
return;
}
_client.UnregisterHandler(msg_id);
_client.RegisterHandler(msg_id, p_callback);
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (msgHandlers.ContainsKey(msgType))
{
msgHandlers.Remove(msgType);
}
msgHandlers.Add(msgType, handler);
}
public void RegisterHandlerOverride(short _msgType, NetworkMessageDelegate handler)
{
if (NetworkServer.handlers.ContainsKey(_msgType))
{
NetworkServer.handlers.Remove(_msgType);
}
NetworkServer.RegisterHandler(_msgType, handler);
}
public void RegisterHandlerOverride(short _msgType, NetworkMessageDelegate handler)
{
if (networkClient.handlers.ContainsKey(_msgType))
{
networkClient.handlers.Remove(_msgType);
}
networkClient.RegisterHandler(_msgType, handler);
}
public bool InvokeHandler(NetworkMessage netMsg)
{
if (m_MessageHandlersDict.ContainsKey(netMsg.msgType))
{
NetworkMessageDelegate msgDelegate = m_MessageHandlersDict[netMsg.msgType];
msgDelegate(netMsg);
return(true);
}
return(false);
}
public static void RegisterNetworkHandlerAttributes()
{
List <NetworkMessageHandlerAttribute> serverMessageHandlers = (List <NetworkMessageHandlerAttribute>)get_serverMessageHandlers.GetValue(null);
List <NetworkMessageHandlerAttribute> clientMessageHandlers = (List <NetworkMessageHandlerAttribute>)get_clientMessageHandlers.GetValue(null);
HashSet <short> hashSet = new HashSet <short>();
Type[] types = typeof(NetworkHandler).Assembly.GetTypes();
for (int i = 0; i < types.Length; i++)
{
foreach (MethodInfo methodInfo in types[i].GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
{
object[] customAttributes = methodInfo.GetCustomAttributes(false);
foreach (var attribute in customAttributes.OfType <NetworkMessageHandlerAttribute>())
{
NetworkMessageHandlerAttribute networkMessageHandlerAttribute = (Attribute)attribute as NetworkMessageHandlerAttribute;
NetworkMessageDelegate messageHandler = null;
if (networkMessageHandlerAttribute != null)
{
messageHandler = (NetworkMessageDelegate)Delegate.CreateDelegate(typeof(NetworkMessageDelegate), methodInfo);
if (messageHandler != null)
{
if (networkMessageHandlerAttribute.client)
{
clientMessageHandlers.Add(networkMessageHandlerAttribute);
hashSet.Add(networkMessageHandlerAttribute.msgType);
}
if (networkMessageHandlerAttribute.server)
{
serverMessageHandlers.Add(networkMessageHandlerAttribute);
hashSet.Add(networkMessageHandlerAttribute.msgType);
}
}
if (messageHandler == null)
{
Debug.LogWarningFormat("Could not register message handler for {0}. The function signature is likely incorrect.", new object[]
{
methodInfo.Name
});
}
get_messageHandler.SetValue(networkMessageHandlerAttribute, messageHandler);
if (!networkMessageHandlerAttribute.client && !networkMessageHandlerAttribute.server)
{
Debug.LogWarningFormat("Could not register message handler for {0}. It is marked as neither server nor client.", new object[]
{
methodInfo.Name
});
}
}
}
}
}
}
private void StartNetServer()
{
serverOnClientConnect += ServerOnClientConnect;
serverOnClientDisconnect += ServerOnClientDisconnect;
msgServer.RegisterHandler(MsgType.Connect, serverOnClientConnect);
msgServer.RegisterHandler(MsgType.Disconnect, serverOnClientDisconnect);
msgServer.Listen(serverListenPort);
Debug.Log("Starting message server on port " + serverListenPort);
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (m_MessageHandlers.ContainsKey(msgType))
{
if (LogFilter.Debug)
{
Debug.Log("NetworkConnection.RegisterHandler replacing " + msgType);
}
}
m_MessageHandlers[msgType] = handler;
}
public static void RegisterHandler(int msgType, NetworkMessageDelegate handler)
{
if (handlers.ContainsKey(msgType))
{
if (LogFilter.Debug)
{
Debug.Log("NetworkClient.RegisterHandler replacing " + handler.ToString() + " - " + msgType);
}
}
handlers[msgType] = handler;
}
new protected void HandleReader(
NetworkReader reader,
int receivedSize,
int channelId)
{
// read until size is reached.
// NOTE: stream.Capacity is 1300, NOT the size of the available data
while (reader.Position < receivedSize)
{
// the reader passed to user code has a copy of bytes from the real stream. user code never touches the real stream.
// this ensures it can never get out of sync if user code reads less or more than the real amount.
ushort sz = reader.ReadUInt16();
short msgType = reader.ReadInt16();
// create a reader just for this message
byte[] msgBuffer = reader.ReadBytes(sz);
NetworkReader msgReader = new NetworkReader(msgBuffer);
if (logNetworkMessages)
{
StringBuilder msg = new StringBuilder();
for (int i = 0; i < sz; i++)
{
msg.AppendFormat("{0:X2}", msgBuffer[i]);
// if (i > k_MaxMessageLogSize) break;
}
Debug.Log("ConnectionRecv con:" + connectionId + " bytes:" + sz + " msgId:" + msgType + " " + msg);
}
NetworkMessageDelegate msgDelegate = null;
if (m_MessageHandlersDict.ContainsKey(msgType))
{
msgDelegate = m_MessageHandlersDict[msgType];
}
if (msgDelegate != null)
{
m_NetMsg.msgType = msgType;
m_NetMsg.reader = msgReader;
m_NetMsg.conn = this;
m_NetMsg.channelId = channelId;
msgDelegate(m_NetMsg);
lastMessageTime = Time.time;
}
else
{
//NOTE: this throws away the rest of the buffer. Need moar error codes
if (LogFilter.logError)
{
Debug.LogError("Unknown message ID " + msgType + " connId:" + connectionId);
}
break;
}
}
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (!_msgHandler.ContainsKey(msgType))
{
_msgHandler.Add(msgType, handler);
}
else
{
_msgHandler[msgType] = handler;
}
}
public void RegisterHandler(short messageType, NetworkMessageDelegate handler)
{
#if DEBUG
if (__client == null)
{
throw new InvalidOperationException();
}
#endif
__client.RegisterHandler(messageType, handler);
}
internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (!LogFilter.logError)
return;
Debug.LogError((object) ("RegisterHandlerSafe id:" + (object) msgType + " handler is null"));
}
else
{
if (LogFilter.logDebug)
Debug.Log((object) ("RegisterHandlerSafe id:" + (object) msgType + " handler:" + handler.Method.Name));
if (this.m_MsgHandlers.ContainsKey(msgType))
return;
this.m_MsgHandlers.Add(msgType, handler);
}
}
internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandlerSafe id:" + msgType + " handler is null");
}
}
else
{
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[] { "RegisterHandlerSafe id:", msgType, " handler:", DotNetCompatibility.GetMethodName(handler) }));
}
if (!this.m_MsgHandlers.ContainsKey(msgType))
{
this.m_MsgHandlers.Add(msgType, handler);
}
}
}
public static AddMessageDelegate SetHandler(int channel, NetworkMessageDelegate handler, MyReceiveQueue.Mode mode = MyReceiveQueue.Mode.Synchronized, Func<TimeSpan> timestampProvider = null)
{
ChannelInfo info;
if (m_channels.TryGetValue(channel, out info))
{
if (info.Queue.ReadMode == mode)
{
info.Handler = handler;
return info.Queue.AddMessage;
}
else
{
info.Queue.Dispose();
}
}
info = new ChannelInfo();
info.Handler = handler;
info.Queue = new MyReceiveQueue(channel, mode, mode == MyReceiveQueue.Mode.Synchronized ? 1 : 50, timestampProvider);
m_channels[channel] = info;
return info.Queue.AddMessage;
}
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler id:" + msgType + " handler is null");
}
return;
}
if (msgType <= 31)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandler: Cannot replace system message handler " + msgType);
}
return;
}
if (this.m_MsgHandlers.ContainsKey(msgType))
{
if (LogFilter.logDebug)
{
Debug.Log("RegisterHandler replacing " + msgType);
}
this.m_MsgHandlers.Remove(msgType);
}
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[]
{
"RegisterHandler id:",
msgType,
" handler:",
handler.Method.Name
}));
}
this.m_MsgHandlers.Add(msgType, handler);
}
// ===========================================================================
// ========================= UTILITY FUNCTIONS =========================
// ===========================================================================
void registerAllCallbacks ( NetworkClient nc, NetworkMessageDelegate nmd )
{
foreach (Message.ID MsgId in System.Enum.GetValues(typeof(Message.ID))) // Register all the callbacks
nc.RegisterHandler((short)MsgId, nmd);
}
public void connectToLocal(NetworkMessageDelegate onConnect)
{
client = ClientScene.ConnectLocalServer ();
client.RegisterHandler (MsgType.Connect, onConnect);
}
internal void RegisterHandlerSafe(short msgType, NetworkMessageDelegate handler)
{
if (handler == null)
{
if (LogFilter.logError)
{
Debug.LogError("RegisterHandlerSafe id:" + msgType + " handler is null");
}
return;
}
if (LogFilter.logDebug)
{
Debug.Log(string.Concat(new object[]
{
"RegisterHandlerSafe id:",
msgType,
" handler:",
handler.Method.Name
}));
}
if (this.m_MsgHandlers.ContainsKey(msgType))
{
return;
}
this.m_MsgHandlers.Add(msgType, handler);
}
/// <summary>
/// Processes messages
/// Delay indicates how long must be message in queue before processing (lag emulation)
/// </summary>
public void Process(NetworkMessageDelegate handler, TimeSpan delay = default(TimeSpan))
{
if (ReadMode == Mode.Synchronized)
{
// Process old messages (stored because of delay)
if (m_receiveQueue.Count > 0)
{
ProcessMessages(handler, delay);
}
// Read and process all of them cuz it might ping-pong msgs between server-client all the time
while (ReceiveOne());
ProcessMessages(handler, delay);
}
else
{
ProcessMessages(handler, delay);
}
}
private void ProcessMessages(NetworkMessageDelegate handler, TimeSpan delay)
{
long delayTicks = (long)Math.Round(delay.TotalSeconds * Stopwatch.Frequency);
long processTime = Stopwatch.GetTimestamp() - delayTicks;
Message msg;
int count = m_receiveQueue.Count;
while (m_receiveQueue.TryPeek(out msg) && (processTime > msg.ReceiveTime) && count != 0)
{
count--;
if (m_receiveQueue.TryDequeue(out msg)) // Can fail when queue was cleared
{
if (msg.Timestamp != TimeSpan.Zero)
{
msg.Timestamp += delay;
}
handler(msg.Data, msg.Length, msg.UserId, msg.Timestamp);
m_messagePool.Return(msg);
}
}
}
/// <summary>
///
/// <para>
/// Register a handler for a particular message type.
/// </para>
///
/// </summary>
/// <param name="msgType">Message type number.</param><param name="handler">Function handler which will be invoked for when this message type is received.</param>
public static void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
NetworkServer.instance.m_MessageHandlers.RegisterHandler(msgType, handler);
}
/// <summary>
/// Processes messages
/// Delay indicates how long must be message in queue before processing (lag emulation)
/// </summary>
public void Process(NetworkMessageDelegate handler, TimeSpan delay = default(TimeSpan))
{
if (ReadMode == Mode.Synchronized)
{
// Process old messages (stored because of delay)
if (m_receiveQueue.Count > 0)
{
ProcessMessages(handler, delay);
}
// Read and process one-by-one to keep memory usage low
while (ReceiveOne())
{
ProcessMessages(handler, delay);
}
}
else
{
ProcessMessages(handler, delay);
}
}
/// <summary>
/// <para>Register a handler for a particular message type.</para>
/// </summary>
/// <param name="msgType">Message type number.</param>
/// <param name="handler">Function handler which will be invoked for when this message type is received.</param>
public static void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
instance.m_SimpleServerSimple.RegisterHandler(msgType, handler);
}
/// <summary>
/// <para>This registers a handler function for a message Id.</para>
/// </summary>
/// <param name="msgType">The message ID to register.</param>
/// <param name="handler">The handler function to register.</param>
public void RegisterHandler(short msgType, NetworkMessageDelegate handler)
{
this.m_MessageHandlers.RegisterHandler(msgType, handler);
}