/// <summary>
/// This is all kinds of f****d, but basically it marshals an SVar from the client and poops
/// it forward to the component named in the message.
/// </summary>
/// <param name="message"></param>
/// <param name="client"></param>
internal void HandleSetSVar(byte[] serializedParameter, NetConnection client)
{
MarshalComponentParameter parameter = MarshalComponentParameter.Deserialize(serializedParameter);
IPlayerSession player = IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(client);
Owner.GetComponent <Component>(parameter.Family).SetSVar(parameter);
Logger.Log("Player " + player.name + " set SVar."); //Make this message better
}
/// <summary>
/// Sends an SVar to the server to be set on the server-side entity.
/// </summary>
/// <param name="sendingEntity"></param>
/// <param name="svar"></param>
public void SendSVar(Entity sendingEntity, MarshalComponentParameter svar)
{
NetOutgoingMessage message = CreateEntityMessage();
message.Write((byte)EntityMessage.SetSVar);
message.Write(sendingEntity.Uid);
svar.Serialize(message);
_networkManager.SendMessage(message, NetDeliveryMethod.ReliableUnordered);
}
/// <summary>
/// Sets a component parameter via the sVar interface. Only
/// parameters that are registered as sVars will be set through this
/// function.
/// </summary>
/// <param name="sVar">ComponentParameter</param>
public void SetSVar(MarshalComponentParameter sVar)
{
ComponentParameter param = sVar.Parameter;
//If it is registered, and the types match, set it.
if (_sVars.ContainsKey(param.MemberName) &&
_sVars[param.MemberName] == param.ParameterType)
{
SetParameter(param);
}
}
/// <summary>
/// This is all kinds of f****d, but basically it marshals an SVar from the client and poops
/// it forward to the component named in the message.
/// </summary>
/// <param name="message"></param>
/// <param name="client"></param>
internal void HandleSetSVar(byte[] serializedParameter, NetConnection client)
{
MarshalComponentParameter parameter = MarshalComponentParameter.Deserialize(serializedParameter);
//Check admin status -- only admins can get svars.
IPlayerSession player = IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(client);
if (!player.adminPermissions.isAdmin)
{
LogManager.Log("Player " + player.name + " tried to set an SVar, but is not an admin!", LogLevel.Warning);
}
else
{
Owner.GetComponent <Component>(parameter.Family).SetSVar(parameter);
LogManager.Log("Player " + player.name + " set SVar."); //Make this message better
}
}
public void HandleGetSVars(IncomingEntityComponentMessage message)
{
//If nothing's listening, then why bother with this shit?
if (GetSVarsCallback == null)
{
return;
}
var count = (int)message.MessageParameters[1];
var svars = new List <MarshalComponentParameter>();
for (int i = 2; i < count + 2; i++)
{
svars.Add(MarshalComponentParameter.Deserialize((byte[])message.MessageParameters[i]));
}
GetSVarsCallback(this, new GetSVarsEventArgs(svars));
GetSVarsCallback = null;
}
private GuiComponent CreateEditField(MarshalComponentParameter compPar)
{
if (compPar.Parameter.ParameterType == typeof(float) || compPar.Parameter.ParameterType == typeof(int) ||
compPar.Parameter.ParameterType == typeof(String))
{
var editTxt = new Textbox(100, _resourceManager);
editTxt.ClearOnSubmit = false;
editTxt.UserData = compPar;
editTxt.Text = compPar.Parameter.Parameter.ToString();
editTxt.OnSubmit += editTxt_OnSubmit;
return(editTxt);
}
else if (compPar.Parameter.ParameterType == typeof(Boolean))
{
var editBool = new Checkbox(_resourceManager);
editBool.UserData = compPar;
editBool.Value = ((Boolean)compPar.Parameter.Parameter);
editBool.ValueChanged += editBool_ValueChanged;
return(editBool);
}
return(null);
}
public void DoSetSVar(MarshalComponentParameter svar)
{
Owner.SendComponentNetworkMessage(this, NetDeliveryMethod.ReliableUnordered, ComponentMessageType.SetSVar,
svar.Serialize());
}
/// <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);
}
