protected virtual void OnPlayerDisconnected(SteamPlayer player)
        {
            var user = GetUser(player);

            if (user == null)
            {
                return;
            }

            if (user.Session is UnturnedUserSession session)
            {
                session.OnSessionEnd();
            }

            AsyncHelper.RunSync(async() =>
            {
                var disconnectedEvent = new UserDisconnectedEvent(user);
                await m_EventBus.EmitAsync(m_Runtime, this, disconnectedEvent);

                m_UnturnedUsers.Remove(user);

                var userData = await m_UserDataStore.GetUserDataAsync(user.Id, user.Type);
                if (userData == null)
                {
                    return;
                }

                userData.LastSeen = DateTime.Now;
                await m_UserDataStore.SaveUserDataAsync(userData);
            });
        }
        protected virtual void OnRejectingPlayer(CSteamID steamId, ESteamRejection rejection, string explanation)
        {
            var pending = m_PendingUsers.FirstOrDefault(d => d.SteamId == steamId);

            if (pending == null)
            {
                return;
            }

            AsyncHelper.RunSync(async() =>
            {
                var disconnectedEvent = new UserDisconnectedEvent(pending);
                await m_EventBus.EmitAsync(m_Runtime, this, disconnectedEvent);

                FinishSession(pending);

                var userData = await m_UserDataStore.GetUserDataAsync(pending.Id, pending.Type);
                if (userData == null)
                {
                    return;
                }

                userData.LastSeen = DateTime.Now;
                await m_UserDataStore.SaveUserDataAsync(userData);
            });
        }
Exemple #3
0
        public void ReceiveMessage(TextMessage textTextMessage)
        {
            switch (textTextMessage.Type)
            {
            case MessageType.TextMessage:
                TextMessageIncomeEvent?.Invoke(textTextMessage);
                break;

            case MessageType.ConnectMessage:
                if (textTextMessage.SenderNick != Nick)
                {
                    UserConnectedEvent?.Invoke(textTextMessage.SenderNick);
                    _chatChannel.SendMessage(textTextMessage.SenderNick,
                                             new TextMessage()
                    {
                        SenderNick = Nick, Type = MessageType.LoadMessage
                    });
                }

                break;

            case MessageType.LoadMessage:
                UserConnectedEvent?.Invoke(textTextMessage.SenderNick);
                break;

            case MessageType.DisconnectMessage:
                if (textTextMessage.SenderNick != Nick)
                {
                    UserDisconnectedEvent?.Invoke(textTextMessage.SenderNick);
                }
                break;

            case MessageType.PlayerStartedMessage:
                if (textTextMessage.SenderNick != Nick)
                {
                    PlayerStartedEvent?.Invoke(textTextMessage.SenderNick);
                }
                break;

            case MessageType.PlayerFinishedMessage:
                if (textTextMessage.SenderNick != Nick)
                {
                    PlayerFinishedEvent?.Invoke(textTextMessage.SenderNick);
                }
                break;
            }
        }
Exemple #4
0
        protected virtual void OnEnemyDisconnected(SteamPlayer player)
        {
            AsyncHelper.RunSync(async() =>
            {
                var user              = GetUser(player);
                user.SessionEndTime   = DateTime.Now;
                var disconnectedEvent = new UserDisconnectedEvent(user);

                await m_EventBus.EmitAsync(m_Runtime, this, disconnectedEvent);
                m_UnturnedUsers.Remove(user);

                var userData      = await m_UserDataStore.GetUserDataAsync(user.Id, user.Type);
                userData.Data     = user.PersistentData;
                userData.LastSeen = DateTime.Now;
                await m_UserDataStore.SaveUserDataAsync(userData);
            });
        }
 public Task HandleEventAsync(object sender, UserDisconnectedEvent @event)
 {
     return(HandleUserEvent(@event.User, "disconnect"));
 }