/// <summary>
/// Sends a message to the relevant system(s) on the target client.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message,
NetConnection targetConnection = null,
NetDeliveryMethod method = NetDeliveryMethod.ReliableUnordered)
{
NetOutgoingMessage newMsg = CreateEntityMessage();
newMsg.Write((byte)EntityMessage.SystemMessage);
var stream = new MemoryStream();
Serializer.Serialize(stream, message);
newMsg.Write((int)stream.Length);
newMsg.Write(stream.ToArray());
if (_messageProfiling)
{
//Log the message
}
//Send the message
if (targetConnection != null)
{
m_netServer.SendMessage(newMsg, targetConnection, method);
}
else
{
m_netServer.SendToAll(newMsg, method);
}
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
if (!(message is ExamineSystemMessages.RequestExamineInfoMessage request))
{
return;
}
var session = _playerManager.GetSessionByChannel(channel);
var playerEnt = session.AttachedEntity;
if (playerEnt == null ||
!_entityManager.TryGetEntity(request.EntityUid, out var entity) ||
!CanExamine(playerEnt, entity))
{
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(
request.EntityUid, _entityNotFoundMessage), channel);
return;
}
var text = GetExamineText(entity);
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(request.EntityUid, text), channel);
}
/// <inheritdoc />
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
if (!(message is FullInputCmdMessage msg))
return;
//Client Sanitization: out of bounds functionID
if (!IoCManager.Resolve<IPlayerManager>().KeyMap.TryGetKeyFunction(msg.InputFunctionId, out var function))
return;
var session = IoCManager.Resolve<IPlayerManager>().GetSessionByChannel(channel);
//Client Sanitization: bad enum key state value
if (!Enum.IsDefined(typeof(BoundKeyState), msg.State))
return;
// route the cmdMessage to the proper bind
//Client Sanitization: unbound command, just ignore
if (_bindMap.TryGetHandler(function, out var command))
{
// set state, only bound key functions get state changes
var states = GetInputStates(session);
states.SetState(function, msg.State);
command.HandleCmdMessage(session, msg);
}
}
private static void HandleParented(object sender, EntitySystemMessage args)
{
var msg = (EntParentChangedMessage)args;
// entity is no longer a child of OldParent, therefore it cannot be in the hand of the parent
if (msg.OldParent != null && msg.OldParent.IsValid() && msg.OldParent.Transform != msg.Entity.Transform.Parent && msg.OldParent.TryGetComponent(out IHandsComponent handsComp))
{
handsComp.RemoveHandEntity(msg.Entity);
}
if (msg.Entity.Deleted)
{
return;
}
// if item is in a container
if (msg.Entity.Transform.IsMapTransform)
{
return;
}
if (!msg.Entity.TryGetComponent(out PhysicsComponent physics))
{
return;
}
// set velocity to zero
physics.LinearVelocity = Vector2.Zero;
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
if (!(message is ExamineSystemMessages.RequestExamineInfoMessage request))
{
return;
}
var session = _playerManager.GetSessionByChannel(channel);
var playerEnt = session.AttachedEntity;
if ((playerEnt == null) ||
(!_entityManager.TryGetEntity(request.EntityUid, out var entity)) ||
(entity.Transform.MapID != playerEnt.Transform.MapID) ||
((entity.Transform.WorldPosition - playerEnt.Transform.WorldPosition).LengthSquared > ExamineRangeSquared))
{
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(
request.EntityUid, _entityNotFoundMessage));
return;
}
var text = GetExamineText(entity);
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(request.EntityUid, text));
}
#pragma warning restore 649
/// <summary>
/// Sends a message to the relevant system(s) server side.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message)
{
var msg = _network.CreateNetMessage <MsgEntity>();
msg.Type = EntityMessageType.SystemMessage;
msg.SystemMessage = message;
_network.ClientSendMessage(msg);
}
/// <summary>
/// Sends a message to the relevant system(s) on all clients.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message)
{
var newMsg = _mNetManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessageType.SystemMessage;
newMsg.SystemMessage = message;
_mNetManager.ServerSendToAll(newMsg);
}
/// <summary>
/// Sends a message to the relevant system(s) on the target client.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel targetConnection)
{
var newMsg = _mNetManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessageType.SystemMessage;
newMsg.SystemMessage = message;
_mNetManager.ServerSendMessage(newMsg, targetConnection);
}
/// <inheritdoc />
public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel targetConnection)
{
var newMsg = _networkManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessageType.SystemMessage;
newMsg.SystemMessage = message;
newMsg.SourceTick = _gameTiming.CurTick;
_networkManager.ServerSendMessage(newMsg, targetConnection);
}
/// <inheritdoc />
public void SendSystemNetworkMessage(EntitySystemMessage message)
{
var newMsg = _networkManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessageType.SystemMessage;
newMsg.SystemMessage = message;
newMsg.SourceTick = _gameTiming.CurTick;
_networkManager.ServerSendToAll(newMsg);
}
public void SendSystemNetworkMessage(EntitySystemMessage message, uint sequence)
{
var msg = _networkManager.CreateNetMessage <MsgEntity>();
msg.Type = EntityMessageType.SystemMessage;
msg.SystemMessage = message;
msg.SourceTick = _gameTiming.CurTick;
msg.Sequence = sequence;
_networkManager.ClientSendMessage(msg);
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
switch (message)
{
case EffectSystemMessage msg:
CreateEffect(msg);
break;
}
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
switch (message)
{
case PlayMeleeWeaponAnimationMessage playMsg:
PlayWeaponArc(playMsg);
break;
}
}
private void OnAttachedEntityChanged(object sender, EntitySystemMessage message)
{
if (!(message is PlayerAttachSysMessage msg))
{
return;
}
if (msg.AttachedEntity != null) // attach
{
SetEntityContextActive(_inputManager, msg.AttachedEntity);
}
else // detach
{
_inputManager.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
}
}
/// <summary>
/// Sends a message to the relevant system(s) serverside.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message,
NetDeliveryMethod method = NetDeliveryMethod.ReliableUnordered)
{
NetOutgoingMessage newMsg = CreateEntityMessage();
newMsg.Write((byte)EntityMessage.SystemMessage);
using (var stream = new MemoryStream())
{
serializer.Serialize(stream, message);
newMsg.Write((int)stream.Length);
newMsg.Write(stream.ToArray());
}
//Send the message
_networkManager.ClientSendMessage(newMsg, method);
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
if (message is ExamineSystemMessages.RequestExamineInfoMessage request)
{
if (!_entityManager.TryGetEntity(request.EntityUid, out var entity))
{
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(
request.EntityUid, _entityNotFoundMessage));
return;
}
var text = GetExamineText(entity);
RaiseNetworkEvent(new ExamineSystemMessages.ExamineInfoResponseMessage(request.EntityUid, text));
}
}
/// <summary>
/// Sends a message to the relevant system(s) on the target client.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel targetConnection = null)
{
var newMsg = _mNetManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessageType.SystemMessage;
newMsg.SystemMessage = message;
//Send the message
if (targetConnection != null)
{
_mNetManager.ServerSendMessage(newMsg, targetConnection);
}
else
{
_mNetManager.ServerSendToAll(newMsg);
}
}
private static void OnAttachedEntityChanged(object sender, EntitySystemMessage message)
{
if (!(message is PlayerAttachSysMessage msg))
{
return;
}
var inputMan = IoCManager.Resolve <IInputManager>();
if (msg.AttachedEntity != null) // attach
{
SetEntityContextActive(inputMan, msg.AttachedEntity);
}
else // detach
{
inputMan.Contexts.SetActiveContext(InputContextContainer.DefaultContextName);
}
}
private bool TryGetCombatComponent(EntitySystemMessage ev, out CombatModeComponent combatModeComponent)
{
if (ev.NetChannel == null)
{
combatModeComponent = default;
return(false);
}
var player = _playerManager.GetSessionByChannel(ev.NetChannel);
if (player.AttachedEntity != null && player.AttachedEntity.TryGetComponent(out combatModeComponent))
{
return(true);
}
combatModeComponent = default;
return(false);
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
if (!(message is AudioMessage msg))
{
return;
}
try
{
switch (message)
{
case PlayAudioGlobalMessage globalmsg:
Play(globalmsg.FileName, globalmsg.AudioParams);
break;
case PlayAudioEntityMessage entitymsg:
if (!EntityManager.TryGetEntity(entitymsg.EntityUid, out var entity))
{
Logger.Error(
$"Server tried to play audio file {entitymsg.FileName} on entity {entitymsg.EntityUid} which does not exist.");
break;
}
Play(entitymsg.FileName, entity, entitymsg.AudioParams);
break;
case PlayAudioPositionalMessage posmsg:
if (!_mapManager.GridExists(posmsg.Coordinates.GridID))
{
Logger.Error($"Server tried to play sound on grid {posmsg.Coordinates.GridID.Value}, which does not exist. Ignoring.");
break;
}
Play(posmsg.FileName, posmsg.Coordinates, posmsg.AudioParams);
break;
}
}
catch (FileNotFoundException)
{
Logger.Error($"Server tried to play audio file {msg.FileName} which does not exist.");
}
}
/// <summary>
/// Sends a message to the relevant system(s) on the target client.
/// </summary>
public void SendSystemNetworkMessage(EntitySystemMessage message,
INetChannel targetConnection = null,
NetDeliveryMethod method = NetDeliveryMethod.ReliableUnordered)
{
MsgEntity newMsg = _mNetManager.CreateNetMessage <MsgEntity>();
newMsg.Type = EntityMessage.SystemMessage;
newMsg.SystemMessage = message;
//Send the message
if (targetConnection != null)
{
_mNetManager.ServerSendMessage(newMsg, targetConnection);
}
else
{
_mNetManager.ServerSendToAll(newMsg);
}
}
//Grab click events sent from the client input system
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
var playerMan = IoCManager.Resolve <IPlayerManager>();
var session = playerMan.GetSessionByChannel(channel);
var playerentity = session.AttachedEntity;
if (playerentity == null)
{
return;
}
switch (message)
{
case ClickEventMessage msg:
UserInteraction(msg, playerentity);
break;
}
}
public override void HandleNetMessage(EntitySystemMessage sysMsg)
{
if (sysMsg is InventorySystemPickUp)
{
InventorySystemPickUp message = sysMsg as InventorySystemPickUp;
Entity user = EntityManager.GetEntity(message.uidUser);
Entity obj = EntityManager.GetEntity(message.uidObject);
if (user != null && obj != null)
{
PickUpEntity(user, obj);
}
}
else if (sysMsg is InventorySystemDrop)
{
InventorySystemDrop message = sysMsg as InventorySystemDrop;
Entity user = EntityManager.GetEntity(message.uidUser);
Entity obj = EntityManager.GetEntity(message.uidObject);
Entity dropping = EntityManager.GetEntity(message.uidDroppingInventory);
if (user != null && obj != null && dropping != null)
{
RemoveEntity(user, dropping, obj);
}
}
else if (sysMsg is InventorySystemExchange) //TODO: Add argument for target inventory type.
{
InventorySystemExchange message = sysMsg as InventorySystemExchange;
Entity user = EntityManager.GetEntity(message.uidUser);
Entity obj = EntityManager.GetEntity(message.uidObject);
Entity prevInv = EntityManager.GetEntity(message.uidPreviousInventory);
Entity newInv = EntityManager.GetEntity(message.uidNewInventory);
if (user != null && obj != null && prevInv != null && newInv != null)
{
ExchangeEntity(user, prevInv, newInv, obj);
}
}
}
/// <inheritdoc />
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
var playerMan = IoCManager.Resolve <IPlayerManager>();
var session = playerMan.GetSessionByChannel(channel);
var entity = session.AttachedEntity;
if (entity == null)
{
return;
}
switch (message)
{
case BoundKeyChangedMessage msg:
entity.SendMessage(null, new BoundKeyChangedMsg(msg.Function, msg.State));
msg.Owner = entity.Uid;
RaiseEvent(msg);
break;
}
}
public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
{
base.HandleNetMessage(channel, message);
var player = _playerManager.GetSessionByChannel(channel);
if (player.AttachedEntity == null ||
!player.AttachedEntity.TryGetComponent(out CombatModeComponent combatModeComponent))
{
return;
}
switch (message)
{
case SetTargetZoneMessage setTargetZone:
combatModeComponent.ActiveZone = setTargetZone.TargetZone;
break;
case SetCombatModeActiveMessage setActive:
combatModeComponent.IsInCombatMode = setActive.Active;
break;
}
}
private static void HandleParented(object sender, EntitySystemMessage args)
{
var msg = (EntParentChangedMessage)args;
if (!msg.Entity.TryGetComponent(out ITransformComponent transform))
{
return;
}
// if item is in a container
if (transform.IsMapTransform)
{
return;
}
if (!msg.Entity.TryGetComponent(out PhysicsComponent physics))
{
return;
}
// set velocity to zero
physics.LinearVelocity = Vector2.Zero;
}
private static void HandleParentChanged(object sender, EntitySystemMessage message)
{
if (!(sender is IEntity childEntity))
{
return;
}
if (!(message is EntParentChangedMessage msg))
{
return;
}
var oldParentEntity = msg.OldParent;
if (oldParentEntity == null || !oldParentEntity.IsValid())
{
return;
}
if (oldParentEntity.TryGetComponent(out ServerStorageComponent storageComp))
{
storageComp.Remove(childEntity);
}
}
public override void HandleNetMessage(EntitySystemMessage sysMsg)
{
base.HandleNetMessage(sysMsg);
}
public void SendSystemNetworkMessage(EntitySystemMessage message, INetChannel channel)
{
throw new NotSupportedException();
}
protected void RaiseNetworkEvent(EntitySystemMessage message, INetChannel channel)
{
EntityNetworkManager.SendSystemNetworkMessage(message, channel);
}
