Esempio n. 1
0
        public NowPlayingInterface()
        {
            display = new Embed ();
            display.Show ();

            ServiceManager.PlayerEngine.EngineBeforeInitialize += engine => {
                var clutter_engine = ServiceManager.PlayerEngine.ActiveEngine as ISupportClutter;
                if (clutter_engine == null) {
                    throw new ApplicationException ("Banshee GStreamer engine does not have Clutter support");
                }

                video_texture = new Texture () { SyncSize = false };
                clutter_engine.EnableClutterVideoSink (video_texture.Handle);
            };

            ServiceManager.SourceManager.SourceAdded += OnSourceAdded;
        }
Esempio n. 2
0
 public static RollResult DiceRoll(Embed embed) =>
 new RollResult(embed);
Esempio n. 3
0
        public async Task <IUserMessage> SendPlayerMessage(Embed embeddedContent, ulong discordId)
        {
            var message = await _discord.GetUser(discordId).SendMessageAsync(embed: embeddedContent);

            return(message);
        }
Esempio n. 4
0
        public async Task <ButtonComponent> SelectButtonAsync(ComponentBuilder builder, string text = null, Embed embed = null, bool deleteWhenDone = false, TimeSpan?timeout = null,
                                                              AllowedMentions allowedMentions       = null)
        {
            if (string.IsNullOrWhiteSpace(text) && embed == null)
            {
                throw new ArgumentNullException($"One of {nameof(text)} or {nameof(embed)} must be non-null");
            }

            var selectionSource = new TaskCompletionSource <ButtonComponent>();

            var selectionTask = selectionSource.Task;
            var timeoutTask   = Task.Delay(timeout ?? InteractivityService.DefaultTimeout);

            var components = builder.Build();

            var message = await ReplyAsync(message : text, embed : embed, component : components, allowedMentions : allowedMentions).ConfigureAwait(false);

            async Task CheckButtonAsync(CallbackEventArgs e)
            {
                if (e.User.Id != Context.User.Id)
                {
                    return;
                }

                var btn = getButton(components, e.ComponentId);

                selectionSource.SetResult(btn);
            }

            try
            {
                ComponentService.Register(message, CheckButtonAsync, doSave: false);
                var task_result = await Task.WhenAny(timeoutTask, selectionTask).ConfigureAwait(false);

                var result = task_result == selectionTask
                    ? await selectionTask.ConfigureAwait(false)
                    : null;

                if (deleteWhenDone)
                {
                    await message.DeleteAsync().ConfigureAwait(false);
                }
                else
                { // disable the buttons instead
                    var disabledBuilder = new ComponentBuilder();
                    int i = 0;
                    foreach (var row in builder.ActionRows)
                    {
                        foreach (var btn in row.Components)
                        {
                            disabledBuilder.WithButton(btn.Label,
                                                       btn.CustomId, btn.Style, btn.Emote, btn.Url, true, i);
                        }
                        i++;
                    }
                    await message.ModifyAsync(x =>
                    {
                        x.Components = disabledBuilder.Build();
                    });
                }

                return(result);
            } finally
            {
                ComponentService.Unregister(message);
            }
        }
Esempio n. 5
0
        public async Task InviteCmd()
        {
            Embed e = _lib.CreateEmbedWithText("Invite Link", _core.GetInviteLink() + "\nThanks for inviting EdgyBot! :smile:");

            await ReplyAsync("", embed : e);
        }
Esempio n. 6
0
 public async Task <IUserMessage> SendMessageAsync(ulong channel, string message, Embed embed = null)
 {
     return(await SendMessageAsync(GetChannel(channel), message, embed));
 }
 public static Task <RestUserMessage> InlineReplyAsync(this SocketMessage message, string text, bool isTTS, Embed embed, CancellationToken cancellationToken)
 => InlineReplyAsync(message, text, isTTS, embed, null, new RequestOptions {
     CancelToken = cancellationToken
 });
 // inline replies
 public static Task <RestUserMessage> InlineReplyAsync(this SocketCommandContext message, string text = null, bool isTTS = false, Embed embed = null, AllowedMentions mentions = null, RequestOptions options = null)
 => InlineReplyAsync(message.Message, text, isTTS, embed, mentions, options);
Esempio n. 9
0
        public async Task <IUserMessage> HandleNewPaginatedMessageAsync(SocketCommandContext context, IEnumerable <EmbedField> displayFields, IEnumerable <string> displayTexts, Embed embed)
        {
            var message = await context.Channel.SendMessageAsync("", false, embed);

            var paginatedMessage = new PaginatedMessage()
            {
                DiscordMessageId = message.Id,
                DiscordChannelId = message.Channel.Id,
                DiscordUserId    = context.User.Id,
            };

            if (displayFields == null)
            {
                paginatedMessage.DisplayMessages = displayTexts.ToArray();
            }
            else
            {
                paginatedMessage.DisplayFields = displayFields.ToArray();
            }

            _activeMessages.Add(paginatedMessage);

            if (paginatedMessage.TotalPages == 1)
            {
                return(message);
            }

            await AddPaginatorReactionsAsync(message);

            AddNewTimer(message.Id);

            return(message);
        }
Esempio n. 10
0
 /// <summary>
 /// Sends a reply to a message in the same channel.
 /// </summary>
 /// <param name="message">The message to reply to.</param>
 /// <param name="embed">The embed message to send.</param>
 public static void SendReply(SocketMessage message, Embed embed)
 {
     message.Channel.SendMessageAsync(embed: embed).Wait();
 }
Esempio n. 11
0
 public Task <RestUserMessage> SendMessageAsync(string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
 => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, embed, options);
Esempio n. 12
0
 async Task <IUserMessage> IMessageChannel.SendMessageAsync(string text, bool isTTS, Embed embed, RequestOptions options)
 => await SendMessageAsync(text, isTTS, embed, options).ConfigureAwait(false);
Esempio n. 13
0
 protected async Task <IUserMessage> SendEmbedAsync(Embed embed)
 {
     return(await Context.Channel.SendMessageAsync("", false, embed));
 }
Esempio n. 14
0
 protected async Task <IUserMessage> SendFileAsync(Stream stream, string filename, string text = null,
                                                   bool isTts = false, Embed embed = null, RequestOptions options = null, bool isSpoiler = false)
 {
     return(await Context.Channel.SendFileAsync(stream, filename, text, isTts, embed, options, isSpoiler));
 }
Esempio n. 15
0
		internal void Update(API.Message model)
		{
			if (model.Attachments != null)
			{
				Attachments = model.Attachments.Select(x => new Attachment
				{
					Id = x.Id,
					Url = x.Url,
					ProxyUrl = x.ProxyUrl,
					Size = x.Size,
					Filename = x.Filename,
					Width = x.Width,
					Height = x.Height
				}).ToArray();
			}
			else
				Attachments = new Attachment[0];
			if (model.Embeds != null)
			{
				Embeds = model.Embeds.Select(x =>
				{
					var embed = new Embed
					{
						Url = x.Url,
						Type = x.Type,
						Description = x.Description,
						Title = x.Title
					};
					if (x.Provider != null)
					{
						embed.Provider = new EmbedReference
						{
							Url = x.Provider.Url,
							Name = x.Provider.Name
						};
					}
					if (x.Author != null)
					{
						embed.Author = new EmbedReference
						{
							Url = x.Author.Url,
							Name = x.Author.Name
						};
					}
					if (x.Thumbnail != null)
					{
						embed.Thumbnail = new File
						{
							Url = x.Thumbnail.Url,
							ProxyUrl = x.Thumbnail.ProxyUrl,
							Width = x.Thumbnail.Width,
							Height = x.Thumbnail.Height
						};
					}
					return embed;
				}).ToArray();
			}
			else
				Embeds = new Embed[0];
			IsMentioningEveryone = model.IsMentioningEveryone;
			IsTTS = model.IsTextToSpeech;
			MentionIds = model.Mentions?.Select(x => x.Id)?.ToArray() ?? new string[0];
			IsMentioningMe = MentionIds.Contains(_client.CurrentUserId);
			RawText = model.Content;
			_cleanText = null;
			Timestamp = model.Timestamp;
			EditedTimestamp = model.EditedTimestamp;
			if (model.Author != null)
				UserId = model.Author.Id;
		}
Esempio n. 16
0
 protected async Task <IUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false,
                                                   Embed embed = null, RequestOptions options      = null, bool isSpoiler = false)
 {
     return(await Context.Channel.SendFileAsync(filePath, text, isTTS, embed, options, isSpoiler));
 }
        public async Task LogAction(string action, bool logToFile = true, bool logToChannel = true, Embed embed = null)
        {
            if (logToChannel)
            {
                var channel = _client.GetChannel(_settings.BotAnnouncementChannel.Id) as ISocketMessageChannel;
                await channel.SendMessageAsync(action, false, embed);
            }

            if (logToFile)
            {
                File.AppendAllText(_settings.ServerRootPath + @"/log.txt",
                                   $"[{DateTime.Now:d/M/yy HH:mm:ss}] {action} {Environment.NewLine}");
            }
        }
Esempio n. 18
0
 public static Task <RestUserMessage> InlineReplyAsync(this SocketCommandContext message, string text, bool isTTS, Embed embed, AllowedMentions mentions, CancellationToken cancellationToken)
 => InlineReplyAsync(message.Message, text, isTTS, embed, mentions, new RequestOptions {
     CancelToken = cancellationToken
 });
Esempio n. 19
0
 protected void SendGameMsg(string msg, Embed embed)
 {
     Channel.SendMessageAsync(msg, embed: embed).GetAwaiter().GetResult();
 }
Esempio n. 20
0
 public static Task <RestUserMessage> InlineReplyAsync(this SocketMessage message, string text = null, bool isTTS = false, Embed embed = null, AllowedMentions mentions = null, RequestOptions options = null)
 => message.Channel.SendMessageAsync(text, isTTS, embed, options, mentions, new MessageReference(message.Id, message.Channel?.Id, (message.Channel as IGuildChannel)?.GuildId));
Esempio n. 21
0
        public async Task ProcessCommandAsync(SocketMessage msg)
        {
            var message = msg as SocketUserMessage;

            if (message == null)
            {
                return;
            }

            int argPos  = 0;
            var context = new SocketCommandContext(Client, message);
            List <DiscordCustomPrefix> guildPrefixes = await PrefixService.GetGuildPrefixes(context.Guild);

            string FinalPrefix = Config.Prefix;

            foreach (DiscordCustomPrefix prefix in guildPrefixes)
            {
                argPos = 0;
                if (message.HasStringPrefix(prefix.Prefix, ref argPos))
                {
                    FinalPrefix = prefix.Prefix;
                    break;
                }
                argPos = 0;
            }
            if (message.HasStringPrefix(FinalPrefix, ref argPos))
            {
                string commandExecuted = message.Content.Split(' ')[0].Replace(FinalPrefix, "");
                if (!Provider.GetService <CooldownService>().IsCooldownExpired(context.Guild.Id, commandExecuted))
                {
                    CommandInfo cmdInfo       = Commands.FindInfoByName(commandExecuted);
                    Embed       cooldownEmbed = Provider.GetService <EmbedService>().MakeFailFeedbackEmbed($"The command `{cmdInfo.Name}` cannot be used for another {Math.Max(Provider.GetService<CooldownService>().GetRemainingTime(context.Guild.Id, cmdInfo), 1)} seconds!");
                    await context.Channel.SendMessageAsync(cooldownEmbed, lifeTime : Provider.GetService <Config>().FeedbackMessageLifeTime);

                    return;
                }
                var result = await Commands.ExecuteAsync(context, argPos, Provider);

                if (result.IsSuccess)
                {
                    CommandInfo cmdInfo = Commands.FindInfoByName(commandExecuted);
                    if (cmdInfo != null)
                    {
                        foreach (var attr in cmdInfo.Preconditions)
                        {
                            if (attr.GetType() == typeof(RequireCooldownAttribute))
                            {
                                RequireCooldownAttribute cooldownAttr = attr as RequireCooldownAttribute;
                                Provider.GetService <CooldownService>().SetCooldown(context.Guild.Id, cmdInfo, cooldownAttr.Seconds);
                            }
                        }

                        using (BotDBContext DBContext = Provider.GetService <DBContextFactory>().Create <BotDBContext>())
                        {
                            string arguments = message.Content.Replace($"{FinalPrefix}{commandExecuted} ", "").Replace($"{FinalPrefix}{commandExecuted}", "");
                            DBContext.CommandLogs.Add(new DiscordCommandLog(message.Author.Id.ToString(), cmdInfo.Name, arguments, context.Channel.Id.ToString(), context.Guild.Id.ToString(), DateTime.Now));
                            await DBContext.SaveChangesAsync();
                        }
                    }
                }
                else
                {
                    ConsoleEx.WriteColoredLine(LogSeverity.Error, ConsoleTextFormat.TimeAndText, ConsoleColor.Red, $"[Command Error - {result.Error?.ToString()}] ", ConsoleColor.White, result.ErrorReason?.ToString());
                    int          lifeTime     = Provider.GetService <Config>().FeedbackMessageLifeTime;
                    EmbedService embedService = Provider.GetService <EmbedService>();
                    switch (result.Error?.ToString())
                    {
                    case "UnmetPrecondition":
                        Embed unmetEmbed = embedService.MakeFailFeedbackEmbed(result.ErrorReason);
                        await context.Channel.SendMessageAsync("", embed : unmetEmbed, lifeTime : lifeTime);

                        break;

                    case "UnknownCommand":
                        string err = "";
                        err = result.ErrorReason?.ToString();
                        bool badArgs = (err.Contains("This input does not match any overload."));
                        if (badArgs)
                        {
                            await TriggerBadArgEmbed(commandExecuted, context, FinalPrefix);

                            return;
                        }
                        List <FuzzyMatch> matches = Commands.FuzzySearch(commandExecuted);
                        if (matches.Count > 0)
                        {
                            string builtString = "";
                            foreach (FuzzyMatch match in matches)
                            {
                                builtString += $"{match.TextValue.Bold()}, ";
                            }

                            builtString = builtString.Substring(0, builtString.Length - 2);
                            Embed suggestEmbed = embedService.MakeFeedbackEmbed($"That command wasn't found.\nDid you mean {builtString}?");
                            await context.Channel.SendMessageAsync("", embed : suggestEmbed);
                        }
                        break;

                    case "BadArgCount":
                        await TriggerBadArgEmbed(commandExecuted, context, FinalPrefix);

                        break;

                    case "ParseFailed":
                        Embed badParseEmbed = embedService.MakeFailFeedbackEmbed("Failed to parse one of the arguments for that command.");
                        await context.Channel.SendMessageAsync("", embed : badParseEmbed, lifeTime : lifeTime);

                        break;

                    case "MultipleMatches":
                        Embed multiMatchEmbed = embedService.MakeFailFeedbackEmbed("Multiple matches were found.");
                        await context.Channel.SendMessageAsync("", embed : multiMatchEmbed, lifeTime : lifeTime);

                        break;

                    case "ObjectNotFound":
                        Embed notFoundEmbed = embedService.MakeFailFeedbackEmbed("One of your specified objects could not be found.");
                        await context.Channel.SendMessageAsync("", embed : notFoundEmbed, lifeTime : lifeTime);

                        break;
                    }
                }
            }
            else if (message.HasMentionPrefix(Provider.GetService <DiscordSocketClient>().CurrentUser, ref argPos))
            {
                using (var typingState = message.Channel.EnterTypingState())
                {
                    string query = message.Content.Replace(Provider.GetService <DiscordSocketClient>().CurrentUser.Mention + " ", "");
                    string resp  = await CleverbotAPI.AskAsync(query);

                    await message.Channel.SendMessageAsync(resp);

                    typingState.Dispose();
                }
            }
        }
Esempio n. 22
0
 public async Task <IUserMessage> SendMessageAsync(IMessageChannel channel, string message, Embed embed = null)
 {
     try
     {
         return(await channel.SendMessageAsync(message, false, embed));
     }
     catch (HttpException ex)
     {
         if (ex.DiscordCode == 50013)
         {
             await LogHelper.LogError($"The bot don't have rights to send message to {channel.Id} ({channel.Name}) channel!");
         }
         throw;
     }
 }
Esempio n. 23
0
        private async Task <IUserMessage> RespondAsync(SocketUserMessage message, string response, Embed embedResponse = null, bool bypassEdit = false, bool rateLimitChecked = false)
        {
            SocketGuild guild = (message.Channel as SocketGuildChannel)?.Guild;

            if (!rateLimitChecked)
            {
                this.Throttler.Increment(message.Author.Id.ToString(), ThrottleType.User);

                if (guild != null)
                {
                    this.Throttler.Increment(guild.Id.ToString(), ThrottleType.Guild);
                }
            }

            var props = new Dictionary <string, string> {
                { "server", guild?.Id.ToString() ?? "private" },
                { "channel", message.Channel.Id.ToString() },
            };

            this.TrackEvent("messageSent", props);

            response = response.SubstringUpTo(Discord.DiscordConfig.MaxMessageSize);

            if (!bypassEdit && this.botResponsesCache.Get(message.Id) is IUserMessage oldMsg)
            {
                try
                {
                    await oldMsg.ModifyAsync((m) =>
                    {
                        m.Content = response;
                        m.Embed   = embedResponse;
                    });
                }
                catch (HttpException ex) when(ex.DiscordCode == 10008)
                {
                    // ignore unknown messages; likely deleted
                }

                return(null);
            }
            else
            {
                return(await message.Channel.SendMessageAsync(response, false, embedResponse));
            }
        }
        public async Task <IUserMessage> ReplyAndDeleteAsync(SocketCommandContext context, string content, bool isTTS = false, Embed embed = null, TimeSpan?timeout = null, RequestOptions options = null)
        {
            timeout = timeout ?? _defaultTimeout;
            var message = await context.Channel.SendMessageAsync(content, isTTS, embed, options).ConfigureAwait(false);

            _ = Task.Delay(timeout.Value)
                .ContinueWith(_ => message.DeleteAsync().ConfigureAwait(false))
                .ConfigureAwait(false);
            return(message);
        }
Esempio n. 25
0
        private async Task <IUserMessage> RespondAsync(SocketUserMessage message, string response, Embed embedResponse = null, bool bypassEdit = false)
        {
            var props = new Dictionary <string, string> {
                { "server", (message.Channel as SocketGuildChannel)?.Guild.Id.ToString() ?? "private" },
                { "channel", message.Channel.Id.ToString() },
            };

            this.TrackEvent("messageSent", props);

            response = response.Substring(0, Math.Min(response.Length, 2000));

            if (!bypassEdit && this.botResponsesCache.Get(message.Id) is IUserMessage oldMsg)
            {
                await oldMsg.ModifyAsync((m) =>
                {
                    m.Content = response;
                    m.Embed   = embedResponse;
                });

                return(null);
            }
            else
            {
                return(await message.Channel.SendMessageAsync(response, false, embedResponse));
            }
        }
Esempio n. 26
0
        public async Task <string> SelectButtonAsync(IEnumerable <string> options, string text = null, Embed embed = null, bool deleteWhenDone = false, TimeSpan?timeout = null)
        {
            var builder = new ComponentBuilder();

            for (int i = 0; i < options.Count(); i++)
            {
                builder.WithButton(ButtonBuilder.CreatePrimaryButton(options.ElementAt(i), i.ToString()));
            }
            var btn = await SelectButtonAsync(builder, text, embed, deleteWhenDone, timeout).ConfigureAwait(false);

            return(options.ElementAt(int.Parse(btn.CustomId)));
        }
Esempio n. 27
0
 public static async Task <IUserMessage> MsgReplyEmbedAsync(this SocketCommandContext context, Embed emb, bool disalbeMention = true)
 {
     return(await context.Message.ReplyAsync(embed : emb, allowedMentions : disalbeMention?AllowedMentions.None : null));
 }
Esempio n. 28
0
 public RollResult(Embed embed) : base(null, null)
 {
     RollEmbed = embed;
 }
Esempio n. 29
0
        public async Task WoodcuttingLevel()
        {
            //Okay let's get the User
            Woodcutting wc;

            using (var uow = DBHandler.UnitOfWork())
            {
                wc = uow.Woodcutting.GetOrCreateWoodcutting(Context.User.Id);
            }

            //New list of stuff
            Dictionary <string, int> CutLogs = new Dictionary <string, int>()
            {
                { "Achey", wc.AcheyTrees },
                { "Arctic Pine", wc.ArcticTrees },
                { "Hollow", wc.HollowTrees },
                { "Magic", wc.MagicTrees },
                { "Mahogany", wc.MahoganyTrees },
                { "Maple", wc.MapleTrees },
                { "Normal", wc.NormalTrees },
                { "Oak", wc.OakTrees },
                { "Redwood", wc.RedwoodTrees },
                { "Sulliuscep", wc.SullTrees },
                { "Teak", wc.TeakTrees },
                { "Yew", wc.YewTrees }
            };

            //List sorted
            List <KeyValuePair <string, int> > logList = CutLogs.ToList();

            logList = logList.OrderByDescending(x => x.Value).ToList();

            //What's their axe level
            string axetype = "";

            foreach (int key in AxeLevel.Keys)
            {
                if (axetype != "")
                {
                    break;
                }
                else if (wc.Level >= key)
                {
                    axetype = AxeLevel[key];
                }
            }

            EmbedBuilder emb = new EmbedBuilder().WithTitle($"Wooductting XP | User: {Context.User.Username}").WithOkColour().WithDescription($"Level: {wc.Level} | Total XP: {wc.XP} | Axe Type: {axetype}");

            EmbedFieldBuilder embF = new EmbedFieldBuilder().WithName("Amount of Logs Chopped");

            string str = "";

            foreach (KeyValuePair <string, int> Tree in logList)
            {
                str += $"{Tree.Key} trees: {Tree.Value}\n";
            }

            str += $"\nTotal Logs: {CutLogs.Sum(x => x.Value)}";

            embF = embF.WithValue(str);

            //Add to emb
            Embed embdone = emb.AddField(embF).Build();

            //Send
            await Context.Channel.BlankEmbedAsync(embdone);
        }
Esempio n. 30
0
        public static bool TryParseOptionalElement(MrssOptionalElements optionalElements, XmlReader reader)
        {
            var parsed = false;

            try
            {
                switch (reader.LocalName)
                {
                    case Community.ELEMENT_NAME:
                        optionalElements.CommunityNode = new Community();
                        optionalElements.CommunityNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Comments.ELEMENT_NAME:
                        optionalElements.CommentsNode = new Comments();
                        optionalElements.CommentsNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Responses.ELEMENT_NAME:
                        optionalElements.ResponsesNode = new Responses();
                        optionalElements.ResponsesNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Backlinks.ELEMENT_NAME:
                        optionalElements.BacklinksNode = new Backlinks();
                        optionalElements.BacklinksNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Embed.ELEMENT_NAME:
                        var embedNode = new Embed();
                        embedNode.ReadXml(reader);
                        if (optionalElements.EmbedNodes == null)
                            optionalElements.EmbedNodes = new List<Embed>();
                        optionalElements.EmbedNodes.Add(embedNode);
                        parsed = true;
                        break;
                    case Price.ELEMENT_NAME:
                        optionalElements.PriceNode = new Price();
                        optionalElements.PriceNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case License.ELEMENT_NAME:
                        optionalElements.LicenseNode = new License();
                        optionalElements.LicenseNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case PeerLink.ELEMENT_NAME:
                        optionalElements.PeerLinkNode = new PeerLink();
                        optionalElements.PeerLinkNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case SubTitle.ELEMENT_NAME:
                        optionalElements.SubTitleNode = new SubTitle();
                        optionalElements.SubTitleNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Restriction.ELEMENT_NAME:
                        optionalElements.RestrictionNode = new Restriction();
                        optionalElements.RestrictionNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Status.ELEMENT_NAME:
                        optionalElements.StatusNode = new Status();
                        optionalElements.StatusNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Scenes.ELEMENT_NAME:
                        optionalElements.ScenesNode = new Scenes();
                        optionalElements.ScenesNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Description.ELEMENT_NAME:
                        optionalElements.DescriptionNode = new Description();
                        optionalElements.DescriptionNode.ReadXml(reader);
                        parsed = true;
                        break;
                    case Thumbnail.ELEMENT_NAME:
                        optionalElements.ThumbnailNode = new Thumbnail();
                        optionalElements.ThumbnailNode.ReadXml(reader);
                        parsed = true;
                        break;
                }

                return parsed;
            }
            catch (Exception)
            {
                //TODO Log error
                return false;
            }
        }
Esempio n. 31
0
        public async Task TreeList()
        {
            //List of trees
            Dictionary <string, int> TreeToID = new Dictionary <string, int>()
            {
                { "Normal", 1 },
                { "Achey", 1 },
                { "Oak", 15 },
                { "Willow", 30 },
                { "Teak", 35 },
                { "Maple", 45 },
                { "Hollow", 45 },
                { "Mahogany", 50 },
                { "Arctic Pine", 54 },
                { "Yew", 60 },
                { "Sulliuscep", 65 },
                { "Magic", 75 },
                { "Redwood", 90 }
            };

            //Okay let's get the User
            Woodcutting wc;

            using (var uow = DBHandler.UnitOfWork())
            {
                wc = uow.Woodcutting.GetOrCreateWoodcutting(Context.User.Id);
            }

            //wowoowowwowo
            EmbedBuilder emb = new EmbedBuilder().WithTitle("Woodcutting | Trees");

            //New field
            EmbedFieldBuilder embF = new EmbedFieldBuilder().WithName("You can chop these");
            string            str  = "";

            //Lets get the ones we CAN cut
            foreach (KeyValuePair <string, int> Tree in TreeToID)
            {
                if (wc.Level >= Tree.Value)
                {
                    //Aa?
                    string logName  = Tree.Key.ToLower().Replace(' ', '_');
                    double XPperLog = TreeXP[TreeID[logName]];

                    //Aaa
                    str += $"{Tree.Key} | Level: {Tree.Value} | XP Per Log: {XPperLog} | Log Value: {LogValues[TreeID[logName]]}\n";
                }
            }

            //Add to field
            embF = embF.WithValue(str);

            //Neewwww
            EmbedFieldBuilder embF2 = new EmbedFieldBuilder().WithName("You cannot chop these");
            string            str2  = "";

            //Stuff you can't do
            //Lets get the ones we CAN cut
            foreach (KeyValuePair <string, int> Tree in TreeToID)
            {
                if (wc.Level < Tree.Value)
                {
                    //Aa?
                    string logName  = Tree.Key.ToLower().Replace(' ', '_');
                    double XPperLog = TreeXP[TreeID[logName]];

                    //Aaa
                    str2 += $"{Tree.Key} | Level: {Tree.Value} | XP Per Log: {XPperLog}\n";
                }
            }

            if (str2 == "")
            {
                str2 = "*You can now chop all trees.*";
            }

            //Add to field
            embF2 = embF2.WithValue(str2);

            //Add fields
            Embed embDone = emb.AddField(embF).AddField(embF2).WithOkColour().Build();

            //Respond
            await Context.Channel.BlankEmbedAsync(embDone);
        }
Esempio n. 32
0
 public static Task <RestUserMessage> ReplyAsync(this SocketMessage message, string text = null, bool isTTS = false, Embed embed = null, AllowedMentions mentions = null, RequestOptions options = null)
 => message.Channel.SendMessageAsync(text, isTTS, embed, options, mentions);
Esempio n. 33
0
 public void AddEmbed(Embed embed)
 {
     pages.Add(embed);
 }