Beispiel #1
0
        public static Task Main(string[] args)
        {
            if (args.Length == 2 &&
                int.TryParse(args[0], out int shardId) &&
                int.TryParse(args[1], out int parentProcessId))
            {
                return(new NadekoBot(shardId, parentProcessId)
                       .RunAndBlockAsync(args));
            }
            else
            {
#if DEBUG
                var _ = new NadekoBot(0, Process.GetCurrentProcess().Id)
                        .RunAsync(args);
#endif
                return(new ShardsCoordinator()
                       .RunAndBlockAsync());
            }
        }
Beispiel #2
0
        private static void Main()
        {
            Console.OutputEncoding = Encoding.Unicode;

            try
            {
                File.WriteAllText("data/config_example.json", JsonConvert.SerializeObject(new Configuration(), Formatting.Indented));
                if (!File.Exists("data/config.json"))
                {
                    File.Copy("data/config_example.json", "data/config.json");
                }
                File.WriteAllText("credentials_example.json", JsonConvert.SerializeObject(new Credentials(), Formatting.Indented));
            }
            catch
            {
                Console.WriteLine("Failed writing credentials_example.json or data/config_example.json");
            }

            try
            {
                Config              = JsonConvert.DeserializeObject <Configuration>(File.ReadAllText("data/config.json"));
                Config.Quotes       = JsonConvert.DeserializeObject <List <Quote> >(File.ReadAllText("data/quotes.json"));
                Config.PokemonTypes = JsonConvert.DeserializeObject <List <PokemonType> >(File.ReadAllText("data/PokemonTypes.json"));
            }
            catch (Exception ex)
            {
                Console.WriteLine("Failed loading configuration.");
                Console.WriteLine(ex);
                Console.ReadKey();
                return;
            }

            try
            {
                //load credentials from credentials.json
                Creds = JsonConvert.DeserializeObject <Credentials>(File.ReadAllText("credentials.json"));
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Failed to load stuff from credentials.json, RTFM\n{ex.Message}");
                Console.ReadKey();
                return;
            }

            //if password is not entered, prompt for password
            if (string.IsNullOrWhiteSpace(Creds.Token))
            {
                Console.WriteLine("Token blank. Please enter your bot's token:\n");
                Creds.Token = Console.ReadLine();
            }

            Console.WriteLine(string.IsNullOrWhiteSpace(Creds.GoogleAPIKey)
                ? "No google api key found. You will not be able to use music and links won't be shortened."
                : "Google API key provided.");
            Console.WriteLine(string.IsNullOrWhiteSpace(Creds.TrelloAppKey)
                ? "No trello appkey found. You will not be able to use trello commands."
                : "Trello app key provided.");
            Console.WriteLine(Config.ForwardMessages != true
                ? "Not forwarding messages."
                : "Forwarding private messages to owner.");
            Console.WriteLine(string.IsNullOrWhiteSpace(Creds.SoundCloudClientID)
                ? "No soundcloud Client ID found. Soundcloud streaming is disabled."
                : "SoundCloud streaming enabled.");
            Console.WriteLine(string.IsNullOrWhiteSpace(Creds.OsuAPIKey)
                ? "No osu! api key found. Song & top score lookups will not work. User lookups still available."
                : "osu! API key provided.");

            BotMention = $"<@{Creds.BotId}>";

            //create new discord client and log
            Client = new DiscordClient(new DiscordConfigBuilder()
            {
                MessageCacheSize  = 10,
                ConnectionTimeout = int.MaxValue,
                LogLevel          = LogSeverity.Warning,
                LogHandler        = (s, e) =>
                                    Console.WriteLine($"Severity: {e.Severity}" +
                                                      $"ExceptionMessage: {e.Exception?.Message ?? "-"}" +
                                                      $"Message: {e.Message}"),
            });

            //create a command service
            var commandService = new CommandService(new CommandServiceConfigBuilder
            {
                AllowMentionPrefix  = false,
                CustomPrefixHandler = m => 0,
                HelpMode            = HelpMode.Disabled,
                ErrorHandler        = async(s, e) =>
                {
                    if (e.ErrorType != CommandErrorType.BadPermissions)
                    {
                        return;
                    }
                    if (string.IsNullOrWhiteSpace(e.Exception?.Message))
                    {
                        return;
                    }
                    try
                    {
                        await e.Channel.SendMessage(e.Exception.Message).ConfigureAwait(false);
                    }
                    catch { }
                }
            });

            //add command service
            Client.AddService <CommandService>(commandService);

            //create module service
            var modules = Client.AddService <ModuleService>(new ModuleService());

            //add audio service
            Client.AddService <AudioService>(new AudioService(new AudioServiceConfigBuilder()
            {
                Channels         = 2,
                EnableEncryption = false,
                Bitrate          = 128,
            }));

            //install modules
            modules.Add(new HelpModule(), "Help", ModuleFilter.None);
            modules.Add(new AdministrationModule(), "Administration", ModuleFilter.None);
            modules.Add(new UtilityModule(), "Utility", ModuleFilter.None);
            modules.Add(new PermissionModule(), "Permissions", ModuleFilter.None);
            modules.Add(new Conversations(), "Conversations", ModuleFilter.None);
            modules.Add(new GamblingModule(), "Gambling", ModuleFilter.None);
            modules.Add(new GamesModule(), "Games", ModuleFilter.None);
#if !NADEKO_RELEASE
            modules.Add(new MusicModule(), "Music", ModuleFilter.None);
#endif
            modules.Add(new SearchesModule(), "Searches", ModuleFilter.None);
            modules.Add(new NSFWModule(), "NSFW", ModuleFilter.None);
            modules.Add(new ClashOfClansModule(), "ClashOfClans", ModuleFilter.None);
            modules.Add(new PokemonModule(), "Pokegame", ModuleFilter.None);
            modules.Add(new TranslatorModule(), "Translator", ModuleFilter.None);
            modules.Add(new CustomReactionsModule(), "Customreactions", ModuleFilter.None);
            if (!string.IsNullOrWhiteSpace(Creds.TrelloAppKey))
            {
                modules.Add(new TrelloModule(), "Trello", ModuleFilter.None);
            }

            //run the bot
            Client.ExecuteAndWait(async() =>
            {
                await Task.Run(() =>
                {
                    Console.WriteLine("Specific config started initializing.");
                    var x = SpecificConfigurations.Default;
                    Console.WriteLine("Specific config done initializing.");
                });

                PermissionsHandler.Initialize();

                try
                {
                    await Client.Connect(Creds.Token, TokenType.Bot).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"Token is wrong. Don't set a token if you don't have an official BOT account.");
                    Console.WriteLine(ex);
                    Console.ReadKey();
                    return;
                }
#if NADEKO_RELEASE
                await Task.Delay(220000).ConfigureAwait(false);
#else
                await Task.Delay(1000).ConfigureAwait(false);
#endif

                Console.WriteLine("-----------------");
                Console.WriteLine(await NadekoStats.Instance.GetStats().ConfigureAwait(false));
                Console.WriteLine("-----------------");


                OwnerPrivateChannels = new List <Channel>(Creds.OwnerIds.Length);
                foreach (var id in Creds.OwnerIds)
                {
                    try
                    {
                        OwnerPrivateChannels.Add(await Client.CreatePrivateChannel(id).ConfigureAwait(false));
                    }
                    catch
                    {
                        Console.WriteLine($"Failed creating private channel with the owner {id} listed in credentials.json");
                    }
                }
                Client.ClientAPI.SendingRequest += (s, e) =>
                {
                    var request = e.Request as Discord.API.Client.Rest.SendMessageRequest;
                    if (request == null)
                    {
                        return;
                    }
                    // meew0 is magic
                    request.Content = request.Content?.Replace("@everyone", "@everyοne").Replace("@here", "@һere") ?? "_error_";
                    if (string.IsNullOrWhiteSpace(request.Content))
                    {
                        e.Cancel = true;
                    }
                };
#if NADEKO_RELEASE
                Client.ClientAPI.SentRequest += (s, e) =>
                {
                    Console.WriteLine($"[Request of type {e.Request.GetType()} sent in {e.Milliseconds}]");

                    var request = e.Request as Discord.API.Client.Rest.SendMessageRequest;
                    if (request == null)
                    {
                        return;
                    }

                    Console.WriteLine($"[Content: { request.Content }");
                };
#endif
                NadekoBot.Ready = true;
                NadekoBot.OnReady();
                Console.WriteLine("Ready!");
                //reply to personal messages and forward if enabled.
                Client.MessageReceived += Client_MessageReceived;
            });
            Console.WriteLine("Exiting...");
            Console.ReadKey();
        }