예제 #1
0
        public static async Task TryAddExp(User user, Server server, ICommandContext context)
        {
            await Task.Run(async() =>
            {
                // If the user can receive exp, give them between 5 and 8.
                if (!CanGetExperience(user))
                {
                    return;
                }

                // Don't give exp to any user who is blacklisted.
                // Members in blacklisted servers also cannot earn exp.
                if (user.IsBlacklisted || server.IsBlacklisted)
                {
                    return;
                }

                SocketTextChannel levelAnnouncementChannel = null;
                if (server.LogLevelAnnouncements != 0)
                {
                    levelAnnouncementChannel = await context.Guild.GetTextChannelAsync(server.LogLevelAnnouncements) as SocketTextChannel;
                }

                if (levelAnnouncementChannel == null)
                {
                    levelAnnouncementChannel = (SocketTextChannel)context.Channel;
                }

                double oldLevel = ReturnLevel(user);

                var r      = new Random();
                int exp    = r.Next(5, 8);
                int points = r.Next(1, 4);

                user.Experience  += exp;
                user.Points      += points;
                user.LastGivenExp = DateTime.Now.ToOADate();
                await DatabaseQueries.UpdateAsync(user);

                double newLevel = ReturnLevel(user);
                await ConsoleLogger.LogAsync($"[Global Exp]: User {user.UserId} has received {exp} exp and {points} points. " +
                                             $"[New Total: {user.Experience:N0} Exp]", LogLvl.DEBUG);

                if (!HasLeveledUp(oldLevel, newLevel))
                {
                    return;
                }

                await ConsoleLogger.LogAsync($"[Global Exp]: User {user.UserId} has leveled up! " +
                                             $"[Level: {Math.Floor(newLevel):0} | EXP: {user.Experience:N0}]", LogLvl.INFO);

                // Don't send announcement if the channel is blacklisted, but only if it's not a level-announcements log channel.
                if (server.BlackListedChannels.Any(x => x.ChannelId == context.Channel.Id && x.ChannelId != server.LogLevelAnnouncements))
                {
                    return;
                }

                if (!server.LevelAnnouncementsEnabled)
                {
                    return;
                }

                var xp = new XpImage();

                if (user.ExpChatNotificationType == ExpType.GLOBAL || user.ExpChatNotificationType == ExpType.BOTH)
                {
                    if (levelAnnouncementChannel != null)
                    {
                        Stream xpStream = await xp.GenerateXpImageStream(user, (SocketGuildUser)context.User);
                        if (xpStream != null)
                        {
                            await levelAnnouncementChannel.SendFileAsync(xpStream, $"Kaguya_Xp_LevelUp.png", "");
                        }
                    }
                }

                if (user.ExpDmNotificationType == ExpType.GLOBAL || user.ExpDmNotificationType == ExpType.BOTH)
                {
                    Stream xpStream = await xp.GenerateXpImageStream(user, (SocketGuildUser)context.User);
                    if (xpStream != null)
                    {
                        await context.User.SendFileAsync(xpStream, $"Kaguya_Xp_LevelUp.png", "");
                    }
                }
            });
        }
        public static async Task TryAddExp(User user, Server server, ICommandContext context)
        {
            List <ServerExp> specificExps = await DatabaseQueries.GetAllForServerAsync <ServerExp>(server.ServerId);

            var userExpObj = new ServerExp();

            // If the user can receive exp, give them between 5 and 8.
            if (!await CanGetExperience(specificExps, server, user))
            {
                return;
            }

            if (user.IsBlacklisted || server.IsBlacklisted)
            {
                return;
            }

            SocketTextChannel levelAnnouncementChannel;

            if (server.LogLevelAnnouncements != 0)
            {
                levelAnnouncementChannel = await context.Guild.GetTextChannelAsync(server.LogLevelAnnouncements) as SocketTextChannel;
            }
            else
            {
                levelAnnouncementChannel = context.Channel as SocketTextChannel;
            }

            var r   = new Random();
            int exp = r.Next(5, 8);

            if (server.ServerExp != null)
            {
                userExpObj = server.ServerExp.FirstOrDefault(x => x.UserId == user.UserId);
            }
            else
            {
                userExpObj = new ServerExp
                {
                    ServerId  = server.ServerId,
                    UserId    = user.UserId,
                    Exp       = 0,
                    LatestExp = 0
                };
            }

            var expObject = new ServerExp
            {
                ServerId  = server.ServerId,
                UserId    = user.UserId,
                Exp       = userExpObj?.Exp ?? 0,
                LatestExp = 0
            };

            double oldLevel = ReturnLevel(server, user);

            expObject.Exp      += exp;
            expObject.LatestExp = DateTime.Now.ToOADate();
            await DatabaseQueries.InsertOrReplaceAsync(expObject);

            // We update server again below because we have to refresh the serverExp list.

            server = await DatabaseQueries.GetOrCreateServerAsync(server.ServerId);

            double newLevel = ReturnLevel(server, user);
            await ConsoleLogger.LogAsync(
                $"[Server Exp]: User {user.UserId}] has received {exp} exp. [Guild: {server.ServerId}] " +
                $"Total Exp: {expObject.Exp:N0}]", LogLvl.TRACE);

            if (HasLeveledUp((int)oldLevel, (int)newLevel))
            {
                await ConsoleLogger.LogAsync(
                    $"[Server Exp]: [Server {server.ServerId} | User {user.UserId}] has leveled up! [Level: {(int) newLevel} | Experience: {GetExpForUser(server, user)}]",
                    LogLvl.INFO);

                // Don't send announcement if the channel is blacklisted.
                if (server.BlackListedChannels.Any(x => x.ChannelId == context.Channel.Id))
                {
                    return;
                }

                if (!server.LevelAnnouncementsEnabled)
                {
                    return;
                }

                var    xp       = new XpImage();
                Stream xpStream = await xp.GenerateXpImageStream(user, (SocketGuildUser)context.User, server);

                if (xpStream != null)
                {
                    if (user.ExpChatNotificationType == ExpType.SERVER || user.ExpChatNotificationType == ExpType.BOTH)
                    {
                        if (levelAnnouncementChannel != null)
                        {
                            await levelAnnouncementChannel.SendFileAsync(xpStream, $"Kaguya_Xp_LevelUp.png", "");
                        }
                        else
                        {
                            await context.Channel.SendFileAsync(xpStream, $"Kaguya_Xp_LevelUp.png", "");
                        }
                    }

                    if (user.ExpDmNotificationType == ExpType.SERVER || user.ExpDmNotificationType == ExpType.BOTH)
                    {
                        await context.User.SendFileAsync(xpStream, $"Kaguya_Xp_LevelUp.png", "");
                    }
                }

                // Server level-up reward stuffs.

                List <ServerRoleReward> serverRoleRewards = server.RoleRewards.ToList();
                if (serverRoleRewards.Count > 0)
                {
                    foreach (ServerRoleReward item in serverRoleRewards)
                    {
                        if (user.ServerLevel(server).Rounded(RoundDirection.DOWN) == item.Level)
                        {
                            IRole targetRole = context.Guild.Roles.First(x => x.Id == item.RoleId);
                            // ReSharper disable PossibleNullReferenceException
                            await(context.User as SocketGuildUser).AddRoleAsync(targetRole);
                            await ConsoleLogger.LogAsync($"User {user.UserId} received level-up role reward in guild " +
                                                         $"{server.ServerId}. Role Name: {targetRole.Name}", LogLvl.DEBUG);

                            // ReSharper restore PossibleNullReferenceException
                        }
                    }
                }
            }
        }