private async void Read()
{
try
{
if (Status != null && Status.Length > 0)
{
while (true)
{
foreach (StatusConfig status in Status)
{
DiscordGame game = new DiscordGame
{
Name = status.StatusJogo
};
await Cliente.UpdateStatusAsync(game);
Thread.Sleep(10000);
}
}
}
}
catch (Exception ex)
{
Cliente.DebugLogger.LogMessage(LogLevel.Info, "Kurosawa Dia - Event", ex.Message, DateTime.Now);
}
}
private async Task Set_Status(ReadyEventArgs e)
{
var g = new DiscordGame {
Name = "Online and Ready!"
};
await Client.UpdateStatusAsync(g);
}
private async Task OnClientReady(ReadyEventArgs e)
{
foreach (DiscordClient shardedClient in Client.ShardClients.Values)
{
shardedClient.UseCommandsNext(new CommandsNextConfiguration()
{
CaseSensitive = false,
EnableDefaultHelp = true,
EnableDms = false,
EnableMentionPrefix = false,
StringPrefix = Configuration.prefix,
IgnoreExtraArguments = true,
});
shardedClient.GetCommandsNext().RegisterCommands <CommandSets.Image>();
shardedClient.GetCommandsNext().RegisterCommands <CommandSets.Miscellaneous>();
shardedClient.GetCommandsNext().CommandErrored += OnCommandError;
}
DiscordGame presence = new DiscordGame()
{
Name = $"{Configuration.prefix}wumpus | {Configuration.prefix}getwumpobot | {Configuration.prefix}submit",
};
await Client.UpdateStatusAsync(presence, UserStatus.Online, DateTime.Now);
await Task.Yield();
}
private async Task ChangeStatus()
{
DiscordGame game = _isRandomStatus ? _starWars : _games[_rand.Next(_games.Count)];
_isRandomStatus = !_isRandomStatus;
await _client.UpdateStatusAsync(game);
}
private Task SetStatus(ReadyEventArgs e)
{
DiscordGame discordGame = new DiscordGame("Gatekeeping");
Client.DebugLogger.LogMessage(LogLevel.Info, "Gatekeeper", "Setting user status", DateTime.Now);
Client.UpdateStatusAsync(discordGame, UserStatus.Online, DateTimeOffset.UtcNow);
return(Task.CompletedTask);
}
internal TransportGame(DiscordGame game)
{
if (game == null)
{
return;
}
this.Name = game.Name;
this.StreamType = game.StreamType;
this.Url = game.Url;
//this.Details = game.Details;
//this.State = game.State;
//this.Instance = game.Instance;
//this.ApplicationId = game.Application?.Id;
//
//if (game.PartyId != null || (game.CurrentPartySize != null && game.MaximumPartySize != null))
//{
// this.Party = new GameParty
// {
// Id = game.PartyId?.ToString(CultureInfo.InvariantCulture)
// };
//
// if (game.CurrentPartySize != null && game.MaximumPartySize != null)
// this.Party.Size = new GameParty.GamePartySize
// {
// Current = game.CurrentPartySize.Value,
// Maximum = game.MaximumPartySize.Value
// };
//}
//
//if (game.LargeImage != null && game.SmallImage != null)
// this.Assets = new PresenceAssets
// {
// LargeImage = game.LargeImage.Id,
// SmallImage = game.SmallImage.Id,
// LargeImageText = game.LargeImageText,
// SmallImageText = game.SmallImageText
// };
//
//if (game.StartTimestamp != null || game.EndTimestamp != null)
// this.Timestamps = new GameTimestamps
// {
// _start = game.StartTimestamp != null ? (long?)(Utilities.GetUnixTime(game.StartTimestamp.Value) / 1000) : null,
// _end = game.EndTimestamp != null ? (long?)(Utilities.GetUnixTime(game.EndTimestamp.Value) / 1000) : null
// };
//
//if (game.JoinSecret != null || game.MatchSecret != null || game.SpectateSecret != null)
// this.Secrets = new GameSecrets
// {
// Join = game.JoinSecret,
// Match = game.MatchSecret,
// Spectate = game.SpectateSecret
// };
}
/// <summary>
/// Updates playing statuses on all shards.
/// </summary>
/// <param name="game">Game to set.</param>
/// <param name="user_status">Status of the user.</param>
/// <param name="idle_since">Since when is the client idle.</param>
/// <returns>Asynchronous operation.</returns>
public async Task UpdateStatusAsync(DiscordGame game = null, UserStatus?user_status = null, DateTimeOffset?idle_since = null)
{
var tasks = new List <Task>();
foreach (var client in this.ShardClients.Values)
{
tasks.Add(client.UpdateStatusAsync(game, user_status, idle_since));
}
await Task.WhenAll(tasks).ConfigureAwait(false);
}
static async Task MainAsync(string[] args)
{
var json = "";
using (var fs = File.OpenRead("config.json"))
using (var sr = new StreamReader(fs, new UTF8Encoding(false)))
json = await sr.ReadToEndAsync();
var cfgjson = JsonConvert.DeserializeObject <ConfigJson>(json);
discord = new DiscordClient(new DiscordConfiguration
{
Token = cfgjson.Token,
TokenType = TokenType.Bot,
UseInternalLogHandler = true,
LogLevel = LogLevel.Error
});
discord.SetWebSocketClient <WebSocketSharpClient>();
discord.GuildCreated += async e =>
{
var defaultChannel = e.Guild.GetDefaultChannel();
Console.Write($"Joined: {defaultChannel}");
await discord.SendMessageAsync(defaultChannel, "Bonzi in da HOUSE");
};
discord.Ready += async e =>
{
await Task.Run(() =>
{
Console.WriteLine("Initialized SharpBonzi!");
Console.WriteLine($"Connected to {discord.Guilds.Count} Guilds");
});
//Init Playing
var playingGame = new DiscordGame();
playingGame.Name = "Windows 95";
await discord.UpdateStatusAsync(playingGame);
};
commands = discord.UseCommandsNext(new CommandsNextConfiguration
{
StringPrefix = cfgjson.CommandPrefix,
EnableMentionPrefix = true
});
commands.RegisterCommands <MyCommands>();
commands.SetHelpFormatter <SimpleHelpFormatter>();
await discord.ConnectAsync();
await Task.Delay(-1);
}
private Task Client_Ready(ReadyEventArgs e)
{
// let's log the fact that this event occured
Assembly.GetExecutingAssembly().GetName().Version.ToString();
e.Client.DebugLogger.LogMessage(LogLevel.Info, "SWGOHBot", "Client is ready to process events.", DateTime.Now);
e.Client.DebugLogger.LogMessage(LogLevel.Info, "SWGOHBot", $"Running Client Version: {Assembly.GetExecutingAssembly().GetName().Version.ToString()}", DateTime.Now);
DiscordGame dg = new DiscordGame(cfgjson.CommandPrefix + "help | version:" + Assembly.GetExecutingAssembly().GetName().Version.ToString());
this.Client.UpdateStatusAsync(dg);
// since this method is not async, let's return a completed task, so that no additional work is done
return(Task.CompletedTask);
}
private Task Client_Ready(ReadyEventArgs e)
{
Console.WriteLine("Connected!");
e.Client.DebugLogger.LogMessage(LogLevel.Info, "ExampleBot", "Client is ready to process events.", DateTime.Now);
DiscordGame game = new DiscordGame();
game.Name = botCgf.Read("Status");
game.StartTimestamp = DateTimeOffset.Now;
Client.UpdateStatusAsync(game);
loggingChannel = Client.GetChannelAsync(ulong.Parse(botCgf.Read("Channel"))).Result;
enableLogging = true;
return(Task.CompletedTask);
}
static async Task MainAsyn()
{
string _Token = "";
string url = @"C:\Users\stepa\OneDrive\Рабочий стол\TokenBot.txt";
using (StreamReader sr = new StreamReader(url))
{
_Token = sr.ReadToEnd();
}
discord = new DiscordClient(new DiscordConfiguration
{
Token = _Token,
TokenType = TokenType.Bot,
});
commands = discord.UseCommandsNext(new CommandsNextConfiguration
{
StringPrefix = "!"
});
commands.RegisterCommands <MyCommands>();
discord.MessageCreated += async e =>
{
DiscordGame game = new DiscordGame();
var html = @"https://topcraft.ru/servers/308/servers/";
HtmlWeb web = new HtmlWeb();
var htmlDoc = web.Load(html);
string[] OnlServers = new string[15];
string OnlServersStr = "";
var nodes = htmlDoc.DocumentNode.SelectNodes("//span[@class='online']");
int count = 0;
foreach (var node in nodes)
{
OnlServers[count] = node.InnerText;
OnlServersStr += OnlServers[count] + "\n";
count++;
}
game.Name = "TM (" + OnlServers[3] + ")";
await discord.UpdateStatusAsync(game);
};
await discord.ConnectAsync();
await Task.Delay(-1);
}
private async Task Client_Ready(ReadyEventArgs e)
{
e.Client.DebugLogger.LogMessage(LogLevel.Info, "002", "Client is ready to process events.", DateTime.Now);
await Task.Delay(1000);
var game = new DiscordGame
{
Name = "2B W ダーリン",
Url = "https://www.twitch.tv/devimind",
StreamType = GameStreamType.Twitch
};
await client.UpdateStatusAsync(game : game);
return;
}
public async Task Setplaying(CommandContext ctx, string input)
{
if (Permissions.CheckOwner(ctx.Message.Author))
{
var game = new DiscordGame();
game.Name = input;
await ctx.Client.UpdateStatusAsync(game);
await ctx.RespondAsync($"Set current game to: {input}");
}
else
{
await ctx.RespondAsync("You do not have the required permissions to do this.");
}
}
private Task RegisterDiscord()
{
discord = new DiscordClient(new DiscordConfiguration
{
Token = Plugin.Config.BotToken,
TokenType = TokenType.Bot
});
discord.ConnectAsync();
discord.MessageCreated += Discord_MessageCreated;
game = new DiscordGame();
discord.Ready += async e => Ready = true;
return(Task.CompletedTask);
}
//start bot and stuff
static async Task MainAsync(string[] args)
{
string data = "";
discord = new DiscordClient(new DiscordConfiguration
{
Token = "<Token>",
TokenType = TokenType.Bot
});
//if message created
discord.MessageCreated += async e =>
{
//~~price command
if (e.Message.Content.ToLower().StartsWith("~~price"))
{
if (!e.Message.Author.IsBot)
{
data = FindPrice(e.Message.Content.ToLower().Replace("~~price ", ""), false);
Console.WriteLine("Price: " + e.Message.Content);
await e.Message.RespondAsync(data);
}
}
//~~average command
if (e.Message.Content.ToLower().StartsWith("~~average"))
{
if (!e.Message.Author.IsBot)
{
var averagePrices = FindPrice(e.Message.Content.ToLower().Replace("~~average ", ""), true);
averagePrices.Replace(",", ".");
Console.WriteLine("Average: " + e.Message.Content);
await e.Message.RespondAsync("Average profit if you pull the " + e.Message.Content.Replace("~~average ", "") + ": " + "$" + averagePrices);
}
}
};
//create status
discord.Ready += async x =>
{
DiscordGame game = new DiscordGame("The CS:GO Economy");
await discord.UpdateStatusAsync(game);
};
//start bot
await discord.ConnectAsync();
await Task.Delay(-1);
}
public static async Task LoadEntities()
{
ClientGame = new DiscordGame()
{
Name = GameString
};
Guild = await Program.discord.GetGuildAsync(GuildId);
ChannelMain = Guild.GetChannel(ChannelMainId);
ChannelMainVoice = Guild.GetChannel(ChannelMainVoiceId);
Category = Guild.GetChannel(CategoryId);
ChannelDonor = Guild.GetChannel(ChannelDonorId);
ChannelAFKVoice = Guild.GetChannel(ChannelAFKVoiceId);
RoleEveryone = Guild.GetRole(GuildId);
RoleMain = Guild.GetRole(RoleMainId);
RoleBad = Guild.GetRole(RoleBadId);
}
private async Task OnClientReady(ReadyEventArgs e)
{
// Get DGE´s "testing" channel id
ulong id = 732293267256901705;
// Get DGE´s "general" channel id
ulong generalId = 731998842219659357;
DiscordChannel testchannel = Client.GetChannelAsync(id).Result;
DiscordChannel genChannel = Client.GetChannelAsync(generalId).Result;
// Set bot status info for using bot commands
DiscordGame game = new DiscordGame("?help for botcommands");
await Client.UpdateStatusAsync(game).ConfigureAwait(false);
await testchannel.SendMessageAsync("MiskDisc bot connected. Under progress..").ConfigureAwait(false);
//await genChannel.SendMessageAsync("MiskDisc bot connected. Under progress..").ConfigureAwait(false);
//return Task.CompletedTask;
}
public static void ToggleMaintenance(string notification, bool state)
{
_lastStateMaint = state;
_lastNotifyMaint = notification;
if (state)
{
Client.UpdateStatusAsync(new DiscordGame(string.IsNullOrEmpty(notification) ? "Maintenance" : notification), UserStatus.DoNotDisturb).Wait();
return;
}
DiscordGame game = null;
if (!string.IsNullOrEmpty(notification))
{
game = new DiscordGame(notification);
}
Client.UpdateStatusAsync(game, UserStatus.Online).Wait();
}
public async Task Stream(CommandContext ctx, string streamname)
{
DiscordGame Game = new DiscordGame();
if (streamname == "clear")
{
await Program.discord.UpdateStatusAsync(null);
await ctx.Message.ModifyAsync($"~~{ctx.Message.Content}~~ *Streaming Status cleared!*");
}
else
{
Game.Name = streamname;
Game.StreamType = GameStreamType.Twitch;
Game.Url = "https://www.twitch.tv/!";
await Program.discord.UpdateStatusAsync(Game);
await ctx.Message.ModifyAsync($"~~{ctx.Message.Content}~~ *Streaming {streamname}*");
}
}
public BotStatus(DiscordClient client)
{
_client = client;
_starWars = new DiscordGame("Star Wars: The Old Republic");
_games = new List <DiscordGame>()
{
new DiscordGame("Dejarik"),
new DiscordGame("Letting the wookie win"),
new DiscordGame("Chatta-ragul"),
new DiscordGame("with a Joom-ball"),
new DiscordGame("Theed Quoits"),
new DiscordGame("the growdi harmonique"),
new DiscordGame("the violin"),
new DiscordGame("with Nen's lightsaber"),
new DiscordGame("Star Wars Galaxies"),
new DiscordGame("World of Warcraft"),
new DiscordGame("with HK-51"),
};
_rand = new Random();
_isRandomStatus = true;
}
private void SetNextStatus(DiscordClient discord)
{
DiscordGame game = null;
lock (m_lkStatus)
{
if (m_statusList.Count > 0)
{
int index = m_rand.Next(m_statusList.Count * 2);
if (index < m_statusList.Count)
{
string status = m_statusList[index];
game = new DiscordGame(status);
}
}
}
discord.UpdateStatusAsync(game).Wait();
}
internal DiscordUserPresence(Snowflake userId, DiscordApiData data)
{
UserId = userId;
DiscordApiData gameData = data.Get("game");
if (gameData != null)
{
if (gameData.IsNull)
{
Game = null;
}
else
{
Game = new DiscordGame(gameData);
}
}
string statusStr = data.GetString("status");
if (statusStr != null)
{
DiscordUserStatus?status = Utils.ParseUserStatus(statusStr);
if (!status.HasValue)
{
// If we don't have a value for the status yet,
// we at least know that they aren't offline.
Status = DiscordUserStatus.Online;
// However, this should issue a warning.
DiscoreLogger.Global.LogWarning($"[DiscordUserPresence] Failed to deserialize status for user {UserId}. " +
$"status = {statusStr}");
}
else
{
Status = status.Value;
}
}
}
static async Task MainAsync(string[] args)
{
string location = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
string[] array = File.ReadAllLines(location + @"\config.txt", Encoding.UTF8);
string token = array[0].Split('=')[1].Replace(" ", "");
string StreamName = array[1].Split('=')[1];
string URL = array[2].Split('=')[1].Replace(" ", "");
discord = new DiscordClient(new DiscordConfiguration
{
Token = $"{token}",
TokenType = TokenType.User
});
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().StartsWith("c!start"))
{
if (e.Message.Author.Id == discord.CurrentUser.Id)
{
await e.Message.RespondAsync("started!");
DiscordGame game = new DiscordGame()
{
Name = $"{StreamName}", StreamType = GameStreamType.Twitch, Url = $"{URL}"
};
await discord.UpdateStatusAsync(game, UserStatus.Online);
Console.WriteLine("Token: " + token + "\nStreamName: " + StreamName + "\nURL: " + URL);
}
}
};
Console.WriteLine("Ready for fire");
Console.WriteLine("Token: " + token + "\nStreamName: " + StreamName + "\nURL: " + URL);
await discord.ConnectAsync();
await Task.Delay(-1);
}
static async Task MainAsync(string[] args)
{
try
{
loadConfigs("configs.dat");
loadWhitelist("whitelist.txt");
discord = new DiscordClient(new DiscordConfiguration
{
Token = configs["Bot-Token"],
TokenType = TokenType.Bot
});
commands = new Dictionary <string, ComObj>();
commands.Add("talkrate", new ComObj("talkrate", "Set the Talkback Rate",
"Sets the rate (at 1/r) at which this bot responds to messages. Usage: !talkrate <number>", doTalkRate));
commands.Add("help", new ComObj("help", "You are here.",
"I don't know what else to tell you.", getHelp));
SBorgPort.statLoadMem("lines.txt");
Console.Out.WriteLine("Bot Memory Loaded");
loadChannels("ChannelInfo.tdf");
Console.Out.WriteLine("Channel Info Loaded");
//loadCensors("censors.dat");
discord.SetWebSocketClient <WebSocket4NetClient>();
discord.MessageCreated += async e =>
{
try
{
if (e.Author == discord.CurrentUser)
{
return;
}
string ret = "";
string chanID = e.Message.ChannelId.ToString();
if (channels.ContainsKey(chanID)) // This should now always be true
{
channels[chanID].lastMessage = e.Message.Id.ToString();
}
SBorgPort borg = (SBorgPort)channels[chanID].modules["borg"];
string chanRec = "";
if (e.Channel.IsPrivate)
{
foreach (DiscordUser user in ((DiscordDmChannel)e.Channel).Recipients)
{
chanRec += user.Username + ", ";
}
Console.Out.WriteLine("Message recieved from " + chanRec.Substring(0, chanRec.Length - 2) + ": " + e.Message.Content);
}
else
{
Console.Out.WriteLine("Message recieved from channel (" + e.Guild.Name + ")" + e.Channel.Name + ": " + e.Message.Content);
}
bool isAdmin = whitelist.Contains(e.Author.Id.ToString());
if (e.Message.Content[0] == DSPModuleMap.MOD_ID)
{
ret = channels[chanID].modules.command(e.Message.Content.ToLower(), isAdmin);
}
else if (e.Message.Content[0] == '!')
{
string[] com = e.Message.Content.Split(new char[] { ' ' }, 2, StringSplitOptions.RemoveEmptyEntries);
if (commands.ContainsKey(com[0].Substring(1).ToLower()))
{
string cargs = chanID;
if (com.Length > 1)
{
cargs += ' ' + com[1];
}
ret = commands[com[0].Substring(1).ToLower()].doAction(cargs, isAdmin);
}
//else ret = borg.command(e.Message.Content, isAdmin);
else
{
ret = channels[chanID].modules.command(e.Message.Content.ToLower(), isAdmin);
}
}
else if (e.MentionedUsers.Contains(discord.CurrentUser))
{
string tr = "";
string[] tex = e.Message.Content.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string s in tex)
{
if (!Regex.IsMatch(s, "^<@\\d>$") && s[0] != '@')
{
tr += s + ' ';
}
}
ret = borg.reply(tr);
}
else
{
if (channels.ContainsKey(chanID) && channels[chanID].talkRate > 0 && rand.Next(channels[chanID].talkRate) == 0)
{
ret = borg.reply(e.Message.Content);
}
SBorgPort.learn(e.Message.Content);
}
if (ret.Trim().Length > 0)
{
if (e.Channel.IsPrivate)
{
Console.Out.WriteLine("Message sent to " + chanRec.Substring(0, chanRec.Length - 2) + ": " + ret);
}
else
{
Console.Out.WriteLine("Message sent to channel (" + e.Guild.Name + ")" + e.Channel.Name + ": " + ret);
}
await e.Message.RespondAsync(ret);
}
}
catch (Exception ex)
{
Console.Out.WriteLine(ex.GetType().ToString() + ": " + ex.Message);
}
};
int numGuilds = 999999;
discord.Ready += async e =>
{
await Task.Yield();
numGuilds = discord.Guilds.Count;
};
discord.GuildAvailable += async e =>
{
IReadOnlyList <DiscordChannel> dChannels = await e.Guild.GetChannelsAsync();
foreach (DiscordChannel chan in dChannels)
{
await loadLastMessages(chan);
}
numGuilds--;
if (numGuilds == 0)
{
SBorgPort.statSaveMem("lines.txt");
saveChannels("ChannelInfo.tdf");
DiscordGame game = new DiscordGame();
game.Name = RandomGameName.getGameName();
game.StreamType = GameStreamType.NoStream;
await discord.UpdateStatusAsync(game);
}
};
discord.DmChannelCreated += async e =>
{
if (loadedDMs.Contains(e.Channel.Id.ToString()))
{
return;
}
await loadLastMessages(e.Channel);
loadedDMs.Add(e.Channel.Id.ToString());
};
await discord.ConnectAsync();
CancellationTokenSource exitSource = new CancellationTokenSource();
CancellationToken exitToken = exitSource.Token;
try
{
while (!exitSource.IsCancellationRequested)
{
await Task.Delay(1800000, exitSource.Token);
Console.Out.WriteLine("Backing up...");
SBorgPort.statSaveMem("lines.txt");
saveChannels("ChannelInfo.tdf");
//saveCensors("censors.dat");
DiscordGame game = new DiscordGame();
game.StreamType = GameStreamType.NoStream;
game.Name = RandomGameName.getGameName();
await discord.UpdateStatusAsync(game);
await Task.Delay(1800000, exitSource.Token);
game.Name = RandomGameName.getGameName();
await discord.UpdateStatusAsync(game);
}
}
catch (TaskCanceledException) { }
} catch (Exception e) // why would this ever happen
{
Console.Out.WriteLine(e.GetType() + ": " + e.Message);
Console.Out.WriteLine(e.StackTrace);
}
}
public async Task MainTask(string[] args)
{
var config = new DiscordConfiguration()
{
Token = token,
TokenType = TokenType.Bot,
UseInternalLogHandler = true,
LogLevel = LogLevel.Debug
};
client = new DiscordClient(config);
client.Ready += async e =>
{
var game = new DiscordGame("твоем очке");
game.Application = client.CurrentApplication;
await client.UpdateStatusAsync(game);
};
client.MessageCreated += async e =>
{
if (e.Channel.Name.ToLower() == "анти-бот")
{
string message = e.Message.Content;
if (message.ToLower().StartsWith("инфобот"))
{
var messageToSend =
$"Приветствую тебя, участник наипиздатейшей гильдии АнтиМетод (если ты не участник, то ливай и заодно обоссы себе ебальник, чорт, хули ты тут забыл).{Environment.NewLine}" +
$"Вот комманды, по которым я могу выдать тебе полезную информацию (или послать нахуй, тут по настроению):{Environment.NewLine}" +
$"Персонаж: *Сервер*, *Ник персонажа* - Выдам инфу по любому существующему персонажу.{Environment.NewLine}" +
$"Гильдия: *Сервер*, *Название гильдии* - Аналогично персонажу выдам полезную информацию по запрашиваемой гильдии.{Environment.NewLine}" +
$"Аффиксы - Аффиксы текущей недели и их подробное описание на EU регионе.{Environment.NewLine}" +
$"Гайд: *Сложность одной буквой (N - нормал, H - героик, M - мифик)* - Постараюсь найти для тебя видеогайд по прохождению интересующего тебя рейдового босса.";
await e.Message.RespondAsync(messageToSend);
}
else if (message.ToLower().StartsWith("персонаж:"))
{
try
{
await e.Message.RespondAsync(MessageBuilder.CharacterAnswer(message));
}
catch (WebException ex)
{
await e.Message.RespondAsync($"Произошла ошибка - (если тебе это что то даст, то {ex.Message}). {Environment.NewLine}Тут то ли ты вместо имени персонажа или сервера хуйню написал, то ли я дурак. {Environment.NewLine}Зовите Макса, пусть разбирается, хули.");
}
}
else if (message.ToLower().StartsWith("гильдия:"))
{
try
{
await e.Message.RespondAsync(MessageBuilder.GuildAnswer(message));
}
catch (WebException ex)
{
await e.Message.RespondAsync($"Произошла ошибка - (если тебе это что то даст, то {ex.Message}). {Environment.NewLine}Тут то ли ты вместо названия гильдии или сервера хуйню написал, то ли я дурак. {Environment.NewLine}Зовите Макса, пусть разбирается, хули.");
}
}
else if (message.ToLower() == "аффиксы")
{
try
{
await e.Message.RespondAsync(MessageBuilder.AffixAnswer());
}
catch (WebException ex)
{
await e.Message.RespondAsync($"Произошла ошибка - (если тебе это что то даст, то {ex.Message}). {Environment.NewLine}Зовите Макса, пусть разбирается, хули.");
}
}
else if (message.ToLower().StartsWith("гайд:"))
{
var parsedMessage = message.Replace("гайд:", "").Replace("Гайд:", "").Split(',');
if (parsedMessage.Length != 2)
{
await e.Message.RespondAsync("Нормально напиши, блять, сложность и имя босса через запятую, полудурок");
}
var dif = parsedMessage[0].ToLower().Trim();
var bossName = parsedMessage[1].ToLower().Trim();
switch (dif)
{
case "n":
await e.Message.RespondAsync(RaidGuides.GetBossGuide(RaidDifficult.Normal, bossName));
break;
case "h":
await e.Message.RespondAsync(RaidGuides.GetBossGuide(RaidDifficult.Heroic, bossName));
break;
case "m":
await e.Message.RespondAsync(RaidGuides.GetBossGuide(RaidDifficult.Mythical, bossName));
break;
default:
await e.Message.RespondAsync("Ты че, блять, сложность указать не можешь, дефеченто? Если не знаешь, как писать запросы, напиши \"Инфобот\", уебан, и узнай, как сука сложность указывать.");
break;
}
}
else if (message.ToLower() == "рандомная тян")
{
string[] tyans =
{
"http://img1.joyreactor.cc/pics/post/full/Anime-Nora-cat-nora-cat-channel-sunsuke-4291251.png",
"https://i.pinimg.com/736x/1b/33/07/1b330700beab0801c6aa8a4392fd9461.jpg",
"https://trikky.ru/wp-content/blogs.dir/1/files/2019/11/15/0674654f7d9b9ed91a3a6f92e08823bf.jpg"
};
var tyan = tyans[_rnd.Next(3)];
var builder = new DiscordEmbedBuilder();
builder.ImageUrl = tyan;
await e.Message.RespondAsync(null, false, builder.Build());
}
else if (message.ToLower() == "вилкой чисти")
{
var last = e.Channel.LastMessageId;
var messages = e.Channel.GetMessagesAsync(100, last).Result;
while (messages.Any())
{
e.Channel.DeleteMessagesAsync(messages).Wait();
last = e.Channel.LastMessageId;
messages = e.Channel.GetMessagesAsync(100, last).Result;
}
}
}
};
await client.ConnectAsync();
await Task.Delay(-1);
}
public async Task Play(string gameName = "Quiplash")
{
try
{
GameLobby lobby = null;
//check to see if lobby exists
foreach (GameLobby checkLobby in lobbies)
{
if (checkLobby.Channel.Id == Context.Channel.Id)
{
lobby = checkLobby;
}
}
//lobby doesn't exist
if (lobby == null)
{
//create lobby and game
lobby = new GameLobby(Context.Client, Context.Channel, null);
lobby.LobbyGame = DiscordGame.ConstructGame(gameName, lobby);
if (lobby.LobbyGame == null)
{
await ReplyAsync("That game doesn't exist.");
await Task.CompletedTask;
}
lobbies.Add(lobby);
lobby.Players.Add(Context.User);
//notify the channel
await ReplyAsync($"A lobby has been started! The game of {lobby.LobbyGame.Name} will start in one minute. Type \".play\" if you'd like to join!");
await Task.Delay(30000);
await ReplyAsync("The game will start in 30 seconds! Be sure you've joined the game using \".play\"!");
await Task.Delay(30000);
lobby.Joinable = false;
//not enough players
if (lobby.Players.Count < lobby.LobbyGame.MinimumPlayers)
{
await ReplyAsync($"Sorry, you need at least {lobby.LobbyGame.MinimumPlayers} people to play {lobby.LobbyGame.Name}.");
lobbies.Remove(lobby);
}
//get the game started
else
{
await lobby.StartGame();
lobbies.Remove(lobby);
}
}
//lobby exists
else
{
if (lobby.Joinable && !lobby.Players.Contains(Context.User))
{
lobby.Players.Add(Context.User);
await ReplyAsync($"{Context.User.Mention} has joined the game!");
}
else if (lobby.Players.Contains(Context.User))
{
await ReplyAsync("You already joined this game!");
}
else
{
await ReplyAsync("Sorry, you can't join this game.");
}
}
//just to give it something
await Task.CompletedTask;
}
catch (Exception err)
{
await ReplyAsync(err.ToString());
}
}
private static async Task MainAsync(string[] args)
{
discord = new DiscordClient(new DiscordConfiguration
{
Token = File.ReadAllText(AppDomain.CurrentDomain.BaseDirectory + "token.txt"),
TokenType = TokenType.Bot,
UseInternalLogHandler = true,
LogLevel = LogLevel.Debug,
});
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().Contains("n***a"))
{
member = (DiscordMember)e.Author;
}
await member.BanAsync();
};
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().Contains("tranny"))
{
member = (DiscordMember)e.Author;
}
await member.BanAsync();
};
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().Contains("retarded"))
{
member = (DiscordMember)e.Author;
}
await member.BanAsync();
};
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().Contains("f****t"))
{
member = (DiscordMember)e.Author;
}
await member.BanAsync();
};
discord.MessageCreated += async e =>
{
if (e.Message.Content.ToLower().Contains(";;bitch"))
{
await message.DeleteAsync();
}
};
discord.GuildMemberAdded += async e =>
{
guest = e.Guild.GetRole(609506619532771329);
await e.Member.GrantRoleAsync(guest);
};
discord.Ready += async e =>
{
var game = new DiscordGame();
game.Name = "Killing Sooper";
await discord.UpdateStatusAsync(game : game);
};
commands = discord.UseCommandsNext(new CommandsNextConfiguration
{
StringPrefix = ";;"
});
var builder = new DiscordEmbedBuilder();
builder.WithImageUrl("https://titles.trackercdn.com/destiny/common/destiny2_content/screenshots/3588934839.jpg");
commands.RegisterCommands <Commands>();
await discord.ConnectAsync();
await Task.Delay(-1);
}
