Пример #1
0
        public FrmGroupChat(XmppClient xmppClient, Jid roomJid, string nickname, ListView listContract)
        {
            InitializeComponent();
            local_history = new HistoryTransactionTableAdapter();
            connection = new SqlCeConnection(local_history.Connection.ConnectionString);
            _roomJid = roomJid;
            _xmppClient = xmppClient;
            _nickname = nickname;
            _listContract = listContract;
            fm.XmppClient = FrmLogin.Instance.xmppClient;
            fm.OnFile += fm_OnFile;
            Text = roomJid.User + " Group"; ;
            mm = new MucManager(xmppClient);

            // Setup new Message Callback using the MessageFilter
            _xmppClient.MessageFilter.Add(roomJid, new BareJidComparer(), MessageCallback);

            // Setup new Presence Callback using the PresenceFilter
            _xmppClient.PresenceFilter.Add(roomJid, new BareJidComparer(), PresenceCallback);

            GetLastRow(_xmppClient.Username, _xmppClient.XmppDomain, _roomJid.Bare, out LastDtDB);
            btnHistory.Enabled = false;
            Form.CheckForIllegalCrossThreadCalls = false;
            Instance = this;
        }
Пример #2
0
        //static void xmpp_OnReadXml(object sender, string xml)
        //{
        //    Console.Write("--------xml--------");
        //    Console.Write(xml);
        //    Console.Write(sender);
        //    Console.Write("--------xml--------");
        //   // throw new NotImplementedException();
        //}


        /*
         *
         * Create room
         *
         */
        private static void CreateRoom()
        {
            MucManager muc     = new MucManager(xmpp);
            Jid        RoomJid = new Jid("[email protected]");

            muc.CreateReservedRoom(RoomJid, new IqCB(OnCreateRoom));
            muc.JoinRoom(RoomJid, "[email protected]");
            muc.JoinRoom(RoomJid, "[email protected]");
            muc.JoinRoom(RoomJid, "[email protected]");
            muc.JoinRoom(RoomJid, "[email protected]");
        }
Пример #3
0
        /// <summary>
        /// Joins the specified room.
        /// </summary>
        /// <param name="room">The room.</param>
        /// <returns></returns>
        public bool Join(Room room)
        {
            var manager = new MucManager(connection);

            var jid = new Jid(room.JabberId, "conf.hipchat.com", string.Empty);

            manager.JoinRoom(jid, current.Name);

            Out.WriteLine("{1:HH:mm:ss} Joined room: {0}.", room.Name, DateTime.Now);

            return(true);
        }
Пример #4
0
 public FormConferention(string _roomJid)
 {
     InitializeComponent();
     roomJid  = new Jid(_roomJid);
     xmpp     = Settings.xmpp;
     mainJid  = Settings.jid;
     nickname = Settings.nickname;
     muc      = new MucManager(xmpp);
     muc.JoinRoom(roomJid, nickname);
     xmpp.MesagageGrabber.Add(roomJid, new BareJidComparer(), new MessageCB(MessageCallback), null);
     xmpp.PresenceGrabber.Add(roomJid, new BareJidComparer(), new PresenceCB(PresenceCallback), null);
 }
Пример #5
0
        /// <summary>
        /// Leaves the specified room.
        /// </summary>
        /// <param name="room">The room.</param>
        public bool Leave(Room room)
        {
            var manager = new MucManager(connection);

            var jid = new Jid(room.JabberId, "conf.hipchat.com", string.Empty);

            manager.LeaveRoom(jid, current.Name);

            Out.WriteLine("Left room: {0}.", room.Name);

            return(true);
        }
Пример #6
0
        void xmpp_OnLogin(object sender)
        {
            MucManager mucManager = new MucManager(_client);

            string[] rooms = _config.Rooms.Split(',');

            foreach (string room in rooms)
            {
                Jid jid = new Jid(room + "@" + _config.ConferenceServer);
                mucManager.JoinRoom(jid, _config.RoomNick);
            }
        }
Пример #7
0
        /// <summary>
        /// Fires when the XMPP Client receives a message.
        /// </summary>
        /// <param name="sender">
        /// The Sender
        /// </param>
        /// <param name="msg">
        /// The Message
        /// </param>
        private void XmppOnMessage(object sender, Message msg)
        {
            switch (msg.Type)
            {
            case MessageType.normal:
                if (msg.From.Server == "conference." + this.client.Config.ChatHost)
                {
                    string rname = msg.From.User;
                    var    m     = new MucManager(this.xmpp);
                    m.JoinRoom(msg.From, msg.From.User);
                    ChatRoom theRoom = this.GetRoom(new User(msg.From), true);
                    this.xmpp.RosterManager.AddRosterItem(msg.From, msg.From.User);
                }

                break;

            case MessageType.error:
            {
                if (msg.From.User.ToLowerInvariant().Contains("gameserv"))
                {
                    return;
                }
                ChatRoom nc = this.GetRoom(new User(msg.From.Bare), true);
                nc.OnMessage(this, msg);
                break;
            }

            case MessageType.chat:
            {
                switch (msg.Chatstate)
                {
                case Chatstate.None:

                    // TODO Group chat whispers in the form of {roomname}@conference.server.octgn.info/{username} need to be handled here.
                    ChatRoom nc = this.GetRoom(new User(msg.From.Bare));
                    nc.OnMessage(sender, msg);
                    break;
                }

                break;
            }

            case MessageType.groupchat:
            {
                ChatRoom nc = this.GetRoom(new User(msg.From.Bare), true);
                nc.OnMessage(this, msg);
                break;
            }

            case MessageType.headline:
                break;
            }
        }
Пример #8
0
        private void OnLogin(object sender)
        {
            var mucManager = new MucManager(_client);

            var rooms = Robot.Settings.Get("HipChatRooms").Split(',');

            var roomJids = rooms.Select(room => new Jid(room + "@" + _conferenceServer));

            foreach (var jid in roomJids)
            {
                mucManager.JoinRoom(jid, Robot.Settings.Get("HipChatRoomNick"));
                JoinedRoomJids.Add(jid);
            }
        }
Пример #9
0
        public override bool OnLoad(Gui.MainWindow window)
        {
            Config = Configuration.Load();

            Window = window;

            var loginWindow = new LoginWindow {
                txtUsername = { Text = Config.Email }
            };

            if (!loginWindow.ShowDialog().HasValue || LoginData == null)
            {
                return(false);
            }

            Config.Email = loginWindow.Username;

            if (loginWindow.chkRemember.IsChecked != null && loginWindow.chkRemember.IsChecked.Value)
            {
                Config.Save();
            }

            SelfJid = new Jid(Nickname + "@chat.hipchat.com");

            window.Title = "Chatterbox - " + GroupName;

            HipchatClient = new XmppClientConnection("chat.hipchat.com");
            HipchatClient.Open(Nickname, loginWindow.Password);
            HipchatClient.Status = "Chatterbox";
            HipchatClient.Show   = ShowType.chat;
            HipchatClient.AutoResolveConnectServer = false;
            HipchatClient.OnLogin += HipchatClient_OnLogin;

            MucManager = new MucManager(HipchatClient);

            HipchatClient.OnRosterStart += sender => Users.Clear();
            HipchatClient.OnRosterItem  += HipchatClient_OnRosterItem;
            HipchatClient.OnMessage     += HipchatClient_OnMessage;
            HipchatClient.OnPresence    += HipchatClient_OnPresence;

            Lobby             = new LobbyControl();
            Lobby.OnRoomJoin += Lobby_OnRoomJoin;


            Window.SetLobbyRoom(Lobby);

            return(true);
        }
Пример #10
0
        public EndOfGamePage(EndOfGameStats statistics)
        {
            InitializeComponent();
            RenderStats(statistics);
            Client.SwitchPage(Client.MainPage);
            Client.runonce = false;
            Client.ChampId = -1;
            RoomJid        = Client.GetChatroomJid(statistics.RoomName, statistics.RoomPassword, false);

            newRoom = new MucManager(Client.XmppConnection);
            Client.XmppConnection.OnMessage       += XmppConnection_OnMessage;
            Client.XmppConnection.OnPresence      += XmppConnection_OnPresence;
            Client.RiotConnection.MessageReceived += RiotConnection_MessageReceived;
            newRoom.AcceptDefaultConfiguration(new Jid(RoomJid));
            newRoom.JoinRoom(new Jid(RoomJid), Client.LoginPacket.AllSummonerData.Summoner.Name);
        }
Пример #11
0
        private void OnClientLogin(object sender)
        {
            var mucManager = new MucManager(_client);

            foreach (string room in _rooms.Union(_logRooms).Distinct())
            {
                var jid = new Jid(room + "@" + _confhost);
                mucManager.JoinRoom(jid, _roomNick);
                Rooms.Add(room);
                Logger.Info(string.Format("Joined Room '{0}'", room));
            }
            foreach (string logRoom in _logRooms)
            {
                LogRooms.Add(logRoom);
            }
        }
Пример #12
0
        public FrmGroupChat(XmppClient xmppClient, Jid roomJid, string nickname)
        {
            InitializeComponent();

            _roomJid    = roomJid;
            _xmppClient = xmppClient;
            _nickname   = nickname;

            mm = new MucManager(xmppClient);

            // Setup new Message Callback using the MessageFilter
            _xmppClient.MessageFilter.Add(roomJid, new BareJidComparer(), MessageCallback);

            // Setup new Presence Callback using the PresenceFilter
            _xmppClient.PresenceFilter.Add(roomJid, new BareJidComparer(), PresenceCallback);
        }
Пример #13
0
        public FrmGroupChat(XmppClient xmppClient, Jid roomJid, string nickname)
        {
            InitializeComponent();

            _roomJid = roomJid;
            _xmppClient = xmppClient;
            _nickname = nickname;

            mm = new MucManager(xmppClient);

            // Setup new Message Callback using the MessageFilter
            _xmppClient.MessageFilter.Add(roomJid, new BareJidComparer(), MessageCallback);

            // Setup new Presence Callback using the PresenceFilter
            _xmppClient.PresenceFilter.Add(roomJid, new BareJidComparer(), PresenceCallback);
        }
Пример #14
0
        private void OnClientLogin(object sender)
        {
            var mucManager = new MucManager(_client);

            var rooms = _api.GetAllRooms();

            foreach (var room in rooms.Items)
            {
                var roomInfo = _api.GetRoom(room.Id);

                var jid = new Jid(roomInfo.XmppJid);
                mucManager.JoinRoom(jid, _botUser.Name);
                Rooms.Add(room.Name);
                LogRooms.Add(room.Name);
                Logger.Info(string.Format("Joined Room '{0}'", room.Name));
            }
        }
Пример #15
0
        private void XmppOnOnLogin(object sender)
        {
            myPresence.Type = PresenceType.available;
            myPresence.Show = ShowType.chat;
            MucManager      = new MucManager(Xmpp);
            Jid room = new Jid("lobby@conference." + Host);

            MucManager.AcceptDefaultConfiguration(room);
            //MucManager.JoinRoom(room,Username,Password,false);
            Me = new NewUser(Xmpp.MyJID);
            Me.SetStatus(UserStatus.Online);
            Xmpp.PresenceManager.Subscribe(Xmpp.MyJID);
            if (OnLoginComplete != null)
            {
                OnLoginComplete.Invoke(this, LoginResults.Success);
            }
        }
Пример #16
0
        public static XmppClient InitXmppClient(string userName, string passWord, string domain, string server)
        {
            StaticClass2.xmppClient          = new XmppClient(userName, domain, passWord);
            StaticClass2.xmppClient.Hostname = server;

            //StaticClass.xmppClient.Open();

            StaticClass2.pm = new PresenceManager(xmppClient);
            StaticClass2.rm = new RosterManager(xmppClient);

            StaticClass2.muc = new MucManager(xmppClient);

            StaticClass2.fm = new FileTransferManager();
            //StaticClass.fm.OnProgress += Fm_OnProgress;
            //StaticClass.fm.OnEnd += Fm_OnEnd;

            return(StaticClass2.xmppClient);
        }
Пример #17
0
        public void GroupChat()//Jid roomJid, string nickname)
        {
            XmppClient xmppClient = XmppClients[Context.ConnectionId];

            mm = new MucManager(xmppClient);

            //     mm.EnterRoom("ALLURE786", "*****@*****.**");

            //    mm = new MucManager(xmppClient);
            mm.EnterRoom("ALLURE786", "*****@*****.**", true);
            mm.Invite("*****@*****.**", "ALLURE786", "Please join");
            //    mm.Invite("*****@*****.**", "ALLURE786", "Please join");

            // Setup new Message Callback using the MessageFilter
            //    xmppClient.MessageFilter.Add(roomJid, new BareJidComparer(), MessageCallback);

            // Setup new Presence Callback using the PresenceFilter
            //  xmppClient.PresenceFilter.Add(roomJid, new BareJidComparer(), PresenceCallback);
        }
Пример #18
0
        private void OnClientLogin(object sender)
        {
            var mucManager = new MucManager(_client);

            var rooms = _api.GetAllRooms();

            foreach (var room in rooms.Items.Where(r => _roomList.Count == 0 || r.Name != null && _roomList.Contains(r.Name.ToUpper())))
            {
                var roomInfo = _api.GetRoom(room.Id);

                _roomMap.Add(roomInfo.XmppJid, room.Id);

                var jid = new Jid(roomInfo.XmppJid);
                mucManager.JoinRoom(jid, _botUser.Name);
                Rooms.Add(room.Name);
                LogRooms.Add(room.Name);
                Logger.Info(string.Format("Joined Room '{0}'", room.Name));
            }
        }
Пример #19
0
        public override void Configure()
        {
            base.Configure();
            _client = new XmppClientConnection(Server);
            _client.OnXmppConnectionStateChanged += this.XmppOnXmppConnectionStateChanged;
            _client.OnLogin       += this.XmppOnLogin;
            _client.OnRosterItem  += this.XmppOnRosterItem;
            _client.OnRosterEnd   += this.XmppOnRosterEnd;
            _client.OnRosterStart += this.XmppOnRosterStart;
            _client.OnMessage     += this.XmppOnMessage;
            _client.OnPresence    += this.XmppOnPresence;
            _client.OnAgentItem   += this.XmppOnAgentItem;
            _client.OnIq          += this.XmppOnIq;
            _client.OnClose       += this.XmppOnClose;
            _client.OnError       += this.XmppOnError;
            _client.OnSocketError += this.XmppOnSocketError;
            _client.OnStreamError += this.XmppOnStreamError;

            _muc = new MucManager(_client);
            Outputs["XmppLobby"].OnMessage += XmppChatModule_OnMessage;
        }
Пример #20
0
        public RiotChat()
        {
            xmpp = new XmppClientConnection {
                Server                   = "pvp.net",
                Port                     = 5223,
                ConnectServer            = Session.Region.ChatServer,
                AutoResolveConnectServer = false,
                Resource                 = "xiff",
                UseSSL                   = true,
                KeepAliveInterval        = 10,
                KeepAlive                = true,
                UseCompression           = true,
                AutoPresence             = true,
                Status                   = new LeagueStatus(StatusMessage, Status).ToXML(),
                Show                     = ShowType.chat,
                Priority                 = 0
            };
            xmpp.OnMessage   += Xmpp_OnMessage;
            xmpp.OnAuthError += (o, e) => Session.Log(e);
            xmpp.OnError     += (o, e) => Session.Log(e);
            xmpp.OnLogin     += o => Session.Log("Connected to chat server");
            xmpp.Open(Session.Current.Account.LoginSession.AccountSummary.Username, "AIR_" + Session.Current.Account.LoginSession.Password);

            presence = new PresenceManager(xmpp);
            roster   = new RosterManager(xmpp);
            lobby    = new MucManager(xmpp);

            xmpp.OnRosterEnd  += o => connected = true;
            xmpp.OnRosterItem += Xmpp_OnRosterItem;
            xmpp.OnPresence   += Xmpp_OnPresence;

            timer = new Timer(1000)
            {
                AutoReset = true
            };
            timer.Elapsed += UpdateProc;
            timer.Start();
        }
Пример #21
0
        public async void LoadStats()
        {
            i                  = 10;
            PingTimer          = new Timer(1000);
            PingTimer.Elapsed += PingElapsed;
            PingTimer.Enabled  = true;
            PingElapsed(1, null);
            InviteButton.IsEnabled    = false;
            StartGameButton.IsEnabled = false;

            if (CurrentLobby == null)
            {
                CurrentLobby = await RiotCalls.AcceptInvite(Invite);
            }
            if (CurrentLobby.InvitationID != null)
            {
                string ObfuscatedName =
                    Client.GetObfuscatedChatroomName(CurrentLobby.InvitationID.ToLower(),
                                                     ChatPrefixes.Arranging_Game);
                string Jid = Client.GetChatroomJid(ObfuscatedName, CurrentLobby.ChatKey, false);
                newRoom = new MucManager(Client.XmppConnection);
                jid     = new Jid(Jid);
                Client.XmppConnection.OnMessage  += XmppConnection_OnMessage;
                Client.XmppConnection.OnPresence += XmppConnection_OnPresence;
                newRoom.AcceptDefaultConfiguration(jid);
                newRoom.JoinRoom(jid, Client.LoginPacket.AllSummonerData.Summoner.Name, CurrentLobby.ChatKey);
                RenderLobbyData();
            }
            else
            {
                Client.GameStatus = "outOfGame";
                Client.SetChatHover();
                Client.SwitchPage(Client.MainPage);
                Client.ClearPage(typeof(TeamQueuePage));
                Client.Log("Failed to join room.");
            }
        }
Пример #22
0
 //Handles incoming messages
 static void MessageCallBack(object sender,
                             agsXMPP.protocol.client.Message msg,
                             object data)
 {
     if (msg.Body != null)
     {
         Console.ForegroundColor = ConsoleColor.Red;
         Console.WriteLine("{0}>> {1}", msg.From.User, msg.Body);
         Console.ForegroundColor = ConsoleColor.Green;
     }
     else
     {
         try
         {
             Console.WriteLine(msg.FirstChild.GetAttributeJid("jid"));
             MucManager _manager = new MucManager(xmpp);
             _manager.JoinRoom(msg.FirstChild.GetAttributeJid("jid"), "test");
         }
         catch (Exception e)
         {
             Console.WriteLine(e);
         }
     }
 }
Пример #23
0
 public GroupChatItem(string id, string title)
 {
     InitializeComponent();
     ChatId = id;
     PlayerLabelName.Content = title;
     GroupTitle = title;
     if (ChatId == null)
     {
         return;
     }
     try
     {
         newRoom = new MucManager(Client.XmppConnection);
     }
     catch
     {
         return;
     }
     Client.XmppConnection.OnPresence += XmppConnection_OnPresence;
     Client.XmppConnection.OnMessage  += XmppConnection_OnMessage;
     newRoom.AcceptDefaultConfiguration(new Jid(ChatId));
     roomName = ChatId;
     newRoom.JoinRoom(new Jid(ChatId), Client.LoginPacket.AllSummonerData.Summoner.Name);
 }
Пример #24
0
        public override Task Run()
        {
            _loginTcs = new TaskCompletionSource <bool>();
            Task <bool> connect = _loginTcs.Task;

            if (_xmppConnection != null)
            {
                _xmppConnection.Close();
                _xmppConnection = null;
            }
            _xmppConnection = new XmppClientConnection
            {
                Server                   = _host,
                ConnectServer            = _connectHost,
                AutoResolveConnectServer = true,
                Username                 = _username,
                Password                 = _password
            };
            if (_port > 0)
            {
                _xmppConnection.Port = _port;
            }

            _xmppConnection.KeepAlive = true;

            _xmppConnection.OnLogin      += OnLogin;
            _xmppConnection.OnError      += OnError;
            _xmppConnection.OnMessage    += OnMessage;
            _xmppConnection.OnPresence   += XmppConnectionOnOnPresence;
            _xmppConnection.OnRosterItem += OnClientRosterItem;
            _xmppConnection.OnXmppConnectionStateChanged += OnXmppConnectionStateChanged;

            Task.Factory.StartNew(() =>
            {
                _xmppConnection.Open();
                Thread.Sleep(CONNECT_TIMEOUT);
                _loginTcs.TrySetResult(false);
            });

            if (!connect.Result)
            {
                throw new TimeoutException("XMPP adapter timed out while trying to login");
            }
            else
            {
                MucManager muc = new MucManager(_xmppConnection);
                foreach (var room in _rooms)
                {
                    try
                    {
                        muc.JoinRoom(string.Format("{0}@{1}", room, _confServer), _username, _password, true);
                        Logger.Info(string.Format("Successfully joined room {0}", room));
                        Rooms.Add(string.Format("{0}@{1}", room, _confServer));
                    }
                    catch (Exception ex)
                    {
                        Logger.Error("Failed to join room - " + ex.Message);
                    }
                }

                foreach (var logroom in _logRooms)
                {
                    try
                    {
                        muc.JoinRoom(string.Format("{0}@{1}", logroom, _confServer), _username, _password, true);
                        Logger.Info(string.Format("Successfully joined room {0}", logroom));
                        LogRooms.Add(string.Format("{0}@{1}", logroom, _confServer));
                    }
                    catch (Exception ex)
                    {
                        Logger.Error("Failed to join room - " + ex.Message);
                    }
                }
            }

            return(_loginTcs.Task);
        }
Пример #25
0
        private void Lobby_OnMessageReceived(object sender, object message)
        {
            if (message.GetType() != typeof(GameDTO))
            {
                return;
            }

            var dto = message as GameDTO;

            Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(async() =>
            {
                if (!HasConnectedToChat)
                {
                    //Run once
                    BaseMap map                  = BaseMap.GetMap(dto.MapId);
                    MapLabel.Content             = map.DisplayName;
                    ModeLabel.Content            = Client.TitleCaseString(dto.GameMode);
                    GameTypeConfigDTO configType =
                        Client.LoginPacket.GameTypeConfigs.Find(x => x.Id == dto.GameTypeConfigId);
                    TypeLabel.Content = GetGameMode(configType.Id);
                    SizeLabel.Content = dto.MaxNumPlayers / 2 + "v" + dto.MaxNumPlayers / 2;

                    HasConnectedToChat    = true;
                    string obfuscatedName =
                        Client.GetObfuscatedChatroomName(dto.Name.ToLower() + Convert.ToInt64(dto.Id),
                                                         ChatPrefixes.Arranging_Practice);
                    string Jid = Client.GetChatroomJid(obfuscatedName, dto.RoomPassword, false);
                    newRoom    = new MucManager(Client.XmppConnection);
                    Client.XmppConnection.OnMessage  += XmppConnection_OnMessage;
                    Client.XmppConnection.OnPresence += XmppConnection_OnPresence;
                    jid = new Jid(dto.RoomName);
                    newRoom.AcceptDefaultConfiguration(jid);
                    newRoom.JoinRoom(jid, Client.LoginPacket.AllSummonerData.Summoner.Name, dto.RoomPassword);
                }
                switch (dto.GameState)
                {
                case "TEAM_SELECT":
                    {
                        OptomisticLock     = dto.OptimisticLock;
                        LaunchedTeamSelect = false;
                        BlueTeamListView.Items.Clear();
                        PurpleTeamListView.Items.Clear();

                        var allParticipants = new List <Participant>(dto.TeamOne.ToArray());
                        allParticipants.AddRange(dto.TeamTwo);

                        int i           = 0;
                        bool purpleSide = false;

                        foreach (Participant playerTeam in allParticipants)
                        {
                            i++;
                            var lobbyPlayer = new CustomLobbyPlayer();
                            //var botPlayer = new BotControl();
                            if (playerTeam is PlayerParticipant)
                            {
                                var player  = playerTeam as PlayerParticipant;
                                lobbyPlayer = RenderPlayer(player, dto.OwnerSummary.SummonerId == player.SummonerId);
                                ///BotParticipant botParticipant = playerTeam as BotParticipant;
                                //botPlayer = RenderBot(botParticipant);
                                IsOwner = dto.OwnerSummary.SummonerId ==
                                          Client.LoginPacket.AllSummonerData.Summoner.SumId;
                                StartGameButton.IsEnabled = IsOwner;

                                if (Client.Whitelist.Count > 0)
                                {
                                    if (!Client.Whitelist.Contains(player.SummonerName.ToLower()))
                                    {
                                        await RiotCalls.BanUserFromGame(Client.GameID, player.AccountId);
                                    }
                                }
                            }

                            if (i > dto.TeamOne.Count)
                            {
                                i          = 0;
                                purpleSide = true;
                            }

                            if (!purpleSide)
                            {
                                BlueTeamListView.Items.Add(lobbyPlayer);
                            }
                            else
                            {
                                PurpleTeamListView.Items.Add(lobbyPlayer);
                            }
                        }
                    }
                    break;

                case "PRE_CHAMP_SELECT":
                case "CHAMP_SELECT":
                    if (!LaunchedTeamSelect)
                    {
                        Client.ChampSelectDTO  = dto;
                        Client.LastPageContent = Client.Container.Content;
                        Client.SwitchPage(new ChampSelectPage(dto.RoomName, dto.RoomPassword).Load(this));
                        LaunchedTeamSelect = true;
                    }
                    break;
                }
            }));
        }
Пример #26
0
        private void Lobby_OnMessageReceived(object sender, object message)
        {
            if (message == null)
            {
                return;
            }

            if (message.GetType() != typeof(GameDTO))
            {
                return;
            }

            var dto = message as GameDTO;

            Dispatcher.BeginInvoke(DispatcherPriority.Input, new ThreadStart(async() =>
            {
                if (!HasConnectedToChat)
                {
                    //Run once
                    BaseMap map                  = BaseMap.GetMap(dto.MapId);
                    MapLabel.Content             = map.DisplayName;
                    ModeLabel.Content            = Client.TitleCaseString(dto.GameMode);
                    GameTypeConfigDTO configType = Client.LoginPacket.GameTypeConfigs.Find(x => x.Id == dto.GameTypeConfigId);
                    TypeLabel.Content            = GetGameMode(configType.Id);
                    SizeLabel.Content            = dto.MaxNumPlayers / 2 + "v" + dto.MaxNumPlayers / 2;

                    HasConnectedToChat = true;

                    string obfuscatedName = Client.GetObfuscatedChatroomName(dto.Name.ToLower() + Convert.ToInt64(dto.Id), ChatPrefixes.Arranging_Practice);
                    string Jid            = Client.GetChatroomJid(obfuscatedName, dto.RoomPassword, false);
                    newRoom = new MucManager(Client.XmppConnection);
                    Client.XmppConnection.OnMessage  += XmppConnection_OnMessage;
                    Client.XmppConnection.OnPresence += XmppConnection_OnPresence;
                    roomJid = new Jid(Jid);
                    newRoom.AcceptDefaultConfiguration(roomJid);
                    newRoom.JoinRoom(roomJid, Client.LoginPacket.AllSummonerData.Summoner.Name);
                }
                switch (dto.GameState)
                {
                case "TEAM_SELECT":
                    {
                        bool isSpectator   = false;
                        OptomisticLock     = dto.OptimisticLock;
                        LaunchedTeamSelect = false;
                        BlueTeamListView.Items.Clear();
                        PurpleTeamListView.Items.Clear();
                        SpectatorListView.Items.Clear();

                        foreach (Participant playerTeam in dto.TeamOne)
                        {
                            if (playerTeam is PlayerParticipant)
                            {
                                var lobbyPlayer            = new CustomLobbyPlayer();
                                var player                 = playerTeam as PlayerParticipant;
                                lobbyPlayer                = RenderPlayer(player, dto.OwnerSummary.SummonerId == player.SummonerId);
                                Client.isOwnerOfGame       = dto.OwnerSummary.SummonerId == Client.LoginPacket.AllSummonerData.Summoner.SumId;
                                StartGameButton.IsEnabled  = Client.isOwnerOfGame;
                                AddBotBlueTeam.IsEnabled   = Client.isOwnerOfGame;
                                AddBotPurpleTeam.IsEnabled = Client.isOwnerOfGame;

                                BlueTeamListView.Items.Add(lobbyPlayer);

                                if (Client.Whitelist.Count <= 0)
                                {
                                    continue;
                                }

                                if (!Client.Whitelist.Contains(player.SummonerName.ToLower()))
                                {
                                    await RiotCalls.BanUserFromGame(Client.GameID, player.AccountId);
                                }
                            }
                            else if (playerTeam is BotParticipant)
                            {
                                var botParticipant = playerTeam as BotParticipant;
                                var botPlayer      = new BotControl();
                                botPlayer          = RenderBot(botParticipant);
                                BlueTeamListView.Items.Add(botPlayer);
                            }
                        }
                        foreach (Participant playerTeam in dto.TeamTwo)
                        {
                            if (playerTeam is PlayerParticipant)
                            {
                                var lobbyPlayer            = new CustomLobbyPlayer();
                                var player                 = playerTeam as PlayerParticipant;
                                lobbyPlayer                = RenderPlayer(player, dto.OwnerSummary.SummonerId == player.SummonerId);
                                Client.isOwnerOfGame       = dto.OwnerSummary.SummonerId == Client.LoginPacket.AllSummonerData.Summoner.SumId;
                                StartGameButton.IsEnabled  = Client.isOwnerOfGame;
                                AddBotBlueTeam.IsEnabled   = Client.isOwnerOfGame;
                                AddBotPurpleTeam.IsEnabled = Client.isOwnerOfGame;

                                PurpleTeamListView.Items.Add(lobbyPlayer);

                                if (Client.Whitelist.Count <= 0)
                                {
                                    continue;
                                }

                                if (!Client.Whitelist.Contains(player.SummonerName.ToLower()))
                                {
                                    await RiotCalls.BanUserFromGame(Client.GameID, player.AccountId);
                                }
                            }
                            else if (playerTeam is BotParticipant)
                            {
                                var botParticipant = playerTeam as BotParticipant;
                                var botPlayer      = new BotControl();
                                botPlayer          = RenderBot(botParticipant);
                                PurpleTeamListView.Items.Add(botPlayer);
                            }
                        }
                        foreach (GameObserver observer in dto.Observers)
                        {
                            if (observer.SummonerId == Client.LoginPacket.AllSummonerData.Summoner.SumId)
                            {
                                isSpectator = true;
                            }

                            var spectatorItem = new CustomLobbyObserver();

                            spectatorItem = RenderObserver(observer);
                            SpectatorListView.Items.Add(spectatorItem);
                        }
                        if (isSpectator)
                        {
                            AddBotPurpleTeam.Visibility            = Visibility.Hidden;
                            AddBotBlueTeam.Visibility              = Visibility.Hidden;
                            JoinBlueTeamFromSpectator.Visibility   = Visibility.Visible;
                            JoinPurpleTeamFromSpectator.Visibility = Visibility.Visible;
                        }
                        else
                        {
                            AddBotPurpleTeam.Visibility            = Visibility.Visible;
                            AddBotBlueTeam.Visibility              = Visibility.Visible;
                            JoinBlueTeamFromSpectator.Visibility   = Visibility.Hidden;
                            JoinPurpleTeamFromSpectator.Visibility = Visibility.Hidden;
                        }
                    }
                    break;

                case "PRE_CHAMP_SELECT":
                case "CHAMP_SELECT":
                    if (!LaunchedTeamSelect)
                    {
                        Client.ChampSelectDTO  = dto;
                        Client.LastPageContent = Client.Container.Content;
                        Client.SwitchPage(new ChampSelectPage(dto.RoomName, dto.RoomPassword).Load(this));
                        Client.GameStatus = "championSelect";
                        Client.SetChatHover();
                        LaunchedTeamSelect = true;
                    }
                    break;
                }
            }));
        }
Пример #27
0
 private void _CreateChatRoom(XmppClient client, string chatRoomName, string roomNick)
 {
     _mucManager = new MucManager(client);
     _mucManager.EnterRoom(chatRoomName, roomNick);
 }
Пример #28
0
 public void MucManager()
 {
     this.mucManager = new MucManager(xmppClient);
 }
Пример #29
0
        public MucManager GetMucManager()
        {
            var muc = new MucManager(_xmppConnection);

            return(muc);
        }
Пример #30
0
 public Muc(XmppClientConnection connection)
 {
     _connection = connection;
     _muc        = new MucManager(connection);
 }
Пример #31
0
        private void XmppOnOnMessage(object sender, Message msg)
        {
            switch (msg.Type)
            {
            case MessageType.normal:
                if (msg.From.Server == "conference." + Skylabs.Lobby.Client.Host)
                {
                    var        rname = msg.From.User;
                    MucManager m     = new MucManager(_xmpp);
                    m.JoinRoom(msg.From, msg.From.User);
                    var theRoom = GetRoom(new NewUser(msg.From), true);
                    _xmpp.RosterManager.AddRosterItem(msg.From, msg.From.User);
                    if (OnCreateRoom != null)
                    {
                        OnCreateRoom.Invoke(this, theRoom);
                    }
                }
                break;

            case MessageType.error:
            {
                var nc = GetRoom(new NewUser(msg.From.Bare), true);
                nc.OnMessage(this, msg);
                break;
            }

            case MessageType.chat:
            {
                switch (msg.Chatstate)
                {
                case Chatstate.None:
                    //TODO Group chat whispers in the form of {roomname}@conference.server.octgn.info/{username} need to be handled here.
                    var nc = GetRoom(new NewUser(msg.From.Bare));
                    nc.OnMessage(sender, msg);
                    break;

                case Chatstate.active:

                    break;

                case Chatstate.inactive:
                    break;

                case Chatstate.composing:
                    break;

                case Chatstate.gone:
                    break;

                case Chatstate.paused:
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                break;
            }

            case MessageType.groupchat:
            {
                var nc = GetRoom(new NewUser(msg.From.Bare), true);
                nc.OnMessage(this, msg);
                break;
            }

            case MessageType.headline:
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
Пример #32
0
        public override async Task Topic(string roomName, params string[] messages)
        {
            var mucManager = new MucManager(_client);

            mucManager.ChangeSubject(new Jid(roomName), string.Join(" ", messages));
        }