/// <summary>
/// Converts a raw NetIncomingMessage to an IncomingEntityMessage object
/// </summary>
/// <param name="message">raw network message</param>
/// <returns>An IncomingEntityMessage object</returns>
public IncomingEntityMessage HandleEntityNetworkMessage(NetIncomingMessage message)
{
var messageType = (EntityMessage)message.ReadByte();
int uid;
IncomingEntityMessage result = IncomingEntityMessage.Null;
switch (messageType)
{
case EntityMessage.ComponentMessage:
uid = message.ReadInt32();
IncomingEntityComponentMessage messageContent = HandleEntityComponentNetworkMessage(message);
result = new IncomingEntityMessage(uid, EntityMessage.ComponentMessage, messageContent,
message.SenderConnection);
break;
case EntityMessage.SystemMessage: //TODO: Not happy with this resolving the entmgr everytime a message comes in.
var manager = IoCManager.Resolve <IEntitySystemManager>();
manager.HandleSystemMessage(new EntitySystemData(message.SenderConnection, message));
break;
case EntityMessage.PositionMessage:
uid = message.ReadInt32();
//TODO: Handle position messages!
break;
}
return(result);
}
/// <summary>
/// Server-side method to handle instantiation messages from client-side components
/// asking for initialization data
/// </summary>
/// <param name="message">Message from client</param>
protected void HandleComponentInstantiationMessage(IncomingEntityMessage message)
{
if (HasComponent((ComponentFamily)message.Message))
{
GetComponent <Component>((ComponentFamily)message.Message).HandleInstantiationMessage(message.Sender);
}
}
/// <summary>
/// Func to handle an incoming network message
/// </summary>
/// <param name="message"></param>
public virtual void HandleNetworkMessage(IncomingEntityMessage message)
{
switch (message.MessageType)
{
case EntityMessage.ComponentMessage:
HandleComponentMessage((IncomingEntityComponentMessage)message.Message, message.Sender);
break;
case EntityMessage.ComponentInstantiationMessage: //Server Only
HandleComponentInstantiationMessage(message);
break;
}
}
/// <summary>
/// Converts a raw NetIncomingMessage to an IncomingEntityMessage object
/// </summary>
/// <param name="message">raw network message</param>
/// <returns>An IncomingEntityMessage object</returns>
public IncomingEntityMessage HandleEntityNetworkMessage(NetIncomingMessage message)
{
var messageType = (EntityMessage)message.ReadByte();
int uid;
IncomingEntityMessage result = IncomingEntityMessage.Null;
switch (messageType)
{
case EntityMessage.ComponentMessage:
uid = message.ReadInt32();
IncomingEntityComponentMessage messageContent = HandleEntityComponentNetworkMessage(message);
result = new IncomingEntityMessage(uid, EntityMessage.ComponentMessage, messageContent,
message.SenderConnection);
if (_messageProfiling)
{
//Log the message
var logger = IoCManager.Resolve <IMessageLogger>();
logger.LogIncomingComponentNetMessage(result.Uid, result.MessageType,
messageContent.ComponentFamily,
messageContent.MessageParameters.ToArray());
}
break;
case EntityMessage.SystemMessage: //TODO: Not happy with this resolving the entmgr everytime a message comes in.
EntityManager eMgr = (EntityManager)IoCManager.Resolve <IEntityManager>();
eMgr.EntitySystemManager.HandleSystemMessage(new EntitySystemData(message.SenderConnection, message));
break;
case EntityMessage.PositionMessage:
uid = message.ReadInt32();
//TODO: Handle position messages!
break;
case EntityMessage.GetSVars:
uid = message.ReadInt32();
result = new IncomingEntityMessage(uid, EntityMessage.GetSVars, message, message.SenderConnection);
break;
}
return(result);
}
/// <summary>
/// Handle an incoming network message by passing the message to the EntityNetworkManager
/// and handling the parsed result.
/// </summary>
/// <param name="msg">Incoming raw network message</param>
public void HandleEntityNetworkMessage(NetIncomingMessage msg)
{
if (!Initialized)
{
IncomingEntityMessage emsg = ProcessNetMessage(msg);
if (emsg.MessageType != EntityMessage.Null)
{
MessageBuffer.Enqueue(emsg);
}
}
else
{
ProcessMsgBuffer();
IncomingEntityMessage emsg = ProcessNetMessage(msg);
if (!_entities.ContainsKey(emsg.Uid))
{
MessageBuffer.Enqueue(emsg);
}
else
{
_entities[emsg.Uid].HandleNetworkMessage(emsg);
}
}
}
protected void ProcessMsgBuffer()
{
if (!Initialized)
{
return;
}
if (!MessageBuffer.Any())
{
return;
}
var misses = new List <IncomingEntityMessage>();
while (MessageBuffer.Any())
{
IncomingEntityMessage entMsg = MessageBuffer.Dequeue();
if (!_entities.ContainsKey(entMsg.Uid))
{
entMsg.LastProcessingAttempt = DateTime.Now;
if ((entMsg.LastProcessingAttempt - entMsg.ReceivedTime).TotalSeconds > entMsg.Expires)
{
misses.Add(entMsg);
}
}
else
{
_entities[entMsg.Uid].HandleNetworkMessage(entMsg);
}
}
foreach (IncomingEntityMessage miss in misses)
{
MessageBuffer.Enqueue(miss);
}
MessageBuffer.Clear(); //Should be empty at this point anyway.
}
/// <summary>
/// Handles an incoming entity message
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
public IncomingEntityMessage HandleEntityNetworkMessage(NetIncomingMessage message)
{
var messageType = (EntityMessage)message.ReadByte();
int uid = 0;
IncomingEntityMessage incomingEntityMessage = IncomingEntityMessage.Null;
switch (messageType)
{
case EntityMessage.ComponentMessage:
uid = message.ReadInt32();
incomingEntityMessage = new IncomingEntityMessage(uid, EntityMessage.ComponentMessage,
HandleEntityComponentNetworkMessage(message),
message.SenderConnection);
break;
case EntityMessage.SystemMessage: //TODO: Not happy with this resolving the entmgr everytime a message comes in.
var manager = IoCManager.Resolve <IEntitySystemManager>();
manager.HandleSystemMessage(new EntitySystemData(message.SenderConnection, message));
break;
case EntityMessage.PositionMessage:
uid = message.ReadInt32();
//TODO: Handle position messages!
break;
case EntityMessage.ComponentInstantiationMessage:
uid = message.ReadInt32();
incomingEntityMessage = new IncomingEntityMessage(uid,
EntityMessage.ComponentInstantiationMessage,
(ComponentFamily)
UnPackParams(message).First(),
message.SenderConnection);
break;
case EntityMessage.SetSVar:
uid = message.ReadInt32();
incomingEntityMessage = new IncomingEntityMessage(uid,
EntityMessage.SetSVar,
MarshalComponentParameter.Deserialize(message),
message.SenderConnection);
break;
case EntityMessage.GetSVars:
uid = message.ReadInt32();
incomingEntityMessage = new IncomingEntityMessage(uid,
EntityMessage.GetSVars, null,
message.SenderConnection);
break;
}
if (_messageProfiling)
{
var logger = IoCManager.Resolve <IMessageLogger>();
if (messageType == EntityMessage.ComponentMessage)
{
var messageContent = (IncomingEntityComponentMessage)incomingEntityMessage.Message;
logger.LogIncomingComponentNetMessage(message.SenderConnection.RemoteUniqueIdentifier,
uid,
messageType,
messageContent.ComponentFamily,
PackParamsForLog(messageContent.MessageParameters.ToArray()));
}
else if (messageType == EntityMessage.ComponentInstantiationMessage)
{
logger.LogIncomingComponentNetMessage(message.SenderConnection.RemoteUniqueIdentifier,
uid,
messageType,
(ComponentFamily)incomingEntityMessage.Message,
new object[0]);
}
}
return(incomingEntityMessage);
}
