606 lines
26 KiB
C#
606 lines
26 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using DSharpPlus;
|
|
using DSharpPlus.CommandsNext;
|
|
using DSharpPlus.CommandsNext.Exceptions;
|
|
using DSharpPlus.Entities;
|
|
using DSharpPlus.EventArgs;
|
|
using DSharpPlus.Interactivity;
|
|
using DSharpPlus.Interactivity.Enums;
|
|
using DSharpPlus.Interactivity.Extensions;
|
|
using DSharpPlus.VoiceNext;
|
|
using DSharpPlus.VoiceNext.Codec;
|
|
using Microsoft.Extensions.Logging;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace StarsiegeBot
|
|
{
|
|
class Program
|
|
{
|
|
public static DiscordMember notify;
|
|
public readonly EventId BotEventId = new EventId(42, "Bot-Ex04");
|
|
|
|
public DiscordClient Client { get; set; }
|
|
public CommandsNextExtension Commands { get; set; }
|
|
public VoiceNextExtension Voice { get; set; }
|
|
|
|
protected string BotName { get; set; }
|
|
|
|
private async Task StartTimer(CancellationToken cancellationToken)
|
|
{
|
|
await Task.Run(async () =>
|
|
{
|
|
while (true)
|
|
{
|
|
string output = JsonConvert.SerializeObject(BotSettings.GuildSettings);
|
|
await File.WriteAllTextAsync("guildSettings.json", output);
|
|
await Task.Delay(TimeSpan.FromSeconds(120), cancellationToken);
|
|
if (cancellationToken.IsCancellationRequested)
|
|
{
|
|
Console.WriteLine("Token Cancelled.");
|
|
break;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
public static void Main(string[] args)
|
|
{
|
|
// since we cannot make the entry method asynchronous,
|
|
// let's pass the execution to asynchronous code
|
|
var prog = new Program(args);
|
|
prog.
|
|
RunBotAsync().
|
|
GetAwaiter().
|
|
GetResult();
|
|
}
|
|
|
|
public Program(string[] args)
|
|
{
|
|
if (args.Length > 0)
|
|
BotName = args[0].ToLower();
|
|
else
|
|
BotName = "sspdev";
|
|
|
|
BotEventId = new EventId(276, BotName);
|
|
}
|
|
|
|
public async Task RunBotAsync()
|
|
{
|
|
|
|
// next, let's load the values from that file
|
|
// to our client's configuration
|
|
var cfg = new DiscordConfiguration
|
|
{
|
|
Token = Environment.GetEnvironmentVariable(BotName + "Token"),
|
|
TokenType = TokenType.Bot,
|
|
|
|
AutoReconnect = true,
|
|
MinimumLogLevel = LogLevel.Debug,
|
|
Intents = DiscordIntents.All,
|
|
};
|
|
|
|
// then we want to instantiate our client
|
|
this.Client = new DiscordClient(cfg);
|
|
|
|
// next, let's hook some events, so we know
|
|
// what's going on
|
|
|
|
this.Client.UseInteractivity(new InteractivityConfiguration()
|
|
{
|
|
PollBehaviour = PollBehaviour.KeepEmojis,
|
|
Timeout = TimeSpan.FromSeconds(15)
|
|
});
|
|
|
|
// up next, let's set up our commands
|
|
var ccfg = new CommandsNextConfiguration
|
|
{
|
|
// let's use the string prefix defined in config.json
|
|
StringPrefixes = new[] { Environment.GetEnvironmentVariable("CommandPrefix") },
|
|
|
|
// enable responding in direct messages
|
|
EnableDms = true,
|
|
|
|
// enable mentioning the bot as a command prefix
|
|
EnableMentionPrefix = true,
|
|
|
|
UseDefaultCommandHandler = false
|
|
};
|
|
|
|
// and hook them up
|
|
this.Commands = this.Client.UseCommandsNext(ccfg);
|
|
|
|
// Hook all possible Event Handlers in the system.
|
|
this.Client.ChannelCreated += this.Event_ChannelCreated;
|
|
this.Client.ChannelDeleted += this.Event_ChannelDeleted;
|
|
this.Client.ChannelPinsUpdated += this.Event_ChannelPinsUpdated;
|
|
this.Client.ChannelUpdated += this.Event_ChannelUpdated;
|
|
this.Client.ClientErrored += this.Event_ClientErrored;
|
|
this.Client.DmChannelDeleted += this.Event_DmChannelDeleted;
|
|
this.Client.GuildAvailable += this.Event_GuildAvailable;
|
|
this.Client.GuildBanAdded += this.Event_GuildBanAdded;
|
|
this.Client.GuildBanRemoved += this.Event_GuildBanRemoved;
|
|
this.Client.GuildCreated += this.Event_GuildCreated;
|
|
this.Client.GuildDeleted += this.Event_GuildDeleted;
|
|
this.Client.GuildDownloadCompleted += this.Event_GuildDownloadCompleted;
|
|
this.Client.GuildEmojisUpdated += this.Event_GuildEmojisUpdated;
|
|
this.Client.GuildIntegrationsUpdated += this.Event_GuildIntegrationsUpdated;
|
|
this.Client.GuildMemberAdded += this.Event_GuildMemberAdded;
|
|
this.Client.GuildMemberRemoved += this.Event_GuildMemberRemoved;
|
|
this.Client.GuildMembersChunked += this.Event_GuildMembersChunked;
|
|
this.Client.GuildMemberUpdated += this.Event_GuildMemberUpdated;
|
|
this.Client.GuildRoleCreated += this.Event_GuildRoleCreated;
|
|
this.Client.GuildRoleDeleted += this.Event_GuildRoleDeleted;
|
|
this.Client.GuildRoleUpdated += this.Event_GuildRoleUpdated;
|
|
this.Client.GuildUnavailable += this.Event_GuildUnavailable;
|
|
this.Client.GuildUpdated += this.Event_GuildUpdated;
|
|
this.Client.Heartbeated += this.Event_Heartbeated;
|
|
this.Client.InviteCreated += this.Event_InviteCreated;
|
|
this.Client.InviteDeleted += this.Event_InviteDeleted;
|
|
this.Client.MessageAcknowledged += this.Event_MessageAcknowledged;
|
|
this.Client.MessageCreated += this.Event_MessageCreated;
|
|
this.Client.MessageDeleted += this.Event_MessageDeleted;
|
|
this.Client.MessageReactionAdded += this.Event_MessageReactionAdded;
|
|
this.Client.MessageReactionRemoved += this.Event_MessageReactionRemoved;
|
|
this.Client.MessageReactionRemovedEmoji += this.Event_MessageReactionRemovedEmoji;
|
|
this.Client.MessageReactionsCleared += this.Event_MessageReactionsCleared;
|
|
this.Client.MessagesBulkDeleted += this.Event_MessagesBulkDeleted;
|
|
this.Client.MessageUpdated += this.Event_MessageUpdated;
|
|
this.Client.PresenceUpdated += this.Event_PresenceUpdated;
|
|
this.Client.Ready += this.Event_Ready;
|
|
this.Client.Resumed += this.Event_Resumed;
|
|
this.Client.SocketClosed += this.Event_SocketClosed;
|
|
this.Client.SocketErrored += this.Event_SocketErrored;
|
|
this.Client.SocketOpened += this.Event_SocketOpened;
|
|
this.Client.TypingStarted += this.Event_TypingStarted;
|
|
this.Client.UnknownEvent += this.Event_UnknownEvent;
|
|
this.Client.UserSettingsUpdated += this.Event_UserSettingsUpdated;
|
|
this.Client.UserUpdated += this.Event_UserUpdated;
|
|
this.Client.VoiceServerUpdated += this.Event_VoiceServerUpdated;
|
|
this.Client.VoiceStateUpdated += this.Event_VoiceStateUpdated;
|
|
this.Client.WebhooksUpdated += this.Event_WebhooksUpdated;
|
|
|
|
this.Client.ApplicationCommandCreated += this.Event_ApplicationCommandCreated;
|
|
this.Client.ApplicationCommandDeleted += this.Event_ApplicationCommandDeleted;
|
|
this.Client.ApplicationCommandUpdated += this.Event_ApplicationCommandUpdated;
|
|
|
|
this.Client.InteractionCreated += this.Event_InteractionCreated;
|
|
|
|
this.Commands.CommandExecuted += this.Event_CommandExecuted;
|
|
this.Commands.CommandErrored += this.Event_CommandErrored;
|
|
|
|
// up next, let's register our commands
|
|
this.Commands.RegisterCommands<Commands>();
|
|
// this.Commands.RegisterCommands<SnappleFacts>();
|
|
this.Commands.RegisterCommands<BotSettings>(); // Main Folder. Test Items.
|
|
this.Commands.RegisterCommands<RoleManagement>(); // Main Folder. Test Items.
|
|
this.Commands.RegisterCommands<LevelRoleManagement>(); // Main Folder. Test Items.
|
|
this.Commands.RegisterCommands<GroupRoleManagement>(); // Main Folder. Test Items.
|
|
this.Commands.RegisterCommands<LevelManagement>(); // Main Folder. Test Items.
|
|
this.Commands.RegisterCommands<GroupManagement>(); // Main Folder. Test Items.
|
|
|
|
// All these commands are in the STARSIEGE folder.
|
|
//if (BotName.Contains("ssp"))
|
|
//{
|
|
this.Commands.RegisterCommands<Quickchat>();
|
|
this.Commands.RegisterCommands<Functions>();
|
|
this.Commands.RegisterCommands<DeathMessages>();
|
|
this.Commands.RegisterCommands<StarsiegeCommands>();
|
|
//}
|
|
Task thisTimer = StartTimer(new CancellationToken());
|
|
|
|
// let's enable voice
|
|
this.Voice = this.Client.UseVoiceNext();
|
|
|
|
// finally, let's connect and log in
|
|
await this.Client.ConnectAsync();
|
|
|
|
// and this is to prevent premature quitting
|
|
await Task.Delay(-1);
|
|
}
|
|
|
|
private Task Event_MessageCreated(DiscordClient d, MessageCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageCreated.");
|
|
|
|
// Ignore all bots. We don't care.
|
|
if (e.Author.IsBot)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
CommandsNextExtension cnext = d.GetCommandsNext();
|
|
DiscordMessage msg = e.Message;
|
|
|
|
// Check if message has valid prefix.
|
|
// json file loaded...
|
|
int cmdStart = msg.GetStringPrefixLength("!");
|
|
|
|
// if Guild is null, do nothing for now.
|
|
if (e.Guild is null)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
string gId = e.Guild.Id.ToString();
|
|
List<string> prefixes = BotSettings.GuildSettings["default"].Prefixes;
|
|
// Check to see if the guild has settings.
|
|
if (BotSettings.GuildSettings.ContainsKey(gId))
|
|
{
|
|
// see if the guild wants global prefixes.
|
|
if (BotSettings.GuildSettings[gId].UseGlobalPrefix)
|
|
{
|
|
// add the Guild prefixes to the list of others.
|
|
prefixes = prefixes.Concat(BotSettings.GuildSettings[gId].Prefixes).ToList();
|
|
}
|
|
else
|
|
{
|
|
// dont use defaults? reset list to just the guild prefixes.
|
|
prefixes = BotSettings.GuildSettings[gId].Prefixes;
|
|
}
|
|
}
|
|
|
|
// check each prefix. break on the one that is evoked.
|
|
foreach (string item in prefixes)
|
|
{
|
|
cmdStart = msg.GetStringPrefixLength(item);
|
|
if (cmdStart != -1) break;
|
|
}
|
|
// we didn't find a command prefix... Break.
|
|
if (cmdStart == -1) return Task.CompletedTask;
|
|
|
|
// Retrieve prefix.
|
|
var prefix = msg.Content.Substring(0, cmdStart);
|
|
var cmdString = msg.Content.Substring(cmdStart);
|
|
|
|
// Retrieve full command string.
|
|
var command = cnext.FindCommand(cmdString, out var args);
|
|
if (command == null) return Task.CompletedTask;
|
|
|
|
var ctx = cnext.CreateContext(msg, prefix, command, args);
|
|
Task.Run(async () => await cnext.ExecuteCommandAsync(ctx));
|
|
}
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Task Event_CommandExecuted(CommandsNextExtension ext, CommandExecutionEventArgs e)
|
|
{
|
|
if (e.Context.Client.Guilds.Count > 75)
|
|
e.Context.Client.Logger.LogCritical(BotEventId, $"Client is in {e.Context.Client.Guilds.Count}");
|
|
// let's log the name of the command and user
|
|
e.Context.Client.Logger.LogInformation(BotEventId, $"{e.Context.User.Username} successfully executed '{e.Command.QualifiedName}'");
|
|
|
|
// since this method is not async, let's return
|
|
// a completed task, so that no additional work
|
|
// is done
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Task Event_CommandErrored(CommandsNextExtension ext, CommandErrorEventArgs e)
|
|
{
|
|
// let's log the error details
|
|
|
|
e.Context.Client.Logger.LogError(BotEventId, $"{e.Context.User.Username} tried executing '{e.Command?.QualifiedName ?? "<unknown command>"}' but it errored: {e.Exception.GetType()}: {e.Exception.Message ?? "<no message>"}", DateTime.Now);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private Task Event_InteractionCreated(DiscordClient d, InteractionCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, $"{e.Interaction.User.Username} started an interaction. {e.Interaction.Data.Name}");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ChannelCreated(DiscordClient d, ChannelCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, $"{e.Channel.Name} was created on {e.Guild.Name}. Type: {e.Channel.Type}");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ChannelDeleted(DiscordClient d, ChannelDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ChannelDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ApplicationCommandCreated(DiscordClient d, ApplicationCommandEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ApplicationCommandCreated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ApplicationCommandDeleted(DiscordClient d, ApplicationCommandEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ApplicationCommandDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ApplicationCommandUpdated(DiscordClient d, ApplicationCommandEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ApplicationCommandUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ChannelPinsUpdated(DiscordClient d, ChannelPinsUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ChannelPinsUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ChannelUpdated(DiscordClient d, ChannelUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ChannelUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_ClientErrored(DiscordClient d, ClientErrorEventArgs e)
|
|
{
|
|
// let's log the details of the error that just
|
|
// occured in our client
|
|
d.Logger.LogError(BotEventId, e.Exception, "Exception occured");
|
|
|
|
// since this method is not async, let's return
|
|
// a completed task, so that no additional work
|
|
// is done
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_DmChannelDeleted(DiscordClient d, DmChannelDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_ClientErrored.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildAvailable(DiscordClient d, GuildCreateEventArgs e)
|
|
{
|
|
string gId = e.Guild.Id.ToString();
|
|
// this guild doesnt have settings, make a skel set for them.
|
|
if (BotSettings.GuildSettings is null)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
if (!BotSettings.GuildSettings.ContainsKey(gId))
|
|
{
|
|
Console.WriteLine("making config");
|
|
GuildSettings item = new GuildSettings();
|
|
item.UseAutoRoles = false;
|
|
item.UseGlobalPrefix = true;
|
|
item.UseLevelRoles = false;
|
|
item.UseLevels = false;
|
|
item.UseSelfRoles = false;
|
|
item.AllowRolesPurchase = false;
|
|
item.UseAutoRoles = false;
|
|
item.LevelRoles = new Dictionary<int, List<DiscordRole>>();
|
|
item.Prefixes = new List<string>();
|
|
item.SelfRoles = new Dictionary<string, Dictionary<string, int>>();
|
|
// this line... is a test line.
|
|
BotSettings.GuildSettings.Add(gId, item);
|
|
}
|
|
}
|
|
|
|
// let's log the name of the guild that was just
|
|
// sent to our client
|
|
d.Logger.LogInformation(BotEventId, $"Guild available: {e.Guild.Name}");
|
|
|
|
// since this method is not async, let's return
|
|
// a completed task, so that no additional work
|
|
// is done
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildBanAdded(DiscordClient d, GuildBanAddEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildBanAdded.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildBanRemoved(DiscordClient d, GuildBanRemoveEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildBanRemoved.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildCreated(DiscordClient d, GuildCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildCreated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildDeleted(DiscordClient d, GuildDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildDownloadCompleted(DiscordClient d, GuildDownloadCompletedEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildDownloadCompleted.");
|
|
notify = e.Guilds[376937422010974209].Members[139548200099905536];
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildEmojisUpdated(DiscordClient d, GuildEmojisUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildEmojisUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildIntegrationsUpdated(DiscordClient d, GuildIntegrationsUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildIntegrationsUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildMemberAdded(DiscordClient d, GuildMemberAddEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildMemberAdded.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildMemberRemoved(DiscordClient d, GuildMemberRemoveEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildMemberRemoved.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildMembersChunked(DiscordClient d, GuildMembersChunkEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildMembersChunked.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildMemberUpdated(DiscordClient d, GuildMemberUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildMemberUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildRoleCreated(DiscordClient d, GuildRoleCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildRoleCreated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildRoleDeleted(DiscordClient d, GuildRoleDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildRoleDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildRoleUpdated(DiscordClient d, GuildRoleUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildRoleUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildUnavailable(DiscordClient d, GuildDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildUnavailable.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_GuildUpdated(DiscordClient d, GuildUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_GuildUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_Heartbeated(DiscordClient d, HeartbeatEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_Heartbeated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_InviteCreated(DiscordClient d, InviteCreateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_InviteCreated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_InviteDeleted(DiscordClient d, InviteDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_InviteDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageAcknowledged(DiscordClient d, MessageAcknowledgeEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageAcknowledged.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageDeleted(DiscordClient d, MessageDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageReactionAdded(DiscordClient d, MessageReactionAddEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageReactionAdded.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageReactionRemoved(DiscordClient d, MessageReactionRemoveEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageReactionRemoved.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageReactionRemovedEmoji(DiscordClient d, MessageReactionRemoveEmojiEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageReactionRemovedEmoji.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageReactionsCleared(DiscordClient d, MessageReactionsClearEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageReactionsCleared.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessagesBulkDeleted(DiscordClient d, MessageBulkDeleteEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessagesBulkDeleted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_MessageUpdated(DiscordClient d, MessageUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_MessageUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_PresenceUpdated(DiscordClient d, PresenceUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_PresenceUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_Ready(DiscordClient d, ReadyEventArgs e)
|
|
{
|
|
// let's log the fact that this event occured
|
|
d.Logger.LogInformation(BotEventId, $"Client is ready to process events. Client is in: {d.Guilds.Count} Guilds.");
|
|
|
|
// since this method is not async, let's return
|
|
// a completed task, so that no additional work
|
|
// is done
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_Resumed(DiscordClient d, ReadyEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_Resumed.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_SocketClosed(DiscordClient d, SocketCloseEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_SocketClosed.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_SocketErrored(DiscordClient d, SocketErrorEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_SocketErrored.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_SocketOpened(DiscordClient d, SocketEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_SocketOpened.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_TypingStarted(DiscordClient d, TypingStartEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_TypingStarted.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_UnknownEvent(DiscordClient d, UnknownEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_UnknownEvent.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_UserSettingsUpdated(DiscordClient d, UserSettingsUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_UserSettingsUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_UserUpdated(DiscordClient d, UserUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_UserUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_VoiceServerUpdated(DiscordClient d, VoiceServerUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_VoiceServerUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_VoiceStateUpdated(DiscordClient d, VoiceStateUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_VoiceStateUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
private Task Event_WebhooksUpdated(DiscordClient d, WebhooksUpdateEventArgs e)
|
|
{
|
|
d.Logger.LogDebug(BotEventId, "Event_WebhooksUpdated.");
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
// this structure will hold data from config.json
|
|
public struct ConfigJson
|
|
{
|
|
[JsonProperty("token")]
|
|
public string Token { get; private set; }
|
|
|
|
[JsonProperty("prefix")]
|
|
public string CommandPrefix { get; private set; }
|
|
}
|
|
}
|
|
}
|