bool ExistsIndexies(List <RankingGroup> rgc, RankingGroup rg)
 {
     foreach (RankingGroup trg in rgc)
     {
         foreach (int i in rg.Indecies)
         {
             if (trg.Indecies.Any(t => t == i))
             {
                 return(true);
             }
         }
     }
     return(false);
 }
        public void GenerateDataTableRanking(ref DataTable toOperateDataTable, string sortByField, string rankingField)
        {
            // group the data elements
            List <RankingGroup> rgc = new List <RankingGroup>();

            foreach (DataRow dr1 in toOperateDataTable.Rows)
            {
                RankingGroup rg = new RankingGroup();
                foreach (DataRow dr2 in toOperateDataTable.Rows)
                {
                    if (dr1 != dr2 && dr2 != null)
                    {
                        if (!rg.Indecies.Contains(toOperateDataTable.Rows.IndexOf(dr1)))
                        {
                            rg.Indecies.Add(toOperateDataTable.Rows.IndexOf(dr1));
                            rg.Score = float.Parse((string)dr1[sortByField]);
                        }

                        if ((float.Parse((string)dr1[sortByField]) == float.Parse((string)dr2[sortByField]) && !rg.Indecies.Contains(toOperateDataTable.Rows.IndexOf(dr2))))
                        {
                            rg.Indecies.Add(toOperateDataTable.Rows.IndexOf(dr2));
                            rg.Score = float.Parse((string)dr2[sortByField]);
                        }
                    }
                }
                if (!ExistsIndexies(rgc, rg))
                {
                    rgc.Add(rg);
                }
            }

            List <RankingGroup> sortedRgc = rgc.OrderByDescending(t => t.Score).ToList();

            int ranking = 1;

            foreach (RankingGroup rg in sortedRgc)
            {
                foreach (int i in rg.Indecies)
                {
                    toOperateDataTable.Rows[i][rankingField] = ranking;
                }
                ranking++;
            }
        }
Exemplo n.º 3
0
        void IModule.Install(ModuleManager manager)
        {
            info             = new Data.TextInformation();
            osuInfo          = new Data.Osu_Data();
            updater          = new Timer(60000);
            updater.Elapsed += Updater_Elapsed;
            updater.Start();

            _manager = manager;
            _client  = manager.Client;

            _client.MessageReceived += _client_MessageReceived;

            manager.CreateCommands("quote", group =>
            {
                group.PublicOnly();

                group.CreateCommand("get")
                .Description("Gets the Quote at Index or Random if no Index is given")
                .Parameter("Index", ParameterType.Optional)
                .Do(async e =>
                {
                    if (e.Args[0] == "")
                    {
                        await e.Channel.SendMessage($"Quote[{new Random().Next(0, info.quotes.Count)}]:\n{info.quotes[new Random().Next(0, info.quotes.Count)]}");
                    }
                    else
                    {
                        await e.Channel.SendMessage($"Quote[{e.Args[0]}]:\n{info.quotes[int.Parse(e.Args[0])]}");
                    }
                });

                group.CreateCommand("search")
                .Description("Searches all Quote containing the keyword")
                .Parameter("keyword", ParameterType.Unparsed)
                .Do(async e =>
                {
                    string output = "";

                    for (int i = 0; i < info.quotes.Count; i++)
                    {
                        if (info.quotes[i].ToString().ToLower().Contains(e.Args[0].ToLower()))
                        {
                            output += $"Quote[{i}]:\n{info.quotes[i]}\n\n";
                        }
                    }

                    await e.Channel.SendMessage(output);
                });

                group.CreateCommand("add")
                .Description("Adds a Quote at the end of the List")
                .Parameter("Quote", ParameterType.Unparsed)
                .Do(async e =>
                {
                    info.quotes.Add($"{e.Args[0]}");
                    info.writeInformation();
                    await e.Channel.SendMessage($"Added Quote[{info.quotes.Count - 1}]");
                });

                group.CreateCommand("de")
                .Description("Removes Quote at Index")
                .Parameter("Index")
                .Do(async e =>
                {
                    info.quotes.RemoveAt(int.Parse(e.Args[0]));
                    info.writeInformation();
                    await e.Channel.SendMessage($"Removed Quote[{e.Args[0]}]");
                });
            });

            manager.CreateCommands("", group =>
            {
                group.CreateCommand("giveCookie")
                .Description("You make me survive for a few minutes longer!")
                .Do(async e =>
                {
                    info.cookies++;
                    info.writeInformation();
                    await e.Channel.SendMessage($"Up to now, I have been fed {info.cookies} cookies!");
                });
            });

            manager.CreateCommands("osu", group =>
            {
                group.CreateCommand("user")
                .Description("test")
                .Parameter("name")
                .Do(async e =>
                {
                    var dict = Module.Data.osuUser.userStats(e.GetArg("name"));

                    try { await e.Channel.SendMessage($"User: {dict["username"]} \nPP: {dict["pp_raw"]}\n\nhttps://osu.ppy.sh/u/{dict["user_id"]}"); } catch (Exception ex) { await e.Channel.SendMessage(ex.Message); }
                });

                group.CreateCommand("signup")
                .Description("Signs you up into the Osu! Database")
                .Parameter("name")
                .Do(async e =>
                {
                    if (osuInfo.osuUsers.Find(x => x.discordID == e.User.Id) != null)
                    {
                        return;
                    }

                    var dict = Module.Data.osuUser.userStats(e.GetArg("name"));

                    osuInfo.osuUsers.Add(new Data.osuUser(e.User.Id, dict["user_id"]));

                    osuInfo.writeInformation();

                    await e.Channel.SendMessage("Signed you up, " + dict["username"] + ".");
                });

                group.CreateCommand("setMainMode")
                .Description("0 = Standard, 1 = Taiko, 2 = CtB, 3 = Mania")
                .Parameter("Mode")
                .Do(async e =>
                {
                    if (osuInfo.osuUsers.Find(x => x.discordID == e.User.Id) == null)
                    {
                        return;
                    }

                    osuInfo.osuUsers.Find(x => x.discordID == e.User.Id).mainMode = "m=" + e.GetArg("Mode");
                    osuInfo.osuUsers.Find(x => x.discordID == e.User.Id).updateStats();

                    osuInfo.writeInformation();

                    await e.Channel.SendMessage("Set mode to " + e.GetArg("Mode"));
                });

                group.CreateCommand("getStats")
                .Description("Fetches and updates your Data from the DataBase")
                .Do(async e =>
                {
                    Data.osuUser OUser = osuInfo.osuUsers.Find(x => x.discordID == e.User.Id);
                    OUser.updateStats();

                    await e.Channel.SendMessage($"Name: {OUser.username}\nScore: {OUser.score} ({Math.Round(OUser.accuracy, 2)}%)\nPP: {OUser.pp}  {OUser.mainMode}\n\nhttps://osu.ppy.sh/u/{OUser.ident}");
                });

                group.CreateGroup("ranking", RankingGroup =>
                {
                    RankingGroup.CreateCommand("pp")
                    .Do(async e =>
                    {
                        osuInfo.osuUsers.Sort((y, x) => x.pp.CompareTo(y.pp));
                        string output = "";

                        int count = 0;

                        foreach (Data.osuUser curUser in osuInfo.osuUsers)
                        {
                            count++;
                            try
                            {
                                output += $"#{count} ``PP: {curUser.pp}`` by **{e.Server.GetUser(curUser.discordID).Name}** ({curUser.username})\n";
                            }
                            catch (NullReferenceException ex)
                            {
                                count--;
                            }
                        }

                        await e.Channel.SendMessage(output);
                    });

                    RankingGroup.CreateCommand("acc")
                    .Do(async e =>
                    {
                        osuInfo.osuUsers.Sort((y, x) => x.accuracy.CompareTo(y.accuracy));
                        string output = "";

                        int count = 0;

                        foreach (Data.osuUser curUser in osuInfo.osuUsers)
                        {
                            count++;
                            try
                            {
                                output += $"#{count} ``{Math.Round(curUser.accuracy, 2)}%`` by **{e.Server.GetUser(curUser.discordID).Name}** ({curUser.username})\n";
                            }
                            catch (NullReferenceException ex)
                            {
                                count--;
                            }
                        }

                        await e.Channel.SendMessage(output);
                    });

                    RankingGroup.CreateCommand("score")
                    .Do(async e =>
                    {
                        osuInfo.osuUsers.Sort((y, x) => x.score.CompareTo(y.score));
                        string output = "";

                        int count = 0;

                        foreach (Data.osuUser curUser in osuInfo.osuUsers)
                        {
                            count++;
                            try
                            {
                                output += $"#{count} ``{curUser.score}`` by **{e.Server.GetUser(curUser.discordID).Name}** ({curUser.username})\n";
                            }
                            catch (NullReferenceException ex)
                            {
                                count--;
                            }
                        }

                        await e.Channel.SendMessage(output);
                    });

                    RankingGroup.CreateCommand("playcount")
                    .Do(async e =>
                    {
                        osuInfo.osuUsers.Sort((y, x) => x.playcount.CompareTo(y.playcount));
                        string output = "";

                        int count = 0;

                        foreach (Data.osuUser curUser in osuInfo.osuUsers)
                        {
                            count++;
                            try
                            {
                                output += $"#{count} ``{curUser.playcount}`` by **{e.Server.GetUser(curUser.discordID).Name}** ({curUser.username})\n";
                            }
                            catch (NullReferenceException ex)
                            {
                                count--;
                            }
                        }

                        await e.Channel.SendMessage(output);
                    });
                });
            });
        }