Beispiel #1
0
        private void ProcessCreateLobbyResponse(NetHookItem item)
        {
            var msg = item.ReadAsProtobufMsg <CMsgClientMMSCreateLobbyResponse>();

            Variables.Lobby.LobbyId = msg.Body.steam_id_lobby;
            CheckIfReJoiningStartedLobby();
        }
Beispiel #2
0
        private void ProcessLeaderBoardUpdate(NetHookItem item)
        {
            var msg = item.ReadAsProtobufMsg <CMsgClientLBSSetScore>();

            if (msg.Body.leaderboard_id == 180533)
            {
                LobbyUtils.StartLobby(Variables.Lobby);
            }
        }
Beispiel #3
0
        private void ReadFile(FileInfo file)
        {
            var item = new NetHookItem();

            if (item.LoadFromFile(file))
            {
                switch (item.Direction)
                {
                case NetHookItem.PacketDirection.In:
                    switch (item.EMsg)
                    {
                    case EMsg.ClientMMSLobbyData:
                        ProcessLobbyUpdate(item);
                        SetLobbyPresence(true);
                        break;

                    case EMsg.ClientMMSCreateLobbyResponse:
                        ProcessCreateLobbyResponse(item);
                        break;

                    case EMsg.ClientMMSJoinLobbyResponse:
                        ProcessJoinLobbyResponse(item);
                        break;
                    }
                    break;

                case NetHookItem.PacketDirection.Out:
                    switch (item.EMsg)
                    {
                    case EMsg.ClientMMSCreateLobby:
                    case EMsg.ClientMMSJoinLobby:
                        LobbyUtils.ResetLobbyData();
                        SetLobbyPresence(true);
                        ClearOverlayTeams();
                        break;

                    case EMsg.ClientMMSLeaveLobby:
                        ProcessLobbyLeave();
                        SetLobbyPresence(false);
                        break;

                    case EMsg.ClientLBSSetScore:
                        ProcessLeaderBoardUpdate(item);
                        break;
                    }
                    break;
                }
            }
            else
            {
                throw new Exception("Failed to read");
            }
        }
Beispiel #4
0
		public NetHookItem AddItemFromPath(string path)
		{
			var fileInfo = new FileInfo(path);
			var item = new NetHookItem();
			if (!item.LoadFromFile(fileInfo))
			{
				return null;
			}

			items.Add(item);
			return item;
		}
Beispiel #5
0
        private void ProcessJoinLobbyResponse(NetHookItem item)
        {
            var msg = item.ReadAsProtobufMsg <CMsgClientMMSJoinLobbyResponse>();

            Variables.Lobby.LobbyId = msg.Body.steam_id_lobby;
            if (msg.Body.chat_room_enter_response != 2)
            {
                CheckIfReJoiningStartedLobby();
            }
            else     //Lobby is not joinable any more
            {
                SetLobbyPresence(false);
            }
        }
Beispiel #6
0
		public void LoadFromDirectory(string directory)
		{
			items.Clear();

			var directoryInfo = new DirectoryInfo(directory);
			var itemFiles = directoryInfo.EnumerateFiles("*.bin", SearchOption.TopDirectoryOnly);
			foreach (var itemFile in itemFiles)
			{
				var item = new NetHookItem();
				if (item.LoadFromFile(itemFile))
				{
					items.Add(item);
				}
			}
		}
Beispiel #7
0
		TreeNode BuildTree(NetHookItem item)
		{
			return new NetHookItemTreeBuilder(item) { Specializations = specializations }.BuildTree();
		}
Beispiel #8
0
        private void ProcessLobbyUpdate(NetHookItem item)
        {
            var msg = item.ReadAsProtobufMsg <CMsgClientMMSLobbyData>();

            if (msg == null || msg.Body == null)
            {
                return;
            }
            var lobbyData = new KeyValue();

            using (var stream1 = new MemoryStream(msg.Body.metadata)) {
                if (!lobbyData.TryReadAsBinary(stream1))
                {
                    throw new Exception("Failed to read lobby metadata");
                }
                else
                {
                    if (lobbyData == null || lobbyData.Children == null || lobbyData.Children.Count == 0)
                    {
                        return;
                    }
                    TryExtractLobbyData(lobbyData);
                    if (msg.Body.members.Count > 0)
                    {
                        this.ClearOverlayTeams();
                        var lobbyMembers = new List <Player>();
                        foreach (var playerData in msg.Body.members)
                        {
                            var memberData = new KeyValue();
                            using (var stream2 = new MemoryStream(playerData.metadata)) {
                                try {
                                    if (memberData.TryReadAsBinary(stream2))
                                    {
                                        var player = new Player()
                                        {
                                            SteamId = playerData.steam_id,
                                            Name    = playerData.persona_name
                                        };
                                        try {
                                            player.RankRM = int.Parse(memberData.Children.SingleOrDefault(c => c.Name == "STAT_ELO_RM").Value);
                                        } catch { }
                                        try {
                                            player.RankDM = int.Parse(memberData.Children.SingleOrDefault(c => c.Name == "STAT_ELO_DM").Value);
                                        } catch { }
                                        lobbyMembers.Add(player);
                                    }
                                } catch (Exception e) {
                                    Console.WriteLine("Error while processing lobby member: " + playerData.persona_name);
                                    Console.WriteLine(e.ToString());
                                }
                            }
                        }
                        Variables.LobbyMembers = lobbyMembers;
                    }
                    if (lobbyData.Children.Any(c => c.Name == "player0_desc"))
                    {
                        foreach (var lobbyMember in Variables.LobbyMembers)
                        {
                            lobbyMember.Position = 0;
                        }
                        var lobbyPlayers = new List <Player>();
                        for (var i = 0; i < 8; i++)
                        {
                            try {
                                var player = new Player()
                                {
                                    Position = i + 1
                                };
                                TryExtractNameAndRank(player, lobbyData.Children.SingleOrDefault(c => c.Name == "player" + i + "_desc")?.Value, Variables.Lobby.Ranked > 0);
                                var lobbyMember = Variables.LobbyMembers.FirstOrDefault(lm => lm.Name == player.Name && lm.Position == 0);
                                if (lobbyMember != null)
                                {
                                    lobbyMember.Position = i + 1;
                                    player.SteamId       = lobbyMember.SteamId;
                                    if (player.Rank == 0)
                                    {
                                        if (Variables.Lobby.Ranked != 2)
                                        {
                                            player.Rank = lobbyMember.RankRM;
                                        }
                                        else
                                        {
                                            player.Rank = lobbyMember.RankDM;
                                        }
                                    }
                                    player.RankRM = lobbyMember.RankRM;
                                    player.RankDM = lobbyMember.RankDM;
                                }
                                if (player.SteamId != 0)
                                {
                                    try {
                                        using (IRepository repository = new Repository()) {
                                            var lobbySlot = repository.LobbySlots.Include(ls => ls.User).GetLobbySlot(player.SteamId, Variables.Lobby.LobbyId).FirstOrDefault();
                                            if (lobbySlot == null)
                                            {
                                                var user  = UserUtils.GetUser(repository, player);
                                                var lobby = repository.Lobbies.FirstOrDefault(l => l.LobbyId == Variables.Lobby.LobbyId);
                                                if (lobby == null)
                                                {
                                                    throw new Exception("Lobby not found in database: " + Variables.Lobby.LobbyId);
                                                }
                                                lobbySlot = new LobbySlot()
                                                {
                                                    Name   = player.Name,
                                                    RankDM = player.RankDM,
                                                    RankRM = player.RankRM,
                                                    User   = user,
                                                    Lobby  = lobby
                                                };
                                                repository.Add(lobbySlot);
                                                repository.SaveChanges();
                                                LobbyUtils.AssignLobbySlotId(lobbySlot, player);
                                            }
                                            else
                                            {
                                                LobbyUtils.AssignLobbySlotId(lobbySlot, player);
                                            }
                                        }
                                    } catch (Exception e) {
                                        LogUtils.Error(string.Format("Failed to persist player joining to lobby event - Player: {0}({1}) - Lobby: {2}", player.Name, player.SteamId, Variables.Lobby.LobbyId), e);
                                    }
                                }
                                lobbyPlayers.Add(player);
                                UserUtils.FetchUserGameStats(player);
                                UserUtils.FetchUserProfile(player);
                                UserUtils.FetchUserReputationStats(player);
                            } catch (Exception e) {
                                Console.WriteLine("Error while processing lobby player in slot: " + i);
                                Console.WriteLine(e.ToString());
                            }
                            lock (Variables.LobbyPlayers) {
                                Variables.LobbyPlayers = lobbyPlayers;
                            }
                        }
                    }
                }
            }
            if (Variables.ReplayMode)
            {
                Thread.Sleep(500);
            }
        }
		public NetHookItemTreeBuilder(NetHookItem item)
		{
			this.item = item;
		}