private async Task AcknowledgeInteraction(DiscordInteraction interaction, bool ephemeral)
        {
            var builder = new DiscordInteractionResponseBuilder()
                          .AsEphemeral(ephemeral);

            await interaction.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource, builder);
        }
Exemple #2
0
        public async Task Docs(InteractionContext ctx,
                               [Option("name", "Function name")] string name,
                               [Option("version", "Experimental or stable game version")]
                               Versions version)
        {
            var doc = this._docs.DocsDictionary[version.GetEnumDescription()];

            if (doc is null)
            {
                throw new NullReferenceException("There was an error while trying to get docs");
            }

            var(cat, func) = FindDoc(name, doc);

            if (cat is null && func is null)
            {
                var errMsg = new DiscordInteractionResponseBuilder()
                             .WithContent($"Function `{name}` not found.");
                await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, errMsg);

                return;
            }

            var baseUrl          = doc.BaseUrl;
            var funcName         = func !.Name;
            var argsFormatted    = FormatApiInputsAndOutputs(func.Arguments);
            var returnsFormatted = FormatApiInputsAndOutputs(func.Return);
            var info             = func.Info;
            var definition       = func.Def;
            var example          = $"```lua\n{func.Example}\n```";

            var embed = new DiscordEmbedBuilder();

            embed.WithTitle($"#{funcName}");
            embed.WithUrl($"{baseUrl}#{funcName}");
            embed.WithDescription($"`{definition}`\n\n{info}");
            embed.AddField("Arguments", argsFormatted);
            embed.AddField("Returns", returnsFormatted);
            embed.AddField("Example", example);
            embed.WithFooter($"API(game) Version: {doc.Version}");
            embed.WithColor(new DiscordColor(0xf0d080));

            var msg = new DiscordInteractionResponseBuilder()
                      .WithContent($"{baseUrl}#{funcName}")
                      .AddEmbed(embed.Build());

            await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, msg);
        }
Exemple #3
0
        private async Task <DiscordInteractionResponseBuilder> GetInteractionResponseAsync(Partner partner, bool isChanged = false,
                                                                                           DiscordChannel?channel          = null, string?errorMessage = null)
        {
            var builder = new DiscordInteractionResponseBuilder()
                          .AddEmbed(await GetRequiermentsEmbed(partner, channel));

            foreach (var item in await GetComponents(partner, isChanged, true))
            {
                builder.AddComponents(item);
            }

            if (errorMessage is not null)
            {
                builder.AddEmbed(ErrorBase().WithDescription(errorMessage));
            }

            return(builder);
        }
Exemple #4
0
            public async Task Av(
                InteractionContext ctx,
                [Option("user", "The user to get it for")]
                DiscordUser user = null
                )
            {
                var member = user is null
                    ? await ctx.Guild.GetMemberAsync(ctx.Member.Id)
                    : await ctx.Guild.GetMemberAsync(user.Id);

                var embed = new DiscordEmbedBuilder
                {
                    Title    = $"{member.Username}'s Avatar",
                    ImageUrl = member.AvatarUrl
                };
                var builder = new DiscordInteractionResponseBuilder().AddEmbed(embed.Build());

                builder.IsEphemeral = user is null;
                await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                              builder);
            }
Exemple #5
0
            public async Task Info(
                InteractionContext ctx,
                [Option("user", "The user to get it for")]
                DiscordUser user = null
                )
            {
                var member = user is null
                    ? await ctx.Guild.GetMemberAsync(ctx.Member.Id)
                    : await ctx.Guild.GetMemberAsync(user.Id);

                var embed = new DiscordEmbedBuilder
                {
                    Title = $"{member.Username}",
                }.WithThumbnail(member.AvatarUrl);

                if (member.Nickname is not null)
                {
                    embed.AddField("Nickname", member.Nickname);
                }

                embed.AddField("ID", member.Id.ToString());
                embed.AddField("Joined Discord", member.JoinedAt.ToString());
                embed.AddField($"Joined {ctx.Guild.Name}", member.CreationTimestamp.ToString());

                var hoistedRoles = member.Roles.Where(role => role.IsHoisted).ToArray();

                embed.AddField($"Hoisted Roles ({hoistedRoles.Length})", string.Join("", hoistedRoles.Take(6).Select(role => role.Mention)), true);

                var normalRoles = member.Roles.Where(role => !role.IsHoisted).Where(role => role.Id != ctx.Guild.Id).ToArray();

                embed.AddField($"Normal Roles ({normalRoles.Length})", string.Join("", normalRoles.Take(6).Select(role => role.Mention)), true);

                embed.AddField("Top Role", member.Roles.First().Mention, true);

                var builder = new DiscordInteractionResponseBuilder().AddEmbed(embed.Build());

                builder.IsEphemeral = user is null;
                await ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
                                              builder);
            }
Exemple #6
0
        private async Task Discord_InteractionCreated(DiscordClient sender, InteractionCreateEventArgs e)
        {
            if (e.Interaction.Type != InteractionType.AutoComplete)
            {
                return;
            }

            this.Discord.Logger.LogInformation($"AutoComplete: Focused: {e.Interaction.Data.Options.First().Focused}, Data: {e.Interaction.Data.Options.First().Value}");

            var option = e.Interaction.Data.Options.First();

            if (string.IsNullOrEmpty(option.Value as string))
            {
                return;
            }

            var builder = new DiscordInteractionResponseBuilder()
                          .AddAutoCompleteChoice(new DiscordAutoCompleteChoice(option.Value as string, "pog ig"));

            await e.Interaction.CreateResponseAsync(InteractionResponseType.AutoCompleteResult, builder);

            return;
        }