public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession?session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
switch (message)
{
case ClickAlertMessage msg:
{
var player = session.AttachedEntity.GetValueOrDefault();
if (player != Owner)
{
break;
}
if (!IsShowingAlert(msg.Type))
{
Logger.DebugS("alert", "user {0} attempted to" +
" click alert {1} which is not currently showing for them",
IoCManager.Resolve <IEntityManager>().GetComponent <MetaDataComponent>(player).EntityName, msg.Type);
break;
}
if (!AlertManager.TryGet(msg.Type, out var alert))
{
Logger.WarningS("alert", "unrecognized encoded alert {0}", msg.Type);
break;
}
alert.OnClick?.AlertClicked(new ClickAlertEventArgs(player, alert));
break;
}
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel channel, ICommonSession session = null)
{
base.HandleNetworkMessage(message, channel, session);
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
switch (message)
{
case SyncFirePosMessage msg:
var user = session.AttachedEntity;
if (user == null)
{
return;
}
_tryFire(user, msg.Target);
break;
}
}
/// <summary>
/// Receives messages to remove entities from storage, verifies the player can do them,
/// and puts the removed entity in hand or on the ground
/// </summary>
/// <param name="message"></param>
/// <param name="netChannel"></param>
/// <param name="component"></param>
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case RemoveEntityMessage msg:
var playerMan = IoCManager.Resolve <IPlayerManager>();
var session = playerMan.GetSessionByChannel(netChannel);
var playerentity = session.AttachedEntity;
var ourtransform = Owner.GetComponent <TransformComponent>();
var playertransform = playerentity.GetComponent <TransformComponent>();
if (playertransform.LocalPosition.InRange(ourtransform.LocalPosition, 2) &&
(ourtransform.IsMapTransform || playertransform.ContainsEntity(ourtransform)))
{
var remove = (RemoveEntityMessage)message;
var entity = IoCManager.Resolve <IEntityManager>().GetEntity(remove.EntityUid);
if (entity != null && storage.Contains(entity))
{
Remove(entity);
UpdateClientInventory();
var item = entity.GetComponent <ItemComponent>();
if (item != null && playerentity.TryGetComponent(out HandsComponent hands))
{
if (hands.PutInHand(item))
{
return;
}
}
entity.GetComponent <TransformComponent>().WorldPosition = Owner.GetComponent <TransformComponent>().WorldPosition;
}
}
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case BumpedEntMsg msg:
if (_state != DoorState.Closed)
{
return;
}
// Only open when bumped by mobs.
if (!msg.Entity.HasComponent(typeof(SpeciesComponent)))
{
return;
}
Open();
break;
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession?session = null)
{
if (!Owner.TryGetComponent(out ISpriteComponent? sprite))
{
return;
}
switch (message)
{
case BodyPartAddedMessage partAdded:
sprite.LayerSetVisible(partAdded.RSIMap, true);
sprite.LayerSetRSI(partAdded.RSIMap, partAdded.RSIPath);
sprite.LayerSetState(partAdded.RSIMap, partAdded.RSIState);
break;
case BodyPartRemovedMessage partRemoved:
sprite.LayerSetVisible(partRemoved.RSIMap, false);
if (!partRemoved.Dropped.HasValue ||
!_entityManager.TryGetEntity(partRemoved.Dropped.Value, out var entity) ||
!entity.TryGetComponent(out ISpriteComponent? droppedSprite))
{
break;
}
var color = sprite[partRemoved.RSIMap].Color;
droppedSprite.LayerSetColor(0, color);
break;
case MechanismSpriteAddedMessage mechanismAdded:
sprite.LayerSetVisible(mechanismAdded.RSIMap, true);
break;
case MechanismSpriteRemovedMessage mechanismRemoved:
sprite.LayerSetVisible(mechanismRemoved.RSIMap, false);
break;
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession?session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
if (session?.AttachedEntity != Owner)
{
return;
}
switch (message)
{
case CharacterInfoMessage characterInfoMessage:
_control.UpdateUI(characterInfoMessage);
if (Owner.TryGetComponent(out ISpriteComponent? spriteComponent))
{
_control.SpriteView.Sprite = spriteComponent;
}
_control.NameLabel.Text = Owner.Name;
break;
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
switch (message)
{
case BoundInterfaceMessageWrapMessage wrapped:
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (!_interfaces.TryGetValue(wrapped.UiKey, out var @interface))
{
Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}",
wrapped.UiKey);
return;
}
@interface.ReceiveMessage(wrapped.Message, session as IPlayerSession);
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case PlayerAttachedMsg _:
if (ConstructionMenu == null)
{
ConstructionMenu = new ConstructionMenu {
Owner = this
};
ConstructionMenu.OnClose += () => _gameHud.CraftingButtonDown = false;
}
_gameHud.CraftingButtonVisible = true;
_gameHud.CraftingButtonToggled = b =>
{
if (b)
{
ConstructionMenu.Open();
}
else
{
ConstructionMenu.Close();
}
};
break;
case PlayerDetachedMsg _:
_gameHud.CraftingButtonVisible = false;
break;
case AckStructureConstructionMessage ackMsg:
ClearGhost(ackMsg.Ack);
break;
}
}
/// <inheritdoc />
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null,
IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case ClientInventoryMessage msg:
var playerMan = IoCManager.Resolve <IPlayerManager>();
var session = playerMan.GetSessionByChannel(netChannel);
var playerentity = session.AttachedEntity;
if (playerentity == Owner)
{
HandleInventoryMessage(msg);
}
break;
case OpenSlotStorageUIMessage msg:
if (!HasSlot(msg.Slot)) // client input sanitization
{
return;
}
var item = GetSlotItem(msg.Slot);
if (item != null && item.Owner.TryGetComponent(out ServerStorageComponent storage))
{
storage.OpenStorageUI(Owner);
}
break;
case ContainerContentsModifiedMessage msg:
if (msg.Removed)
{
ForceUnequip(msg.Container, msg.Entity);
}
break;
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession?session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
switch (message)
{
case GhostReplyWarpPointData data:
WarpNames = new List <string>();
foreach (var names in data.WarpName)
{
WarpNames.Add(names);
}
break;
case GhostReplyPlayerNameData data:
PlayerNames = new Dictionary <EntityUid, string>();
foreach (var(key, value) in data.PlayerNames)
{
PlayerNames.Add(key, value);
}
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case OpenDataWindowMsg msg:
if (LastWindow != null && !LastWindow.Disposed)
{
LastWindow.Dispose();
}
LastWindow = new SS14Window()
{
Title = "Power Debug Tool",
};
LastWindow.Contents.AddChild(new Label()
{
Text = msg.Data
});
LastWindow.Open();
break;
}
}
public override void HandleMessage(ComponentMessage message, IComponent component)
{
base.HandleMessage(message, component);
switch (message)
{
case PlayerAttachedMsg _:
if (ConstructionMenu == null)
{
ConstructionMenu = new ConstructionMenu {
Owner = this
};
ConstructionMenu.OnClose += () => _gameHud.CraftingButtonDown = false;
}
_gameHud.CraftingButtonVisible = true;
_gameHud.CraftingButtonToggled = b =>
{
if (b)
{
ConstructionMenu.Open();
}
else
{
ConstructionMenu.Close();
}
};
break;
case PlayerDetachedMsg _:
_gameHud.CraftingButtonVisible = false;
break;
default:
break;
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
switch (message)
{
case ClickStatusMessage msg:
{
var player = session.AttachedEntity;
if (player != Owner)
{
break;
}
// TODO: Implement clicking other status effects in the HUD
switch (msg.Effect)
{
case StatusEffect.Buckled:
if (!player.TryGetComponent(out BuckleComponent buckle))
{
break;
}
buckle.TryUnbuckle(player);
break;
}
break;
}
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null,
IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case PlayerAttachedMsg _:
if (Window != null)
{
_gameHud.CharacterButtonVisible = true;
_gameHud.CharacterButtonToggled = b =>
{
if (b)
{
Window.Open();
}
else
{
Window.Close();
}
};
}
break;
case PlayerDetachedMsg _:
if (Window != null)
{
_gameHud.CharacterButtonVisible = false;
Window.Close();
}
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null,
IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case BoundInterfaceMessageWrapMessage wrapped:
if (netChannel == null)
{
throw new ArgumentNullException(nameof(netChannel));
}
var session = _playerManager.GetSessionById(netChannel.SessionId);
if (!_interfaces.TryGetValue(wrapped.UiKey, out var @interface))
{
Logger.DebugS("go.comp.ui", "Got BoundInterfaceMessageWrapMessage for unknown UI key: {0}",
wrapped.UiKey);
return;
}
@interface.ReceiveMessage(wrapped.Message, session);
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case PlayerAttachedMsg _:
if (Button == null)
{
Button = new ConstructionButton();
Button.Owner = this;
}
Button.AddToScreen();
break;
case PlayerDetachedMsg _:
Button.RemoveFromScreen();
break;
case AckStructureConstructionMessage ackMsg:
ClearGhost(ackMsg.Ack);
break;
}
}
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
switch (message)
{
case HudStateChange msg:
if (CurrentlyControlled)
{
ChangeHudIcon(msg);
}
break;
case PlayerAttachedMsg _:
_ui.Parent?.RemoveChild(_ui);
_userInterfaceManager.StateRoot.AddChild(_ui);
ApplyOverlay();
break;
case PlayerDetachedMsg _:
_ui.Parent?.RemoveChild(_ui);
RemoveOverlay();
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="componentMessage"></param>
public void PostComponentMessage(ComponentMessage componentMessage)
{
m_ComponentManager.PostComponentMessage(componentMessage);
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
switch (message)
{
case ClickStatusMessage msg:
{
var player = session.AttachedEntity;
if (player != Owner)
{
break;
}
// TODO: Implement clicking other status effects in the HUD
switch (msg.Effect)
{
case StatusEffect.Buckled:
if (!player.TryGetComponent(out BuckleComponent buckle))
{
break;
}
buckle.TryUnbuckle(player);
break;
case StatusEffect.Piloting:
if (!player.TryGetComponent(out ShuttleControllerComponent controller))
{
break;
}
controller.RemoveController();
break;
case StatusEffect.Pulling:
if (!player.TryGetComponent(out HandsComponent hands))
{
break;
}
hands.StopPull();
break;
case StatusEffect.Fire:
if (!player.TryGetComponent(out FlammableComponent flammable))
{
break;
}
flammable.Resist();
break;
default:
player.PopupMessage(msg.Effect.ToString());
break;
}
break;
}
}
}
/// <inheritdoc />
public void SendComponentNetworkMessage(IEntity entity, IComponent component, ComponentMessage message)
{
if (!component.NetID.HasValue)
{
throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
}
var msg = _network.CreateNetMessage <MsgEntity>();
msg.Type = EntityMessageType.ComponentMessage;
msg.EntityUid = entity.Uid;
msg.NetId = component.NetID.Value;
msg.ComponentMessage = message;
_network.ClientSendMessage(msg);
}
/// <inheritdoc />
public void SendDirectedComponentNetworkMessage(INetChannel channel, IEntity entity, IComponent component, ComponentMessage message)
{
SendComponentNetworkMessage(entity, component, message);
}
/// <inheritdoc />
public void SendComponentNetworkMessage(INetChannel channel, IEntity entity, IComponent component, ComponentMessage message)
{
if (_mNetManager.IsClient)
{
return;
}
if (!component.NetID.HasValue)
{
throw new ArgumentException($"Component {component.Name} does not have a NetID.", nameof(component));
}
var msg = _mNetManager.CreateNetMessage <MsgEntity>();
msg.Type = EntityMessageType.ComponentMessage;
msg.EntityUid = entity.Uid;
msg.NetId = component.NetID.Value;
msg.ComponentMessage = message;
//Send the message
if (channel == null)
{
_mNetManager.ServerSendToAll(msg);
}
else
{
_mNetManager.ServerSendMessage(msg, channel);
}
}
/// <summary>
/// Receives messages to remove entities from storage, verifies the player can do them,
/// and puts the removed entity in hand or on the ground
/// </summary>
/// <param name="message"></param>
/// <param name="channel"></param>
/// <param name="session"></param>
public override void HandleNetworkMessage(ComponentMessage message, INetChannel channel, ICommonSession session = null)
{
base.HandleNetworkMessage(message, channel, session);
if (session == null)
{
throw new ArgumentException(nameof(session));
}
switch (message)
{
case RemoveEntityMessage _:
{
_ensureInitialCalculated();
var playerentity = session.AttachedEntity;
var ourtransform = Owner.GetComponent <ITransformComponent>();
var playertransform = playerentity.GetComponent <ITransformComponent>();
if (playertransform.GridPosition.InRange(_mapManager, ourtransform.GridPosition, 2) &&
(ourtransform.IsMapTransform || playertransform.ContainsEntity(ourtransform)))
{
var remove = (RemoveEntityMessage)message;
var entity = _entityManager.GetEntity(remove.EntityUid);
if (entity != null && storage.Contains(entity))
{
var item = entity.GetComponent <ItemComponent>();
if (item != null && playerentity.TryGetComponent(out HandsComponent hands))
{
if (hands.CanPutInHand(item) && hands.PutInHand(item))
{
return;
}
}
}
}
break;
}
case InsertEntityMessage _:
{
_ensureInitialCalculated();
var playerEntity = session.AttachedEntity;
var storageTransform = Owner.GetComponent <ITransformComponent>();
var playerTransform = playerEntity.GetComponent <ITransformComponent>();
// TODO: Replace by proper entity range check once it is implemented.
if (playerTransform.GridPosition.InRange(_mapManager,
storageTransform.GridPosition,
InteractionSystem.InteractionRange))
{
PlayerInsertEntity(playerEntity);
}
break;
}
case CloseStorageUIMessage _:
{
UnsubscribeSession(session as IPlayerSession);
break;
}
}
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel channel, ICommonSession?session = null)
{
base.HandleNetworkMessage(message, channel, session);
if (session == null)
{
throw new ArgumentException(nameof(session));
}
switch (message)
{
case RemoveEntityMessage remove:
{
EnsureInitialCalculated();
var player = session.AttachedEntity;
if (player == null)
{
break;
}
var ownerTransform = Owner.Transform;
var playerTransform = player.Transform;
if (!playerTransform.GridPosition.InRange(_mapManager, ownerTransform.GridPosition, 2) ||
!ownerTransform.IsMapTransform &&
!playerTransform.ContainsEntity(ownerTransform))
{
break;
}
var entity = _entityManager.GetEntity(remove.EntityUid);
if (entity == null || _storage?.Contains(entity) == false)
{
break;
}
var item = entity.GetComponent <ItemComponent>();
if (item == null ||
!player.TryGetComponent(out HandsComponent hands))
{
break;
}
if (!hands.CanPutInHand(item))
{
break;
}
hands.PutInHand(item);
break;
}
case InsertEntityMessage _:
{
EnsureInitialCalculated();
var player = session.AttachedEntity;
if (player == null)
{
break;
}
var storagePosition = Owner.Transform.MapPosition;
if (!InteractionChecks.InRangeUnobstructed(player, storagePosition))
{
break;
}
PlayerInsertEntity(player);
break;
}
case CloseStorageUIMessage _:
{
if (!(session is IPlayerSession playerSession))
{
break;
}
UnsubscribeSession(playerSession);
break;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="componentId"></param>
/// <param name="componentMessage"></param>
public void SubScribeComponentMessage(ComponentMessage componentMessage, ComponentId componentId)
{
m_ComponentManager.SubScribeComponentMessage(componentMessage, componentId);
}
public void SendComponentNetworkMessage(IEntity entity, IComponent component, ComponentMessage message)
{
throw new NotImplementedException();
}
public override void HandleNetworkMessage(ComponentMessage message, INetChannel netChannel, ICommonSession?session = null)
{
base.HandleNetworkMessage(message, netChannel, session);
if (message is not BasePerformActionMessage performActionMessage)
{
return;
}
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
var player = session.AttachedEntity;
if (player != Owner)
{
return;
}
var attempt = ActionAttempt(performActionMessage, session);
if (attempt == null)
{
return;
}
if (!attempt.TryGetActionState(this, out var actionState) || !actionState.Enabled)
{
Logger.DebugS("action", "user {0} attempted to use" +
" action {1} which is not granted to them", player.Name,
attempt);
return;
}
if (actionState.IsOnCooldown(GameTiming))
{
Logger.DebugS("action", "user {0} attempted to use" +
" action {1} which is on cooldown", player.Name,
attempt);
return;
}
switch (performActionMessage.BehaviorType)
{
case BehaviorType.Instant:
attempt.DoInstantAction(player);
break;
case BehaviorType.Toggle:
if (performActionMessage is not IToggleActionMessage toggleMsg)
{
return;
}
if (toggleMsg.ToggleOn == actionState.ToggledOn)
{
Logger.DebugS("action", "user {0} attempted to" +
" toggle action {1} to {2}, but it is already toggled {2}", player.Name,
attempt.Action.Name, toggleMsg.ToggleOn);
return;
}
if (attempt.DoToggleAction(player, toggleMsg.ToggleOn))
{
attempt.ToggleAction(this, toggleMsg.ToggleOn);
}
else
{
// if client predicted the toggle will work, need to reset
// that prediction
Dirty();
}
break;
case BehaviorType.TargetPoint:
if (performActionMessage is not ITargetPointActionMessage targetPointMsg)
{
return;
}
if (!CheckRangeAndSetFacing(targetPointMsg.Target, player))
{
return;
}
attempt.DoTargetPointAction(player, targetPointMsg.Target);
break;
case BehaviorType.TargetEntity:
if (performActionMessage is not ITargetEntityActionMessage targetEntityMsg)
{
return;
}
if (!EntityManager.TryGetEntity(targetEntityMsg.Target, out var entity))
{
Logger.DebugS("action", "user {0} attempted to" +
" perform target entity action {1} but could not find entity with " +
"provided uid {2}", player.Name, attempt.Action.Name,
targetEntityMsg.Target);
return;
}
if (!CheckRangeAndSetFacing(entity.Transform.Coordinates, player))
{
return;
}
attempt.DoTargetEntityAction(player, entity);
break;
case BehaviorType.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
///
/// </summary>
/// <param name="componentMessage"></param>
public void OnHandleComponentMessage(ComponentMessage componentMessage)
{
m_ComponentManager.OnHandleComponentMessage(componentMessage);
}
virtual public void ReceiveMessage(ComponentMessage type, int param)
{
}
/// <summary>
/// Receives messages to remove entities from storage, verifies the player can do them,
/// and puts the removed entity in hand or on the ground
/// </summary>
/// <param name="message"></param>
/// <param name="netChannel"></param>
/// <param name="component"></param>
public override void HandleMessage(ComponentMessage message, INetChannel netChannel = null, IComponent component = null)
{
base.HandleMessage(message, netChannel, component);
switch (message)
{
case RemoveEntityMessage _:
{
_ensureInitialCalculated();
var session = _playerManager.GetSessionByChannel(netChannel);
var playerentity = session.AttachedEntity;
var ourtransform = Owner.GetComponent <ITransformComponent>();
var playertransform = playerentity.GetComponent <ITransformComponent>();
if (playertransform.GridPosition.InRange(_mapManager, ourtransform.GridPosition, 2) &&
(ourtransform.IsMapTransform || playertransform.ContainsEntity(ourtransform)))
{
var remove = (RemoveEntityMessage)message;
var entity = _entityManager.GetEntity(remove.EntityUid);
if (entity != null && storage.Contains(entity))
{
Remove(entity);
var item = entity.GetComponent <ItemComponent>();
if (item != null && playerentity.TryGetComponent(out HandsComponent hands))
{
if (hands.PutInHand(item))
{
return;
}
}
entity.GetComponent <ITransformComponent>().WorldPosition = ourtransform.WorldPosition;
}
}
break;
}
case InsertEntityMessage _:
{
_ensureInitialCalculated();
var playerEntity = _playerManager.GetSessionByChannel(netChannel).AttachedEntity;
var storageTransform = Owner.GetComponent <ITransformComponent>();
var playerTransform = playerEntity.GetComponent <ITransformComponent>();
// TODO: Replace by proper entity range check once it is implemented.
if (playerTransform.GridPosition.InRange(_mapManager,
storageTransform.GridPosition,
InteractionSystem.InteractionRange))
{
PlayerInsertEntity(playerEntity);
}
break;
}
case CloseStorageUIMessage _:
{
var session = _playerManager.GetSessionByChannel(netChannel);
UnsubscribeSession(session);
break;
}
}
}
