public IdleDisconnectProcessor(TimeSpan idleTimeout, INetChannel channel)
 {
     _lastReceivedTime = DateTime.UtcNow;
     Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(_ => KillIfIdle());
     _idleTimeout = idleTimeout;
     _channel = channel;
 }
Esempio n. 2
0
 public MsgEntity(INetChannel channel)
     : base(NAME, GROUP, ID)
 {
 }
 public void Thrown(ThrownEventArgs eventArgs)
 {
     SendNetworkMessage(new InstrumentStopMidiMessage());
     _instrumentPlayer = null;
     _userInterface.CloseAll();
 }
 public void DisconnectChannel(INetChannel channel, string reason)
 {
     channel.Disconnect(reason);
 }
Esempio n. 5
0
        /// <inheritdoc />
        public void ServerSendMessage(NetMessage message, INetChannel recipient)
        {
            var packet = BuildMessage(message);

            ServerSendMessage(packet, recipient.Connection);
        }
        /// <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))
                        {
                            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 = 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 void NetChannelRequestStarted(INetNode node, INetChannel channel, Message request, Guid requestId)
 {
     if (_logger.IsEnabled(LogEventLevel.Debug))
         _logger.Debug("NetNode {@node} on NetChannel {@channel} sending request {@message} with id {requestId}", node, channel, request, requestId);
 }
Esempio n. 8
0
 public NetDisconnectedArgs(INetChannel channel, string reason) : base(channel)
 {
     Reason = reason;
 }
 public void NetChannelDisconnected(INetNode node, INetChannel channel)
 {
     if (_logger.IsEnabled(LogEventLevel.Debug))
         _logger.Debug("NetNode {@node} NetChannel {@channel} has disconnected", node, channel);
 }
 public void ConnectionSucceeded(INetNode node, IPEndPoint address, INetChannel channel, int durationMs)
 {
     if (_logger.IsEnabled(LogEventLevel.Information))
         _logger.Information("NetNode {@node} has connected to {@address} with {@channel} in {durationMs} ms", node, address, channel, durationMs);
 }
 public void NetChannelSentMessage(INetNode node, INetChannel channel, Message message)
 {
     if (_logger.IsEnabled(LogEventLevel.Debug))
         _logger.Debug("NetChannel {@channel} has sent message {@message}", channel, message);
 }
 public void NetChannelRequestTimedOut(INetNode node, INetChannel channel, Message message, Guid requestId, int durationMs)
 {
     if (_logger.IsEnabled(LogEventLevel.Warning))
         _logger.Warning("NetChannel {@channel} has timed out within {durationMs} ms on sending request {@message} {requestId}", channel, durationMs, message, requestId);
 }
 public void OperationProcessed(INetNode node, INetChannel channel, IOperationContext operation)
 {
     if (_logger.IsEnabled(LogEventLevel.Information))
         _logger.Information("NetNode {@node} on NetChannel {@channel} processed {@operation}", node, channel, operation);
 }
 public NetCommunicationClient(INetChannel channel)
 {
     Channel = channel;
 }
 public void NetChannelSentReplyMessage(INetNode node, INetChannel channel, Message reply, IOperationContext operation)
 {
     if (_logger.IsEnabled(LogEventLevel.Debug))
         _logger.Debug("NetNode {@node} on NetChannel {@channel} sent reply {@message} for operation {@operation}", node, channel, reply, operation);
 }
        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();
            }
        }
 public void OperationProcessingFailed(INetNode node, INetChannel channel, IOperationContext operation, Exception exception)
 {
     if (_logger.IsEnabled(LogEventLevel.Warning))
         _logger.Warning("NetNode {@node} on NetChannel {@channel} failed to process operation {@operation} with {@exception}", node, channel, operation, exception);
 }
 /// <inheritdoc />
 public void SendDirectedComponentNetworkMessage(INetChannel channel, IEntity entity, IComponent component, ComponentMessage message)
 {
     throw new NotImplementedException();
 }
 static void OnRoomLeave(INetChannel channel)
 {
     RoomMember member;
     if (RoomMembers.TryGetValue(channel, out member))
     {
         List<RoomMember> members;
         if (Rooms.TryGetValue(member.RoomName, out members))
         {
             members.Remove(member);
             members.ForEach((m) => m.UserChannel.Send(new RoomEvent() { UserName = member.UserName, Text = "Left" }));
         }
     }
 }
Esempio n. 20
0
 protected virtual void OnDisconnected(INetChannel channel)
 {
     Disconnect?.Invoke(this, new NetChannelArgs(channel));
 }
        async Task OnRoomLeave(INetChannel channel)
        {
            RoomMember member;
            if (RoomMembers.TryGetValue(channel, out member))
            {
                var newEvent = new RoomEvent() { UserName = member.UserName, Text = "Left" };
                RoomData room;
                if (Rooms.TryGetValue(member.RoomName, out room))
                {
                    room.Members.Remove(member);
                    room.Members.ForEach(m => m.UserChannel.Send(newEvent));

                    room.History.Add(newEvent);

                    using (var tx = StateManager.CreateTransaction())
                    {
                        await _roomsState.SetAsync(tx, room.Name, room);
                        await tx.CommitAsync();
                    }
                }
            }
        }
 public void NetChannelIsDisposing(INetNode node, INetChannel channel)
 {
     if (_logger.IsEnabled(LogEventLevel.Debug))
         _logger.Debug("NetChannel {@channel} is closing", channel);
 }
Esempio n. 23
0
 public MsgScriptStop(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 24
0
 public MsgState(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 25
0
 public MsgRay(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 26
0
 public MsgServerInfoReq(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 27
0
        public override void HandleNetMessage(INetChannel channel, EntitySystemMessage message)
        {
            base.HandleNetMessage(channel, message);

            switch (message)
            {
            case RequestVerbsMessage req:
            {
                if (!_entityManager.TryGetEntity(req.EntityUid, out var entity))
                {
                    return;
                }

                var session    = _playerManager.GetSessionByChannel(channel);
                var userEntity = session.AttachedEntity;

                var data = new List <VerbsResponseMessage.VerbData>();
                //Get verbs, component dependent.
                foreach (var(component, verb) in VerbUtility.GetVerbs(entity))
                {
                    if (verb.RequireInteractionRange && !VerbUtility.InVerbUseRange(userEntity, entity))
                    {
                        continue;
                    }
                    if (VerbUtility.IsVerbInvisible(verb, userEntity, component, out var vis))
                    {
                        continue;
                    }

                    // TODO: These keys being giant strings is inefficient as hell.
                    data.Add(new VerbsResponseMessage.VerbData(verb.GetText(userEntity, component),
                                                               $"{component.GetType()}:{verb.GetType()}",
                                                               vis == VerbVisibility.Visible));
                }
                //Get global verbs. Visible for all entities regardless of their components.
                foreach (var globalVerb in VerbUtility.GetGlobalVerbs(Assembly.GetExecutingAssembly()))
                {
                    if (globalVerb.RequireInteractionRange && !VerbUtility.InVerbUseRange(userEntity, entity))
                    {
                        continue;
                    }
                    if (VerbUtility.IsVerbInvisible(globalVerb, userEntity, entity, out var vis))
                    {
                        continue;
                    }

                    data.Add(new VerbsResponseMessage.VerbData(globalVerb.GetText(userEntity, entity),
                                                               globalVerb.GetType().ToString(), vis == VerbVisibility.Visible));
                }

                var response = new VerbsResponseMessage(data, req.EntityUid);
                RaiseNetworkEvent(response, channel);
                break;
            }


            case UseVerbMessage use:
            {
                if (!_entityManager.TryGetEntity(use.EntityUid, out var entity))
                {
                    return;
                }

                var session    = _playerManager.GetSessionByChannel(channel);
                var userEntity = session.AttachedEntity;

                foreach (var(component, verb) in VerbUtility.GetVerbs(entity))
                {
                    if ($"{component.GetType()}:{verb.GetType()}" != use.VerbKey)
                    {
                        continue;
                    }

                    if (verb.RequireInteractionRange)
                    {
                        var distanceSquared = (userEntity.Transform.WorldPosition - entity.Transform.WorldPosition)
                                              .LengthSquared;
                        if (distanceSquared > VerbUtility.InteractionRangeSquared)
                        {
                            break;
                        }
                    }

                    verb.Activate(userEntity, component);
                    break;
                }

                foreach (var globalVerb in VerbUtility.GetGlobalVerbs(Assembly.GetExecutingAssembly()))
                {
                    if (globalVerb.GetType().ToString() != use.VerbKey)
                    {
                        continue;
                    }

                    if (globalVerb.RequireInteractionRange)
                    {
                        var distanceSquared = (userEntity.Transform.WorldPosition - entity.Transform.WorldPosition)
                                              .LengthSquared;
                        if (distanceSquared > VerbUtility.InteractionRangeSquared)
                        {
                            break;
                        }
                    }

                    globalVerb.Activate(userEntity, entity);
                    break;
                }

                break;
            }
            }
        }
Esempio n. 28
0
 public MsgStateAck(INetChannel channel)
     : base(NAME, GROUP, ID)
 {
 }
Esempio n. 29
0
 IPlayerSession IPlayerManager.GetSessionByChannel(INetChannel channel) => GetSessionByChannel(channel);
Esempio n. 30
0
 public MsgDeleteCharacter(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 31
0
        public void SendPrivateMessage(INetChannel client, ChatChannel channel, string text, string name, int?entityId)
        {
            MsgChat message = MakeNetChatMessage(channel, text, name, entityId);

            IoCManager.Resolve <IServerNetManager>().ServerSendMessage(message, client);
        }
Esempio n. 32
0
 public MsgScriptResponse(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 33
0
        private void ProcessEmote(string text, string name, ChatChannel channel, int?entityId, INetChannel client)
        {
            if (entityId == null)
            {
                return; //No emotes from non-entities!
            }
            var args = new List <string>();

            CommandParsing.ParseArguments(text, args);
            if (_emotes.ContainsKey(args[0]))
            {
                // todo make a user-only channel that only the sender can see i.e. for emotes and game feedback ('you put the coins in the jar' or whatever)
                var otherText = String.Format(_emotes[args[0]].OtherText, name, "his"); //todo pronouns, gender
                SendChatMessage(ChatChannel.Emote, otherText, name, entityId);
            }
            else
            {
                //todo Bitch at the user
            }
        }
Esempio n. 34
0
 /// <summary>
 /// Constructs a new instance.
 /// </summary>
 /// <param name="channel">The channel causing the event.</param>
 public NetChannelArgs(INetChannel channel)
 {
     Channel = channel;
 }
Esempio n. 35
0
        /// <summary>
        /// Processes commands (chat messages starting with /)
        /// </summary>
        /// <param name="text">Text content.</param>
        /// <param name="name">Player name that sent the chat text.</param>
        /// <param name="channel">Channel message was received on.</param>
        /// <param name="client">Client that sent the command.</param>
        private void ProcessCommand(string text, string name, ChatChannel channel, int?entityId, INetChannel client)
        {
            List <string> args = new List <string>();

            CommandParsing.ParseArguments(text.Substring(1), args); // Parse, but cut out the first character (/).

            if (args.Count <= 0)
            {
                return;
            }

            string command = args[0];

            if (!_commands.ContainsKey(command))
            {
                string message = string.Format("Command '{0}' not found.", command);
                SendPrivateMessage(client, ChatChannel.Default, message, "Server", null);
                return;
            }

            _commands[command].Execute(this, client, args.ToArray());
        }
Esempio n. 36
0
 public MsgChatMessage(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 37
0
 public MsgMapReq(INetChannel channel)
     : base(NAME, GROUP, ID)
 {
 }
Esempio n. 38
0
 public MsgViewVariablesDenySession(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 39
0
 public IPlayerSession GetSessionByChannel(INetChannel client)
 {
     // Should only be one session per client. Returns that session, in theory.
     return(_sessions.FirstOrDefault(s => s?.ConnectedClient == client));
 }
Esempio n. 40
0
 protected virtual void OnConnected(INetChannel channel)
 {
     Connected?.Invoke(this, new NetChannelArgs(channel));
 }
Esempio n. 41
0
 public MsgConCmd(INetChannel channel) : base(NAME, GROUP)
 {
 }
 public MsgPreferencesAndSettings(INetChannel channel) : base(NAME, GROUP)
 {
 }
Esempio n. 43
0
 public MsgConGroupUpdate(INetChannel channel) : base(Name, Group)
 {
 }
 public static IMessageProcessingPipeBuilder UseIdleDisconnect(this IMessageProcessingPipeBuilder builder, TimeSpan idleDisconnectTimeout, INetChannel channel)
 {
     var mp = new IdleDisconnectProcessor(idleDisconnectTimeout, channel);
     return builder.Use(next => context => mp.Process(next, context));
 }
 public void NetChannelRequestCompleted(INetNode node, INetChannel channel, Message message, Guid requestId, int durationMs)
 {
     if (_logger.IsEnabled(LogEventLevel.Information))
         _logger.Information("NetNode {@node} NetChannel {@channel} is received reply {@message} for {requestId} in {durationMs} ms", node, channel, message, requestId, durationMs);
 }