Exemple #1
0
        public async Task <IDiscordMessage> SendMessage(IDiscordEmbed embed)
        {
            RuntimeMessage m = null;
            await MeruUtils.TryAsync(async() =>
            {
                Log.Message("Sent embed to channel " + channel.Name);
                m = new RuntimeMessage(
                    await(channel as IMessageChannel)
                    .SendMessageAsync("", false, (embed as IProxy <EmbedBuilder>)
                                      .ToNativeObject()));
            },
                                     async (ex) =>
            {
                Log.ErrorAt("SendMessage", ex.Message);
            });

            return(m);
        }
Exemple #2
0
        public async Task CheckAsync(IDiscordMessage e)
        {
            if (e.Author.IsBot)
            {
                return;
            }

            if (!lastTimeExpGranted.ContainsKey(e.Author.Id))
            {
                lastTimeExpGranted.Add(e.Author.Id, DateTime.MinValue);
            }

            if (lastTimeExpGranted[e.Author.Id].AddMinutes(1) < DateTime.Now)
            {
                int addedExperience = MikiRandom.Next(2, 5);

                await MeruUtils.TryAsync(async() =>
                {
                    User a;
                    LocalExperience experience;

                    long userId = e.Author.Id.ToDbLong();

                    int currentGlobalLevel = 0;
                    int currentLocalLevel  = 0;

                    using (var context = new MikiContext())
                    {
                        a = await context.Users.FindAsync(e.Author.Id.ToDbLong());

                        if (a == null)
                        {
                            a = await User.CreateAsync(e);
                        }

                        experience = await context.Experience.FindAsync(e.Guild.Id.ToDbLong(), userId);

                        if (experience == null)
                        {
                            experience = await LocalExperience.CreateAsync(context, e.Guild.Id.ToDbLong(), e.Author.Id.ToDbLong());
                        }

                        if (experience.LastExperienceTime == null)
                        {
                            experience.LastExperienceTime = DateTime.Now;
                        }

                        GuildUser guildUser = await context.GuildUsers.FindAsync(e.Guild.Id.ToDbLong());
                        if (guildUser == null)
                        {
                            long guildId  = e.Guild.Id.ToDbLong();
                            int?userCount = Bot.instance.Client.GetGuild(e.Guild.Id).Users.Count;

                            int?value = await context.Experience
                                        .Where(x => x.ServerId == guildId)
                                        .SumAsync(x => x.Experience);

                            guildUser                  = new GuildUser();
                            guildUser.Name             = e.Guild.Name;
                            guildUser.Id               = guildId;
                            guildUser.Experience       = value ?? 0;
                            guildUser.UserCount        = userCount ?? 0;
                            guildUser.LastRivalRenewed = Utils.MinDbValue;
                            guildUser.MinimalExperienceToGetRewards = 100;

                            guildUser = context.GuildUsers.Add(guildUser);
                        }

                        currentLocalLevel  = User.CalculateLevel(experience.Experience);
                        currentGlobalLevel = User.CalculateLevel(a.Total_Experience);

                        experience.Experience += addedExperience;
                        a.Total_Experience    += addedExperience;
                        guildUser.Experience  += addedExperience;

                        await context.SaveChangesAsync();
                    }


                    if (currentLocalLevel != User.CalculateLevel(experience.Experience))
                    {
                        await LevelUpLocalAsync(e, a, currentLocalLevel + 1);
                    }

                    if (currentGlobalLevel != User.CalculateLevel(a.Total_Experience))
                    {
                        await LevelUpGlobalAsync(e, a, currentGlobalLevel + 1);
                    }

                    lastTimeExpGranted[e.Author.Id] = DateTime.Now;
                });
            }
        }