public async Task InitializeAsync(DiscordSocketClient client)
{
_client = client;
(_service as IDisposable)?.Dispose();
_service = new ServiceCollection()
.AddSingleton(client)
.AddSingleton(new InteractiveService(_client))
.BuildServiceProvider();
var cmdConfig = new CommandServiceConfig
{
DefaultRunMode = RunMode.Async
};
(_commands as IDisposable)?.Dispose();
_commands = new CommandService(cmdConfig);
await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _service);
_client.Disconnected += EventHandler.BotDisconnected;
_client.Connected += EventHandler.BotConnected;
_client.UserUpdated += EventHandler.UserUpdated;
_client.MessageReceived += HandleCommandAsync;
_client.UserBanned += EventHandler.UserBanned;
}
private async Task CreateAndRegisterCommands()
{
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton(_streamerDataRepository);
serviceCollection.AddSingleton(_settingsRepository);
serviceCollection.AddSingleton(_commandsRepository);
serviceCollection.AddSingleton(_botConfig);
serviceCollection.AddSingleton(_twitchClient);
serviceCollection.AddSingleton(_customCommandHandler);
serviceCollection.AddScoped <IAudioService, AudioService>();
serviceCollection.AddScoped <IYoutubeService, YoutubeService>();
serviceCollection.AddScoped <IVideoToAudioConverter, VideoToAudioConverter>();
var commandsServiceConfig = new CommandServiceConfig
{
CaseSensitiveCommands = false,
};
var commandsService = new CommandService(commandsServiceConfig);
Commands = new CommandHandler(Client, commandsService, serviceCollection.BuildServiceProvider(), _customCommandHandler, _botConfig);
await Commands.InstallCommandsAsync();
}
private async Task ConfigureOverseerAsync()
{
DiscordSocketConfig botConfig = new DiscordSocketConfig()
{
MessageCacheSize = ConfigManager.GetIntegerProperty(PropertyItem.MessageCacheSize),
AlwaysDownloadUsers = true,
DefaultRetryMode = RetryMode.AlwaysRetry,
LargeThreshold = 250,
};
var CommandServiceConfig = new CommandServiceConfig()
{
DefaultRunMode = RunMode.Async
};
_client = new DiscordSocketClient(botConfig);
_commands = new CommandService(CommandServiceConfig);
_services = new ServiceCollection()
.AddSingleton(_commands)
.AddSingleton(_client)
.BuildServiceProvider();
_client.MessageUpdated += MessageLogger.EditedMessageEvent;
_client.MessageDeleted += MessageLogger.DeletedMessageEvent;
_client.MessageReceived += MessageLogger.ReceivedMessageEvent;
_client.UserJoined += RoleApplication.ApplyPeasantRoleAsync;
_client.Ready += InitializeContext;
}
private void Button1_Click(object sender, EventArgs e)
{
CommandServiceConfig _CommandServiceConfig = new CommandServiceConfig
{
CaseSensitiveCommands = caseCheck.Checked,
IgnoreExtraArgs = ignoreChars.Checked
};
if (runModeAsync.Checked)
{
_CommandServiceConfig.DefaultRunMode = RunMode.Async;
}
else
{
_CommandServiceConfig.DefaultRunMode = RunMode.Sync;
}
if (logVerbose.Checked)
{
_CommandServiceConfig.LogLevel = Discord.LogSeverity.Verbose;
}
else
{
_CommandServiceConfig.LogLevel = Discord.LogSeverity.Warning;
}
Program.MainWindow.BOT.UpdateCommandConfig(_CommandServiceConfig);
}
protected override async Task InitializeCommandsAsync()
{
_log.LogDebug("Initializing CommandService");
try { (Commands as IDisposable)?.Dispose(); } catch { }
CommandsOptions options = this._commandOptions.CurrentValue;
CommandServiceConfig config = new CommandServiceConfig();
config.CaseSensitiveCommands = options.CaseSensitive;
if (options.DefaultRunMode != RunMode.Default)
{
config.DefaultRunMode = options.DefaultRunMode;
}
config.IgnoreExtraArgs = options.IgnoreExtraArgs;
this.Commands = new CommandService(config);
foreach (Assembly asm in options.Assemblies)
{
await this.Commands.AddModulesAsync(asm, _serviceProvider).ConfigureAwait(false);
}
foreach (Type t in options.Classes)
{
await this.Commands.AddModuleAsync(t, _serviceProvider).ConfigureAwait(false);
}
}
private ServiceProvider ConfigureServices()
{
var cmdConfig = new CommandServiceConfig()
{
IgnoreExtraArgs = true
};
var clientConfig = new DiscordSocketConfig()
{
MessageCacheSize = 1000
};
return(new ServiceCollection()
.AddSingleton <ConfigService>()
.AddSingleton <DiscordSocketClient>(_ => new DiscordSocketClient(clientConfig))
.AddSingleton <CommandService>(_ => new CommandService(cmdConfig))
.AddSingleton <Random>()
.AddSingleton <AchievementService>()
.AddSingleton <AudioService>()
.AddSingleton <CommandHandlingService>()
.AddSingleton <HangmanService>()
.AddSingleton <ReactionService>()
.AddSingleton <BaccaratService>()
.AddSingleton <CaptchaService>()
.AddSingleton <HttpClient>()
.AddSingleton <ImageService>()
.AddSingleton <MarkovService>()
.AddSingleton <StockService>()
.AddSingleton <GameService>()
.AddSingleton <WebService>()
.AddSingleton <RouletteService>()
.AddSingleton <SlotService>()
.AddSingleton <RonStockMarketService>()
//.AddSingleton<LootGenerator>(_ => new LootGenerator("TestData/"))
.BuildServiceProvider());
}
private async Task ConfigureSeymourAsync()
{
DiscordSocketConfig botConfig = new DiscordSocketConfig()
{
MessageCacheSize = ConfigManager.GetIntegerProperty(PropertyItem.MessageCacheSize),
AlwaysDownloadUsers = true,
DefaultRetryMode = RetryMode.AlwaysRetry,
LargeThreshold = 250,
};
var CommandServiceConfig = new CommandServiceConfig()
{
DefaultRunMode = RunMode.Async,
};
_client = new DiscordSocketClient(botConfig);
_commands = new CommandService(CommandServiceConfig);
_services = new ServiceCollection()
.AddSingleton(_commands)
.AddSingleton(_client)
.BuildServiceProvider();
_client.Log += Toolbox.Logging.Logger.Log;
_commands.CommandExecuted += OnCommandExecutedAsync;
_client.UserJoined += UserJoinedChecker.SanitizeJoinedUser;
_client.Ready += BotReady;
_client.MessageUpdated += MessageUpdatedEvent;
_client.ReactionAdded += MessageReactionHandler;
await RegisterCommandAsync();
}
/// <summary>
/// Initializes a new <see cref="CommandServiceEx"/> class with the provided configuration.
/// </summary>
/// <param name="config">The configuration class.</param>
///
/// <exception cref="InvalidOperationException">
/// The Discord.Commands.RunMode cannot be set to <see cref="RunMode.Default"/>.
/// </exception>
public CommandServiceEx(CommandServiceConfig config, DiscordSocketClient client) : base(config)
{
defaultRunMode = config.DefaultRunMode;
client.MessageReceived += OnMessageReceivedAsync;
//Log += OnLogAsync;
//CommandExecuted += OnCommandExecutedAsync;
}
public static async Task SetUp()
{
var config = new DiscordSocketConfig
{
AlwaysDownloadUsers = true,
ConnectionTimeout = 6000,
MessageCacheSize = 120,
ExclusiveBulkDelete = false,
DefaultRetryMode = RetryMode.AlwaysRetry
};
client = new DiscordSocketClient(config);
client.Ready += Ready;
client.Log += Log;
MessageHandler messageHandler = new MessageHandler(client);
var serviceConfig = new CommandServiceConfig
{
DefaultRunMode = RunMode.Async,
IgnoreExtraArgs = true
};
CommandService service = new CommandService(serviceConfig);
CommandHandler handler = new CommandHandler(client, service);
EXPManager XPManager = new EXPManager(client);
await handler.InstallCommandsAsync();
await client.LoginAsync(TokenType.Bot, HiddenInfo.mainToken);
await client.StartAsync();
}
public static async Task InstallCommandsAsync()
{
if (CommandService != null)
{
Logger.Log("Not installing commands as they have already been installed.", LogSeverity.Debug);
return;
}
Services = new ServiceCollection()
.AddSingleton <IYoutubeModuleService>(new YoutubeModuleService(DataManager.Secrets.GoogleApiKey))
.AddSingleton <IOsuModuleService>(new OsuModuleService(DataManager.Secrets.OsuClientId, DataManager.Secrets.OsuClientSecret))
.AddSingleton <ISpotifyModuleService>(new SpotifyModuleService(DataManager.Secrets.SpotifyClientId, DataManager.Secrets.SpotifyClientSecret))
.BuildServiceProvider();
// TODO: inject this the proper way. need to get DownloadService non-static first.
Modules.Voice.DownloadService.YouTubeService = Services.GetService <IYoutubeModuleService>();
Modules.Voice.DownloadService.SpotifyService = Services.GetService <ISpotifyModuleService>();
var config = new CommandServiceConfig()
{
IgnoreExtraArgs = true,
LogLevel = LogSeverity.Info,
DefaultRunMode = RunMode.Async,
};
CommandService = new CommandService(config);
CommandService.Log += DiscordLogRecievedAsync;
await CommandService.AddModulesAsync(Assembly.GetEntryAssembly(), Services);
Logger.Log("Installed commands.", LogSeverity.Debug);
}
private static void ConfigureServices(HostBuilderContext hbc, IServiceCollection serviceCollection)
{
var discordSettings = hbc.Configuration.GetSection("discord").Get <DiscordSettings>();
serviceCollection
.AddSingleton(discordSettings)
.AddSingleton(sp => {
var config = new CommandServiceConfig();
config.CaseSensitiveCommands = false;
config.DefaultRunMode = RunMode.Sync;
config.IgnoreExtraArgs = false;
config.LogLevel = Discord.LogSeverity.Debug;
config.ThrowOnError = true;
var service = new CommandService(config);
return(service);
})
.AddSingleton <Func <PolarisDbContext> >(CreateDatabase)
.AddTransient <DatabaseStorage>()
.AddSingleton <DiscordSocketClient>()
.AddSingleton <IClaimManager, ServerClaimManager>()
.AddSingleton <IClaimProvider, ServerClaimProvider>()
.AddHostedService <PluginService>()
.AddHostedService <DiscordService>()
.AddHostedService <GuildService>();
}
public async Task RunSystem()
{
var _config = new DiscordSocketConfig {
AlwaysDownloadUsers = true
};
client = new DiscordSocketClient(_config);
var config = new CommandServiceConfig {
DefaultRunMode = RunMode.Async
};
commands = new CommandService(config);
services = new ServiceCollection()
.AddSingleton(client)
.AddSingleton(commands)
.BuildServiceProvider();
//event subscriptions
client.Log += Log;
await RegisterCommandsAsync();
await client.LoginAsync(TokenType.Bot, BOT_TOKEN);
await client.StartAsync();
await client.SetGameAsync(name : "WyoHackathon 2019");
await Task.Delay(-1);
}
public async Task BotMain()
{
_logger = new Tracker.Logger();
DiscordSocketConfig clientConfiguration = new DiscordSocketConfig {
LogLevel = _logger.LogLevel, MessageCacheSize = 1000
};
CommandServiceConfig commandConfiguration = new CommandServiceConfig {
LogLevel = _logger.LogLevel
};
_discordClient = new DiscordSocketClient(clientConfiguration);
_discordClient.Log += _logger.Log;
_discordCommandService = new CommandService(commandConfiguration);
_discordCommandService.Log += _logger.Log;
_commandHandler = new Tracker.CommandHandler(_discordClient, _discordCommandService);
string loginToken = new Tracker.BotToken("token.txt", Tracker.BotTokenPathType.Relative).Token;
await _discordClient.LoginAsync(TokenType.Bot, loginToken);
await _discordClient.StartAsync();
await Task.Delay(-1);
}
public Cirilla(LogSeverity logSeverity)
{
DiscordSocketConfig config = new DiscordSocketConfig {
LogLevel = logSeverity
};
Client = new DiscordSocketClient(config);
Client.Log += Log;
Client.MessageReceived += MessageReceived;
Client.UserJoined += EventHelper.UserJoined;
Client.UserLeft += EventHelper.UserLeft;
CommandServiceConfig serviceConfig = new CommandServiceConfig {
CaseSensitiveCommands = false,
SeparatorChar = '$',
LogLevel = logSeverity
};
_service = new CommandService(serviceConfig);
_service.Log += Log;
_service.AddModulesAsync(Assembly.GetEntryAssembly()).GetAwaiter().GetResult();
try {
Login().GetAwaiter().GetResult();
} catch (Exception ex) {
ConsoleHelper.Log($"Could not login as Discord Bot! {ex.Message}", LogSeverity.Critical);
}
}
/// <summary>
/// Configures the base services that are required for the bot to function.
/// </summary>
/// <returns>The service collection to reference for this bot service provider.</returns>
private IServiceCollection ConfigureServices()
{
IConfigurationRoot config = discordBot.Config;
DiscordSocketConfig discordConfig = discordBot.GetDiscordSocketConfig();
CommandServiceConfig commandConfig = discordBot.GetCommandServiceConfig();
ReliabilityConfig reliabilityConfig = discordBot.GetReliabilityConfig();
// Are we running on <= Windows 7?
// Standard websocket only works for Windows 8+.
if (RequiresWS4Net)
{
discordConfig.WebSocketProvider = WS4NetProvider.Instance;
}
ServiceCollection services = new ServiceCollection();
discordBot.ConfigureServices(services);
discordBot.ConfigureDatabase(services);
return(services
.AddSingleton <DiscordSocketClient>()
.AddSingleton <CommandServiceEx>()
.AddSingleton <StartupService>()
.AddSingleton <ReliabilityService>()
.AddSingleton(config)
.AddSingleton(discordConfig)
.AddSingleton(commandConfig)
.AddSingleton(reliabilityConfig)
.AddSingleton(discordBot)
.AddSingleton(args) // (Make startup args accessible)
);
}
public async Task StartAsync()
{
Log.Logger.Information("Application Starting");
var hostBuilder = Host.CreateDefaultBuilder();
// Discord Configuration
var discordConfig = new DiscordSocketConfig
{
LogLevel = _config.GetSection("discordHost").GetValue <LogSeverity>("logLevel"),
AlwaysDownloadUsers = _config.GetSection("discordHost").GetValue <bool>("AlwaysDownloadUsers"),
MessageCacheSize = _config.GetSection("discordHost").GetValue <int>("messageCacheSize"),
};
hostBuilder.ConfigureDiscordHost <DiscordSocketClient>((context, discordHostConfig) =>
{
discordHostConfig.SocketConfig = discordConfig;
discordHostConfig.Token = _config.GetValue <string>("token");
});
// Discord Command configuration
var commandConfig = new CommandServiceConfig
{
DefaultRunMode = _config.GetSection("commandService").GetValue <RunMode>("runMode"),
LogLevel = _config.GetSection("commandService").GetValue <LogSeverity>("logLevel"),
CaseSensitiveCommands = _config.GetSection("commandService").GetValue <bool>("caseSensitiveCommands")
};
hostBuilder.UseCommandService((context, commandServiceConfig) =>
{
commandServiceConfig = commandConfig;
});
// Services
hostBuilder.ConfigureServices((context, services) =>
{
services.AddSingleton(_config);
services.AddHostedService <CommandHandler>();
services.AddSingleton <ProfileGenerator>();
services.AddDbContext <RootDatabase>();
services.AddSingleton <Users>();
});
hostBuilder.UseConsoleLifetime();
hostBuilder.UseSerilog();
try
{
var host = hostBuilder.Build();
using (host)
{
await host.RunAsync();
}
}
catch (Exception ex)
{
Log.Logger.Error(ex.Message);
}
}
public QuotedCommandHandler(IServiceProvider provider, DiscordSocketClient client,
CommandServiceConfig commandServiceConfig, CommandHandlerOptions options, CustomModuleBuilder moduleBuilder,
IEnumerable <IPluginFactory> pluginFactories,
ILogger <PrefixCommandHandler> logger, CommandService commandService, GuildConfigRepository guildConfigRepository, RepeatRepository repeatRepository)
: base(provider, client, commandServiceConfig, options, moduleBuilder, pluginFactories, logger, commandService, guildConfigRepository, repeatRepository)
{
base.logger = logger;
}
public void UpdateCommandConfig(CommandServiceConfig csc)
{
_ = _client.LogoutAsync().GetAwaiter();
_CommandServiceConfig = csc;
ConfigureBot();
RegisterCommandsAsync().GetAwaiter();
_ = Login(Program.MainWindow._KEY).GetAwaiter();
}
public CommandHandler(CommandServiceConfig config) : base(config)
{
_logger = new Logger <CommandHandler>();
AddModulesAsync(Assembly.GetAssembly(typeof(Modules.Module)), Container.GetServiceProvider()).Wait();
Log += OnLogAsync;
}
public Setup()
{
var config = new CommandServiceConfig {
DefaultRunMode = RunMode.Async
};
_command = new CommandService(config);
}
public void ConfigureServices(IServiceCollection services)
{
var connectionString = Configuration.GetConnectionString("Default");
var basePath = Configuration.GetValue <string>("FilesBasePath");
services
.AddFileSystem(builder => builder.Use(basePath))
.AddDatabase(connectionString)
.AddWebAuthentication()
.AddHandlers()
.AddLoggers()
.AddMemoryCache()
.AddCors()
.AddMessageCache()
.AddHttpClient()
.AddScoped <FileExtensionContentTypeProvider>()
.AddControllersWithViews();
var pages = services.AddRazorPages();
#if DEBUG
pages.AddRazorRuntimeCompilation();
#endif
const GatewayIntents intents = GatewayIntents.Guilds | GatewayIntents.GuildMembers | GatewayIntents.GuildBans | GatewayIntents.GuildEmojis | GatewayIntents.GuildIntegrations | GatewayIntents.GuildInvites |
GatewayIntents.GuildVoiceStates | GatewayIntents.GuildPresences | GatewayIntents.GuildMessages | GatewayIntents.GuildMessageReactions | GatewayIntents.GuildMessageTyping | GatewayIntents.DirectMessages |
GatewayIntents.DirectMessageReactions | GatewayIntents.DirectMessageTyping;
var config = new DiscordSocketConfig()
{
LogLevel = LogSeverity.Verbose,
MessageCacheSize = 50000,
GatewayIntents = intents
};
var commandsConfig = new CommandServiceConfig()
{
LogLevel = LogSeverity.Verbose,
DefaultRunMode = RunMode.Async,
CaseSensitiveCommands = true
};
services
.AddSingleton(new CommandService(commandsConfig))
.AddSingleton(new DiscordSocketClient(config))
.AddSingleton <InitService>()
.AddSingleton(new BotState())
.AddBotFeatures()
.AddEmoteChain()
.AddStatistics()
.AddPaginationServices()
.AddDuckServices()
.AddHelpServices()
.AddBackgroundTasks()
.AddHostedService <GrillBotService>();
services
.Configure <WebAdminConfiguration>(Configuration.GetSection("WebAdmin"));
}
static async Task Main()
{
var builder = new HostBuilder()
.ConfigureAppConfiguration(x =>
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true)
.Build();
x.AddConfiguration(configuration);
})
.ConfigureLogging(x =>
{
x.AddConsole();
x.SetMinimumLevel(LogLevel.Debug);
})
.ConfigureDiscordHost <DiscordSocketClient>((context, config) =>
{
config.SocketConfig = new DiscordSocketConfig
{
LogLevel = LogSeverity.Debug,
AlwaysDownloadUsers = true,
MessageCacheSize = 200,
GatewayIntents = GatewayIntents.Guilds
| GatewayIntents.GuildMembers
| GatewayIntents.GuildMessageReactions
| GatewayIntents.GuildMessages
| GatewayIntents.GuildWebhooks
};
config.Token = context.Configuration["token"];
})
.UseCommandService((context, config) =>
{
config = new CommandServiceConfig()
{
CaseSensitiveCommands = false,
LogLevel = LogSeverity.Info
};
})
.ConfigureServices((context, services) =>
{
services
.AddHostedService <CommandHandler>()
.AddDbContext <SnakeBotContext>()
.AddSingleton <Servers>()
.AddSingleton <Games>();
})
.UseConsoleLifetime();
var host = builder.Build();
using (host)
{
await host.RunAsync();
}
}
public DiscordCommandConfiguration()
{
var commandServiceConfig = new CommandServiceConfig {
DefaultRunMode = RunMode.Async
};
Client = new DiscordSocketClient();
CommandService = new CommandService(commandServiceConfig);
}
public static async Task Main(string[] args)
{
var builder = new HostBuilder()
.ConfigureAppConfiguration(x => {
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true)
.Build();
x.AddConfiguration(config);
})
.ConfigureLogging(x =>
{
x.AddConsole();
x.SetMinimumLevel(LogLevel.Trace);
})
.ConfigureDiscordHost((context, config) =>
{
config.SocketConfig = new DiscordSocketConfig
{
LogLevel = LogSeverity.Debug,
AlwaysDownloadUsers = true,
MessageCacheSize = 200
};
config.Token = context.Configuration["token"];
})
.UseCommandService((context, config) =>
{
config = new CommandServiceConfig()
{
CaseSensitiveCommands = false,
LogLevel = LogSeverity.Debug
};
})
.ConfigureServices((Context, services) =>
{
services.AddHostedService <CommandHandler>();
services.AddLavaNode(x =>
{
x.SelfDeaf = false;
x.LogSeverity = LogSeverity.Warning;
});
services.AddSingleton <InteractivityService>();
services.AddDbContext <MamaDbContext>();
services.AddScoped <JokeProvider>();
})
.UseConsoleLifetime();
var host = builder.Build();
using (host)
{
await host.RunAsync();
}
}
public CommandHandler(DiscordSocketClient client) : base(client)
{
var config = new CommandServiceConfig
{
DefaultRunMode = RunMode.Async,
LogLevel = LogSeverity.Info
};
Service = new CommandService(config);
}
/// <summary>
/// Runs main thread for the function.
/// Task is blocked until the program is closed.
/// </summary>
/// <returns>No task is returned as function ends on system termination.</returns>
public async Task MainAsync()
{
Global.PROGRAM_PATH = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Global.ENV_FILE = JObject.Parse(File.ReadAllText($"{Global.PROGRAM_PATH}\\env.json"));
string token = Global.ENV_FILE.GetValue("token").ToString();
Global.VERSION = Global.ENV_FILE.GetValue("version").ToString();
Global.HOME_SERVER = Global.ENV_FILE.GetValue("home_server").ToString();
Global.EMOTE_SERVER = Global.ENV_FILE.GetValue("emote_server").ToString();
Global.POGO_DB_CONNECTION_STRING = Global.ENV_FILE.GetValue("pogo_db_sql").ToString();
Global.NONA_DB_CONNECTION_STRING = Global.ENV_FILE.GetValue("nona_db_sql").ToString();
Global.DEFAULT_PREFIX = Global.ENV_FILE.GetValue("default_prefix").ToString();
Global.USE_NONA_TEST = Global.ENV_FILE.GetValue("accept_nona_test").ToString().Equals("TRUE", StringComparison.OrdinalIgnoreCase);
Global.USE_EMPTY_RAID = Global.ENV_FILE.GetValue("use_empty_raid").ToString().Equals("TRUE", StringComparison.OrdinalIgnoreCase);
int logLevel = Convert.ToInt32(Global.ENV_FILE.GetValue("log_level").ToString());
Global.LOG_LEVEL = !Enum.IsDefined(typeof(LogSeverity), logLevel) ? DefaultLogLevel : (LogSeverity)logLevel;
DiscordSocketConfig clientConfig = new DiscordSocketConfig
{
MessageCacheSize = SizeMessageCashe,
LogLevel = Global.LOG_LEVEL,
ExclusiveBulkDelete = true
};
client = new DiscordSocketClient(clientConfig);
CommandServiceConfig commandConfig = new CommandServiceConfig
{
DefaultRunMode = RunMode.Async,
LogLevel = Global.LOG_LEVEL
};
commands = new CommandService(commandConfig);
services = new ServiceCollection()
.AddSingleton(client)
.AddSingleton(commands)
.BuildServiceProvider();
await HookEvents();
await client.LoginAsync(TokenType.Bot, token);
await client.StartAsync();
await client.SetGameAsync($".help | v{Global.VERSION}");
Global.COMMAND_INFO = commands.Commands.ToList().OrderBy(c => c.Name).ToList();
// Block this task until the program is closed.
await Task.Delay(-1);
}
public void ConfigureServices(IServiceCollection serviceCollection)
{
// Create Command Service, inject it into Dependency Map
CommandServiceConfig config = new CommandServiceConfig()
{
DefaultRunMode = RunMode.Async
};
_commands = new CommandService(config);
serviceCollection.AddSingleton(_commands);
}
public CommandService(CommandServiceConfig config, Func<Channel, bool> getNsfwFlag = null, Func<User, bool> getMusicFlag = null, Func<Channel, User, bool> getIgnoredChannelFlag = null)
{
_config = config;
_getNsfwFlag = getNsfwFlag;
_getMusicFlag = getMusicFlag;
_getIgnoredChannelFlag = getIgnoredChannelFlag;
_allCommands = new List<Command>();
_map = new CommandMap(null, "", "");
_categories = new Dictionary<string, CommandMap>();
_root = new CommandGroupBuilder(this, "", null);
}
public CommandHandler(DiscordSocketClient client, IServiceProvider services)
{
_client = client;
_services = services;
CommandServiceConfig config = new CommandServiceConfig()
{
DefaultRunMode = RunMode.Async
};
_commands = new CommandService(config);
}
public static CommandService CommandConfig()
{
var commandServiceConfig = new CommandServiceConfig
{
CaseSensitiveCommands = false,
DefaultRunMode = RunMode.Async,
IgnoreExtraArgs = true,
LogLevel = LogSeverity.Info
};
return(new CommandService(commandServiceConfig));
}
public static CommandService BuildBaseCommandService()
{
var commandServiceConfig = new CommandServiceConfig
{
CaseSensitiveCommands = false,
// Default RunMode to async to prevent commands from blocking the thread
DefaultRunMode = RunMode.Async,
IgnoreExtraArgs = true,
LogLevel = LogSeverity.Info
};
return(new CommandService(commandServiceConfig));
}
public static DiscordClient UsingCommands(this DiscordClient client, CommandServiceConfig config = null, Func<Channel, bool> getNsfwFlag = null, Func<User, bool> getMusicFlag = null, Func<Channel, User, bool> getIgnoredChannelFlag = null)
{
client.AddService(new CommandService(config, getNsfwFlag, getMusicFlag, getIgnoredChannelFlag));
return client;
}
