예제 #1
0
        private void SetupFileWatcher()
        {
            LastLobby = OpenDotaAPI.GetLastLobby(FileManagement.ServerLog);

            FileSystemWatcher watcher = new FileSystemWatcher(new FileInfo(FileManagement.ServerLog).Directory.FullName)
            {
                EnableRaisingEvents = true
            };

            watcher.Changed += (newobject, newargs) =>
            {
                try
                {
                    if (Settings.Instance.AutoRetrievePlayerData)
                    {
                        string tempLobby = OpenDotaAPI.GetLastLobby(FileManagement.ServerLog);
                        if (LastLobby != tempLobby)
                        {
                            watcher.EnableRaisingEvents = false;

                            RetrieveData();
                            AutoSizeWindow();

                            LastLobby = tempLobby;
                        }
                    }
                }
                finally
                {
                    watcher.EnableRaisingEvents = true;
                }
            };
        }
예제 #2
0
        private void SetupFileWatcher()
        {
            OpenDotaAPI dotaAPI = new OpenDotaAPI();

            PreviousLobby = dotaAPI.GetLastLobby(FileManagement.ServerLog);

            FileSystemWatcher watcher = new FileSystemWatcher(new FileInfo(FileManagement.ServerLog).Directory.FullName)
            {
                EnableRaisingEvents = true
            };

            watcher.Changed += (newobject, newargs) =>
            {
                try
                {
                    string tempLobby = dotaAPI.GetLastLobby(FileManagement.ServerLog);
                    if (PreviousLobby != tempLobby)
                    {
                        watcher.EnableRaisingEvents = false;

                        UpdatePlayers();

                        PreviousLobby = tempLobby;
                    }
                }
                finally
                {
                    watcher.EnableRaisingEvents = true;
                }
            };
        }
예제 #3
0
        private static List <List <string> > GetPlayersGroups(List <string> playerIds)
        {
            if (!playerIds.SequenceEqual(_lastIds))
            {
                _playerGroups = OpenDotaAPI.GetPlayersPartiesList(playerIds);
                _lastIds      = playerIds;
            }

            return(_playerGroups);
        }
예제 #4
0
        private void RetrieveData()
        {
            this.Dispatcher.Invoke(() =>
            {
                RefreshSpinner.Spin = true;
            });

            var playerIDs = OpenDotaAPI.GetPlayerIDs();

            for (int i = 0; i < 10; i++)
            {
                if (i < playerIDs.Count)
                {
                    PlayerDisplays[i].Update(playerIDs[i]);
                }
                else
                {
                    PlayerDisplays[i].Update("");
                }
            }
        }
예제 #5
0
        public async Task LastMatch()
        {
            if (known_players.Count() == 0)
            {
                known_players.Add("Pwnstar#6451", "110093717");
                known_players.Add("ihsur#0253", "105901322");
                known_players.Add("SakanaFish#6718", "155807445");
                known_players.Add("Anita Jackoff#2748", "247539735");
                known_players.Add("Bazba#9700", "86990383");
                known_players.Add("MajorLagGamer#7065", "100253408");
                known_players.Add("Depression#6421", "302192086");
            }

            var builder = new EmbedBuilder()
            {
                Color = new Color(114, 137, 218),
            };

            string id;

            if (known_players.TryGetValue(Context.Message.Author.ToString(), out id))
            {
                MatchData[] data = await OpenDotaAPI.GetPlayerMatches(id, 1, 0, 0);

                await Context.Channel.SendMessageAsync($@"https://www.opendota.com/matches/{data[0].match_id}");

                //builder.AddField(x =>
                //{
                //    x.Name = "Result";
                //    x.Value = $@"https://www.opendota.com/matches/{data[0].match_id}";
                //});
            }
            else
            {
                await Context.Channel.SendMessageAsync("Unknown User");
            }

            //await ReplyAsync("", false, builder.Build());
        }
예제 #6
0
        public async Task Test()
        {
            List <String> players = OpenDotaAPI.GetPlayerIDs();
            PlayerData    data    = await OpenDotaAPI.GetPlayerData(players[0]);

            if (data.profile != null)
            {
                //await Context.Channel.SendMessageAsync($"{data.solo_competitive_rank}");
                if (data.solo_competitive_rank == null)
                {
                    await ReplyAsync($"empty");
                }
                else
                {
                    await ReplyAsync($"this");
                }
            }
            else
            {
                //await Context.Channel.SendMessageAsync("This is null");
                await ReplyAsync($"This is null");
            }
        }
예제 #7
0
        public async Task HeroStats(params string[] hero)
        {
            HeroData[] data = await OpenDotaAPI.GetHeroStatData();

            HeroData stats = null;

            var builder = new EmbedBuilder()
            {
                Color = new Color(114, 137, 218),
            };

            builder.AddField(x =>
            {
                x.Name = "Statistics";
                StringBuilder labels = new StringBuilder("Pro\n");
                for (int i = 1; i < 8; i++)
                {
                    labels.AppendLine($"{(Medal)i}");
                }

                labels.AppendLine("Total");

                x.Value    = labels;
                x.IsInline = true;
            });

            int pro_picks   = 0;
            int one_picks   = 0;
            int two_picks   = 0;
            int three_picks = 0;
            int four_picks  = 0;
            int five_picks  = 0;
            int six_picks   = 0;
            int seven_picks = 0;

            for (int i = 0; i < data.Length; i++)
            {
                if (String.Join(" ", hero.ToArray()) == data[i].localized_name)         // Check for hero
                {
                    stats = data[i];
                }

                pro_picks   += data[i].pro_pick + data[i].pro_ban;
                one_picks   += data[i].one_pick;
                two_picks   += data[i].two_pick;
                three_picks += data[i].three_pick;
                four_picks  += data[i].four_pick;
                five_picks  += data[i].five_pick;
                six_picks   += data[i].six_pick;
                seven_picks += data[i].seven_pick;
            }

            Console.WriteLine(pro_picks);

            if (stats != null)
            {
                //builder.Title = stats.localized_name;
                builder.WithAuthor(x =>
                {
                    x.Name    = stats.localized_name;
                    x.IconUrl = $@"http://cdn.dota2.com{stats.icon}";
                });

                //builder.ThumbnailUrl = $@"http://cdn.dota2.com{stats.img}";

                StringBuilder des = new StringBuilder();

                des.AppendLine($"Health: {stats.base_health} + {stats.base_health_regen}");
                des.AppendLine($"Mana: {stats.base_mana} + {stats.base_mana_regen}");
                des.AppendLine($"Armor: {stats.base_armor}");
                des.AppendLine($"Magic Resistance: {stats.base_mr}");
                des.AppendLine($"Move speed: {stats.move_speed}");
                des.AppendLine($"Turn rate: {stats.turn_rate}");
                des.AppendLine($"Attack: {stats.base_attack_min} - {stats.base_attack_max}");
                des.AppendLine($"Attack Speed: {stats.attack_rate}");
                des.AppendLine($"Attack Range: {stats.attack_range}");
                des.AppendLine($"Projectile Speed: {stats.projectile_speed}");
                des.AppendLine($"Legs: {stats.legs}");
                des.AppendLine();
                des.AppendLine($"Strength: {stats.base_str} + {stats.str_gain}");
                des.AppendLine($"Agility: {stats.base_agi} + {stats.agi_gain}");
                des.AppendLine($"Intelligence: {stats.base_int} + {stats.int_gain}");

                builder.Description = des.ToString();

                builder.AddField(x =>
                {
                    x.Name = "Winrate";

                    StringBuilder winrate = new StringBuilder();
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.pro_win / stats.pro_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.one_win / stats.one_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.two_win / stats.two_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.three_win / stats.three_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.four_win / stats.four_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.five_win / stats.five_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.six_win / stats.six_pick * 100));
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)stats.seven_win / stats.seven_pick * 100));

                    int total_win  = stats.one_win + stats.two_win + stats.three_win + stats.four_win + stats.five_win + stats.six_win + stats.seven_win;
                    int total_pick = stats.one_pick + stats.two_pick + stats.three_pick + stats.four_pick + stats.five_pick + stats.six_pick + stats.seven_pick;
                    winrate.AppendLine(string.Format("{0:0.00}%", (double)total_win / total_pick * 100));

                    x.Value    = winrate;
                    x.IsInline = true;
                });

                builder.AddField(x =>
                {
                    x.Name = "Pickrate";

                    StringBuilder pickrate = new StringBuilder();
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)(stats.pro_pick + stats.pro_ban) / pro_picks * 2200));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.one_pick / one_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.two_pick / two_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.three_pick / three_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.four_pick / four_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.five_pick / five_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.six_pick / six_picks * 1000));
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)stats.seven_pick / seven_picks * 1000));

                    int total_pick  = stats.one_pick + stats.two_pick + stats.three_pick + stats.four_pick + stats.five_pick + stats.six_pick + stats.seven_pick;
                    int total_picks = one_picks + two_picks + three_picks + four_picks + five_picks + six_picks + seven_picks;
                    pickrate.AppendLine(string.Format("{0:0.00}%", (double)total_pick / total_picks * 1000));

                    x.Value    = pickrate;
                    x.IsInline = true;
                });

                await ReplyAsync("", false, builder.Build());
            }
            else
            {
                await ReplyAsync("Hero not found");
            }
        }
예제 #8
0
        public async Task Battlecup()
        {
            // get player IDs from server log
            List <String> players = OpenDotaAPI.GetPlayerIDs();
            var           result  = String.Join(", ", players.ToArray());

            // find team side
            int master = players.IndexOf("110093717");

            if (master < 5)
            {
                players.RemoveRange(0, 5);
            }
            else
            {
                players.RemoveRange(5, 5);
            }

            /*
             * var builder = new EmbedBuilder()
             * {
             *  Color = new Color(114, 137, 218),
             * };
             *
             * StringBuilder des = new StringBuilder();
             *
             * foreach (string player in players)
             * {
             *  des.AppendLine($"{player}");
             * }
             *
             * builder.Description = des.ToString();
             * await ReplyAsync("", false, builder.Build());
             */

            StringBuilder ranks = new StringBuilder();
            StringBuilder names = new StringBuilder();
            StringBuilder mmr   = new StringBuilder();

            var builder = new EmbedBuilder()
            {
                Color = new Color(114, 137, 218),
            };

            foreach (String p in players)
            {
                PlayerData pData = await OpenDotaAPI.GetPlayerData(p);

                int rank = 0;
                if (pData.rank_tier != null)
                {
                    rank = Convert.ToInt32(pData.rank_tier);
                }

                if (pData.profile != null)
                {
                    names.AppendLine($"{pData.profile.personaname}");

                    // MMR
                    int solo  = pData.solo_competitive_rank == null ? 0 : int.Parse(pData.solo_competitive_rank);
                    int party = pData.competitive_rank == null ? 0 : int.Parse(pData.competitive_rank);
                    int?est   = pData.mmr_estimate.estimate;

                    if (solo == 0 && party == 0)
                    {
                        mmr.AppendLine($"Est: {est}");
                    }
                    else if (solo > party)
                    {
                        mmr.AppendLine($"Solo: {solo}");
                    }
                    else if (solo < party)
                    {
                        mmr.AppendLine($"Party: {party}");
                    }
                    else
                    {
                        mmr.AppendLine($"Est: {est}");
                    }
                }
                else
                {
                    names.AppendLine("Anonymous");
                    mmr.AppendLine("N/A");
                }

                if (rank == 0)
                {
                    ranks.AppendLine($"[Uncalibrated](https://www.opendota.com/players/{p})");
                }
                else if ((rank / 10) == 8)
                {
                    ranks.AppendLine($"[Immortal {pData.leaderboard_rank}](https://www.opendota.com/players/{p})");
                }
                else
                {
                    ranks.AppendLine($"[{(Medal)(rank / 10)} {rank % 10}](https://www.opendota.com/players/{p})");
                }
            }

            builder.AddField(x =>
            {
                x.Name     = "Players";
                x.Value    = names;
                x.IsInline = true;
            });

            builder.AddField(x =>
            {
                x.Name     = "Rank";
                x.Value    = ranks;
                x.IsInline = true;
            });

            builder.AddField(x =>
            {
                x.Name     = "MMR";
                x.Value    = mmr;
                x.IsInline = true;
            });

            await ReplyAsync("", false, builder.Build());



            /* Find past 9 battlecup games
             * MatchData[] data = await OpenDotaAPI.GetPlayerMatches("110093717", 9, 0, 9);
             *
             * var builder = new EmbedBuilder()
             * {
             *  Color = new Color(114, 137, 218),
             * };
             *
             * StringBuilder des = new StringBuilder();
             *
             * foreach (MatchData match in data)
             * {
             *  des.AppendLine($@"https://www.opendota.com/matches/{match.match_id}");
             * }
             *
             * builder.Description = des.ToString();
             * await ReplyAsync("", false, builder.Build());
             * //await Context.Channel.SendMessageAsync($@"https://www.opendota.com/matches/{data[0].match_id}");
             */
        }
예제 #9
0
        public async Task MedalCheck(params string[] cmds)
        {
            // Get player IDs from server log
            List <String> players = OpenDotaAPI.GetPlayerIDs();

            StringBuilder ranks = new StringBuilder();
            StringBuilder names = new StringBuilder();
            StringBuilder mmr   = new StringBuilder();

            var builder = new EmbedBuilder()
            {
                Color = new Color(114, 137, 218),
            };

            foreach (String p in players)
            {
                PlayerData pData = await OpenDotaAPI.GetPlayerData(p);

                int rank = 0;
                if (pData.rank_tier != null)
                {
                    rank = Convert.ToInt32(pData.rank_tier);
                }

                if (pData.profile != null)
                {
                    names.AppendLine($"{pData.profile.personaname}");

                    // MMR
                    int solo  = pData.solo_competitive_rank == null ? 0 : int.Parse(pData.solo_competitive_rank);
                    int party = pData.competitive_rank == null ? 0 : int.Parse(pData.competitive_rank);
                    int?est   = pData.mmr_estimate.estimate;

                    if (solo == 0 && party == 0)
                    {
                        mmr.AppendLine($"Est: {est}");
                    }
                    else if (solo > party)
                    {
                        mmr.AppendLine($"Solo: {solo}");
                    }
                    else if (solo < party)
                    {
                        mmr.AppendLine($"Party: {party}");
                    }
                    else
                    {
                        mmr.AppendLine($"Est: {est}");
                    }
                }
                else
                {
                    names.AppendLine("Anonymous");
                    mmr.AppendLine("N/A");
                }

                if (rank == 0)
                {
                    ranks.AppendLine($"[Uncalibrated](https://www.opendota.com/players/{p})");
                }
                else if ((rank / 10) == 8)
                {
                    ranks.AppendLine($"[Immortal {pData.leaderboard_rank}](https://www.opendota.com/players/{p})");
                }
                else
                {
                    ranks.AppendLine($"[{(Medal)(rank / 10)} {rank % 10}](https://www.opendota.com/players/{p})");
                }
            }

            builder.AddField(x =>
            {
                x.Name     = "Players";
                x.Value    = names;
                x.IsInline = true;
            });

            builder.AddField(x =>
            {
                x.Name     = "Rank";
                x.Value    = ranks;
                x.IsInline = true;
            });

            builder.AddField(x =>
            {
                x.Name     = "MMR";
                x.Value    = mmr;
                x.IsInline = true;
            });

            await ReplyAsync("", false, builder.Build());
        }