You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
791 lines
32 KiB
791 lines
32 KiB
using System;
|
|
using System.Threading.Tasks;
|
|
using Discord.Commands;
|
|
using Discord;
|
|
using System.IO;
|
|
using Kehyeedra3.Preconditions;
|
|
using System.Net;
|
|
using System.Linq;
|
|
using System.Data;
|
|
using Kehyeedra3.Services;
|
|
using MySql.Data;
|
|
using MySql.Data.MySqlClient;
|
|
using Kehyeedra3.Services.Models;
|
|
|
|
namespace Kehyeedra3
|
|
{
|
|
//..[prefix]stats[group] ping[command]
|
|
//..stats ping
|
|
[Group]
|
|
public class Stats : ModuleBase ///////////////////////////////////////////////
|
|
{
|
|
[Command("ping")]
|
|
public async Task Pong()
|
|
{
|
|
await Context.Channel.TriggerTypingAsync();
|
|
await ReplyAsync($"My current ping is {Bot._bot.GetShardFor(Context.Guild).Latency}ms");
|
|
}
|
|
}
|
|
[Group]
|
|
public class HelpModule : ModuleBase ///////////////////////////////////////////////
|
|
{
|
|
private CommandService _service;
|
|
|
|
public HelpModule(CommandService service) //Create a constructor for the commandservice dependency
|
|
{
|
|
_service = service;
|
|
}
|
|
[Command("commands")]
|
|
public async Task HelpAsync()
|
|
{
|
|
string debug = null;
|
|
string prefix = Configuration.Load().Prefix;
|
|
var builder = new EmbedBuilder()
|
|
{
|
|
Color = new Color(114, 137, 218),
|
|
Description = "These are the commands you can use"
|
|
};
|
|
|
|
foreach (var module in _service.Modules)
|
|
{
|
|
string description = null;
|
|
debug += $"{module.Name}\n";
|
|
foreach (var cmd in module.Commands)
|
|
{
|
|
var result = await cmd.CheckPreconditionsAsync(Context);
|
|
if (result.IsSuccess)
|
|
description += $"{prefix}{cmd.Aliases.First()}\n";
|
|
debug += $"{prefix}{cmd.Aliases.First()}\n";
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(description))
|
|
{
|
|
builder.AddField(x =>
|
|
{
|
|
x.Name = module.Name;
|
|
x.Value = description;
|
|
x.IsInline = false;
|
|
});
|
|
}
|
|
}
|
|
|
|
await ReplyAsync(debug);
|
|
}
|
|
|
|
[Command("command")]
|
|
public async Task HelpAsync(string command)
|
|
{
|
|
var result = _service.Search(Context, command);
|
|
|
|
if (!result.IsSuccess)
|
|
{
|
|
await ReplyAsync($"Sorry, I couldn't find a command with the name **{command}**.");
|
|
return;
|
|
}
|
|
|
|
string prefix = Configuration.Load().Prefix;
|
|
var builder = new EmbedBuilder()
|
|
{
|
|
Color = new Color(0, 255, 0),
|
|
Description = $"Here are some commands like **{command}**"
|
|
};
|
|
|
|
foreach (var match in result.Commands)
|
|
{
|
|
var cmd = match.Command;
|
|
|
|
builder.AddField(x =>
|
|
{
|
|
x.Name = string.Join(", ", cmd.Aliases);
|
|
x.Value = $"Parameters: {string.Join(", ", cmd.Parameters.Select(p => p.Name))}\n" +
|
|
$"Remarks: {cmd.Remarks}";
|
|
x.IsInline = false;
|
|
});
|
|
}
|
|
|
|
await ReplyAsync("", false, builder.Build());
|
|
}
|
|
|
|
[Command("help")]
|
|
public async Task HelpCommand()
|
|
{
|
|
EmbedBuilder embed = new EmbedBuilder();
|
|
embed.AddField("help", "Shows this thing");
|
|
embed.AddField("ping", "Shows ping to server");
|
|
embed.AddField("commands", "Lists commands");
|
|
embed.AddField("command", "Tells what parameters a command uses");
|
|
embed.AddField("delet", "Posts a delet this image. Can be used on other channels.");
|
|
embed.AddField("ratetrap", "Rates your or another person's trap potential as a percentage");
|
|
embed.AddField("8b", "Gives a prediction like a generic 8ball command that every self respecting discord bot must have");
|
|
embed.AddField("AIMLbot", "Mention me to talk with me (don't expect intelligence)");
|
|
embed.AddField("math", "It's a calculator, that's what compooter do");
|
|
embed.AddField("roll", "Rolls dice. Eg. 'roll d20'");
|
|
embed.AddField("mine", "Mines %coins");
|
|
embed.AddField("bet", "Gamble %coins in units of 0.0001%");
|
|
embed.AddField("balance", "Displays the percentage of the total currency you own");
|
|
embed.AddField("bank", "Displays the percentage of total currency the bank owns");
|
|
embed.AddField("give", "Give a user money. Eg. 'give @user [amount]'");
|
|
embed.AddField("say", "Sends given message to given channel (admin only)");
|
|
embed.AddField("adddelet", "Adds a delet this image to the bot from link or image (admin only)");
|
|
await ReplyAsync("Here's a list of commands and what they do", false, embed.Build());
|
|
}
|
|
}
|
|
//public class Audio_module : ModuleBase<ICommandContext> ////////////////////////
|
|
//{
|
|
// [Command("join", RunMode = RunMode.Async)]
|
|
// public async Task JoinCmd()
|
|
// {
|
|
// await Bot.AudioService.JoinAudio(Context.Guild, (Context.User as IVoiceState).VoiceChannel);
|
|
// }
|
|
// [Command("leave", RunMode = RunMode.Async)]
|
|
// public async Task LeaveCmd()
|
|
// {
|
|
// await Bot.AudioService.LeaveAudio(Context.Guild);
|
|
// }
|
|
// [Command("play", RunMode = RunMode.Async)]
|
|
// public async Task PlayCmd([Remainder] string song)
|
|
// {
|
|
// await Bot.AudioService.SendAudioAsync(Context.Guild, Context.Channel, song);
|
|
// }
|
|
//}
|
|
public class Stuff : ModuleBase ///////////////////////////////////////////////
|
|
{
|
|
//public DatabaseService dbService { get; set; }
|
|
|
|
[Command("delet")]
|
|
public async Task DeletThis()
|
|
{
|
|
string imgdirpath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Delet");
|
|
DirectoryInfo imgdir = new DirectoryInfo(imgdirpath);
|
|
var files = imgdir.GetFiles();
|
|
var item = files[Bot._rnd.Next(0, files.Length)];
|
|
await Context.Channel.SendFileAsync(item.FullName);
|
|
|
|
}
|
|
[Command("delet")]
|
|
public async Task DeletThis(ITextChannel channel)
|
|
{
|
|
string imgdirpath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Delet");
|
|
DirectoryInfo imgdir = new DirectoryInfo(imgdirpath);
|
|
var files = imgdir.GetFiles();
|
|
var item = files[Bot._rnd.Next(0, files.Length)];
|
|
await channel.SendFileAsync(item.FullName);
|
|
|
|
}
|
|
|
|
[Command("ratetrap")]
|
|
public async Task RateTrap()
|
|
{
|
|
Random rando = new Random();
|
|
Random rando1 = new Random();
|
|
int trapRating0 = rando.Next(0, 101);
|
|
if (trapRating0 == 100)
|
|
{
|
|
int trapRating1 = rando1.Next(0, 1001);
|
|
await Context.Channel.SendMessageAsync($"I'd say right now you're {trapRating1}% passable");
|
|
}
|
|
else
|
|
{
|
|
await Context.Channel.SendMessageAsync($"I'd say right now you're {trapRating0}% passable");
|
|
}
|
|
}
|
|
[Command("ratetrap")]
|
|
public async Task RateOtherTrap([Remainder] string name)
|
|
{
|
|
Random rando = new Random();
|
|
Random rando1 = new Random();
|
|
int trapRating0 = rando.Next(0, 101);
|
|
if (trapRating0 == 100)
|
|
{
|
|
int trapRating1 = rando1.Next(0, 1001);
|
|
await Context.Channel.SendMessageAsync($"I'd say right now {name} is {trapRating1}% passable");
|
|
}
|
|
else
|
|
{
|
|
await Context.Channel.SendMessageAsync($"I'd say right now {name} is {trapRating0}% passable");
|
|
}
|
|
}
|
|
[Command("ratertrap")]
|
|
public async Task RaterTrap()
|
|
{
|
|
await Context.Channel.SendMessageAsync("Please do not be like this man http://tinyurl.com/y7lj6nob");
|
|
}
|
|
[Command("8b")]
|
|
public async Task VapeBall([Remainder] string input)
|
|
{
|
|
Random rando = new Random();
|
|
string[] predictions = new string[]
|
|
{
|
|
"No but you're still gay",
|
|
"I think so",
|
|
"Mayhaps",
|
|
"Yeah but you're still gay",
|
|
"No kys"
|
|
};
|
|
int randomIndex = rando.Next(predictions.Length);
|
|
string text = predictions[randomIndex];
|
|
await ReplyAsync(text + " " + Context.User.Mention);
|
|
}
|
|
[Command("math")]
|
|
public async Task Mathboi([Remainder] string input)
|
|
{
|
|
string result = new DataTable().Compute(input, null).ToString();
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} {input} = {result}");
|
|
}
|
|
[Command("roll")]
|
|
public async Task RollDice([Remainder] string input)
|
|
{
|
|
int dinput = int.Parse(input.Substring(input.IndexOf("d")).Replace("d", ""));
|
|
Random rando = new Random();
|
|
int output = rando.Next(dinput+1);
|
|
await Context.Channel.SendMessageAsync("" + output);
|
|
}
|
|
[Command("remind")]
|
|
public async Task Reminder(ulong d, ulong h, ulong m, [Remainder] string r)
|
|
{
|
|
DateTime dt = DateTime.UtcNow;
|
|
|
|
ulong yeedraStamp = DateTime.UtcNow.ToYeedraStamp();
|
|
|
|
var reminder = new Reminder
|
|
{
|
|
UserId = Context.User.Id,
|
|
Message = ($"Ok dude so at about UTC{dt} you wanted me to remind you and I quote '{r}'"),
|
|
Created = yeedraStamp,
|
|
Send = ((d * 86400) + (h * 3600) + (m * 60)) + yeedraStamp
|
|
};
|
|
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
Database.Reminders.Add(reminder);
|
|
|
|
await Database.SaveChangesAsync().ConfigureAwait(false);
|
|
}
|
|
await Context.Channel.SendMessageAsync($"Ok dude I'll remind you in {d}d {h}h {m}m");
|
|
}
|
|
}
|
|
|
|
public class Money : ModuleBase<ICommandContext>
|
|
{
|
|
readonly string[] ores = new string[]
|
|
{
|
|
"**Gold**,",
|
|
"**Platinum**,",
|
|
"**Plastids**,",
|
|
"a ticking **Time Bomb**,",
|
|
"**Neural Sensors**,",
|
|
"an **Amethyst**,",
|
|
"**Germanium**,",
|
|
"a **Hotdog**,",
|
|
"**Corundum**,",
|
|
"**Quartz**,",
|
|
"**Lithium**,",
|
|
"**Stone**,",
|
|
"a lost **Tribe of Ethiopians**,",
|
|
"**Beryllium**,",
|
|
"**Gallium**,",
|
|
"an **Amber**,",
|
|
"**Bismuth**",
|
|
"an **Emerald**,",
|
|
"a lost **Sock**,",
|
|
"**Tellurium**,",
|
|
"**Ferrite**,",
|
|
"a **Glass of Water**,",
|
|
"**Redstone**,",
|
|
"**Racism**,",
|
|
"**Bronze Ore**,",
|
|
"**Chlorophyte**,",
|
|
"a **Mysterious Artifact of Great Power**,",
|
|
"**Goblite**,",
|
|
"**Ligmanite**,",
|
|
"**Ramen's Friendship**,",
|
|
"an unidentified **Skeleton**,",
|
|
"a piece of **Gravel**,",
|
|
"**Copper**,",
|
|
"**Volatile Motes**,",
|
|
"a **Diamond**,",
|
|
"**Thorium**,",
|
|
"a **Fresh Apple**,",
|
|
"**Raid Shadow Legends** sponsorship money,",
|
|
"a **Boot**,",
|
|
"**Runite**,",
|
|
"a **WinRAR license key**,",
|
|
"a **Viet Cong Tunnel**,",
|
|
"a single unit of several **Trees**,",
|
|
"**1,000,000₩**,",
|
|
"a **Rock Golem**,",
|
|
"a piece of **Toast**,",
|
|
"**Luminite**,",
|
|
"a **Funky Lava Lamp**,",
|
|
"the **Cum Chalice**, you raise a toast to Nick.",
|
|
"a **#%**,",
|
|
"the **Master Sword**,",
|
|
"your **True Calling in Life**,",
|
|
"the **Ocarina of Time**,",
|
|
"**Phosphophyllite**,",
|
|
"a **Brain**,",
|
|
"**Tom's Penis**,",
|
|
"**Oil**,",
|
|
"a **Can of Peaches**,",
|
|
"a **Used Deodorant Stick**,"
|
|
};
|
|
readonly string o = "<:ye:677089325208305665>";
|
|
readonly string n = "<:no:677091514249248778>";
|
|
readonly string ye = "<:ya:677179974154715146>";
|
|
|
|
[Command("mine"), Ratelimit(6, 2, Measure.Minutes)]
|
|
public async Task Mine()
|
|
{
|
|
ulong time = ulong.Parse(DateTime.Now.ToString("yyyyMMddHHmm"));
|
|
ulong lastmine;
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
var user = Database.Users.FirstOrDefault(x => x.Id == Context.User.Id);
|
|
lastmine = user.LastMine;
|
|
user.LastMine = time;
|
|
await Database.SaveChangesAsync();
|
|
}
|
|
if (lastmine < time)
|
|
{
|
|
int res1 = SRandom.Next(0, 101);
|
|
int res2 = SRandom.Next(0, 101);
|
|
int res3 = SRandom.Next(0, 101);
|
|
int end = 0;
|
|
string marks = $"{n}{n}{n}";
|
|
int num = SRandom.Next(ores.Length);
|
|
string ore = ores[num];
|
|
if (res1 > 20)
|
|
{
|
|
end = 1;
|
|
marks = $"{o}{n}{n}";
|
|
if (res2 > 50)
|
|
{
|
|
end = 2;
|
|
marks = $"{o}{o}{n}";
|
|
if (res3 > 80)
|
|
{
|
|
marks = $"{o}{o}{o}";
|
|
string bonus = "";
|
|
int res4 = SRandom.Next(0, 6) * 2;
|
|
int res5 = res4 / 2;
|
|
end = res4 + 3;
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
if (i < res5)
|
|
{
|
|
bonus += $"{ye}";
|
|
}
|
|
else
|
|
{
|
|
bonus += $"{n}";
|
|
}
|
|
}
|
|
if (res4 == 0)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{marks} **+** {bonus}\n{Context.User.Mention} **Lucky strike!** Bonus: {ore} You earned {end / 10000d}%");
|
|
}
|
|
else
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{marks} **+** {bonus}\n{Context.User.Mention} **Lucky strike!** Bonus: {res4}, You earned {end / 10000d}%");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (end == 0)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{marks}\n{Context.User.Mention} You have found {ore} you presume it is worthless and toss it away.");
|
|
}
|
|
else
|
|
{
|
|
if (end < 3)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{marks}\n{Context.User.Mention} You found {end / 10000d}% while mining");
|
|
}
|
|
}
|
|
|
|
|
|
if (end != 0)
|
|
{
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
var user = Database.Users.FirstOrDefault(x => x.Id == Context.User.Id);
|
|
|
|
if (!user.GrantMoney(Database.Users.FirstOrDefault(x => x.Id == 0), end))
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} Bank has no money, convince someone to gamble");
|
|
}
|
|
|
|
await Database.SaveChangesAsync();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} wait 1 minute ok next minute yeah? yeah buddy?");
|
|
}
|
|
}
|
|
[Command("balance")]
|
|
public async Task Shekels([Remainder] IUser otherUser = null)
|
|
{
|
|
User user;
|
|
User buser;
|
|
User suser;
|
|
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
user = Database.Users.FirstOrDefault(x => x.Id == otherUser.Id);
|
|
buser = Database.Users.FirstOrDefault(x => x.Id == 0);
|
|
suser = Database.Users.FirstOrDefault(x => x.Id == 1);
|
|
}
|
|
|
|
if (otherUser == null)
|
|
{
|
|
if (user == null)
|
|
{
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
user = new User
|
|
{
|
|
Id = Context.User.Id,
|
|
Avatar = Context.User.GetAvatarUrl() ?? Context.User.GetDefaultAvatarUrl(),
|
|
Username = Context.User.Username
|
|
};
|
|
Database.Users.Add(user);
|
|
await Database.SaveChangesAsync();
|
|
}
|
|
}
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} You own {user.Money / 10000d}%\nWhich is {(user.Money * 100) / (1000000 - buser.Money - suser.Money)}% of the money in circulation");
|
|
}
|
|
else
|
|
{
|
|
if (user == null)
|
|
{
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
user = new User
|
|
{
|
|
Id = Context.User.Id,
|
|
Avatar = Context.User.GetAvatarUrl() ?? Context.User.GetDefaultAvatarUrl(),
|
|
Username = Context.User.Username
|
|
};
|
|
Database.Users.Add(user);
|
|
await Database.SaveChangesAsync();
|
|
}
|
|
}
|
|
await Context.Channel.SendMessageAsync($"{otherUser.Mention} owns {user.Money / 10000d}%\nWhich is {(user.Money * 100) / (1000000 - buser.Money - suser.Money)}% of the money in circulation");
|
|
}
|
|
}
|
|
|
|
[Command("bank")]
|
|
public async Task BankBalance()
|
|
{
|
|
User user;
|
|
User suser;
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
user = Database.Users.FirstOrDefault(x => x.Id == 0);
|
|
suser = Database.Users.FirstOrDefault(x => x.Id == 1);
|
|
}
|
|
await Context.Channel.SendMessageAsync($"Bank has {user.Money/10000d}% left\nSkuld can currently sell a maximum of {suser.Money*64}₩ at 0.0001% = 64₩ exchange rate");
|
|
}
|
|
[Command("bet")]
|
|
public async Task Gamble(int wager)
|
|
{
|
|
int res0 = SRandom.Next(0, 10000000);
|
|
Random ran = new Random(res0);
|
|
int res1 = ran.Next(0, 101);
|
|
if (wager<0)
|
|
{
|
|
wager = 0;
|
|
}
|
|
int loss = wager;
|
|
if (res1 == 100)
|
|
{
|
|
wager = wager*4;
|
|
}
|
|
else
|
|
{
|
|
if (res1 >= 95)
|
|
{
|
|
wager = wager * 3;
|
|
}
|
|
else
|
|
{
|
|
if (res1 == 77)
|
|
{
|
|
wager = wager * 7;
|
|
}
|
|
else
|
|
{
|
|
if (res1 < 60)
|
|
{
|
|
wager = 0;
|
|
}
|
|
else
|
|
{
|
|
wager = wager * 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
var user = Database.Users.FirstOrDefault(x => x.Id == Context.User.Id);
|
|
var buser = Database.Users.FirstOrDefault(x => x.Id == 0);
|
|
if (user.Money < loss)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} You can't afford that, go back to the mines.");
|
|
}
|
|
else
|
|
{
|
|
if (buser.Money > 100)
|
|
{
|
|
if (!user.GrantMoney(Database.Users.FirstOrDefault(x => x.Id == 0), (wager) - loss))
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} Bank has no money, gamble more and lose please.");
|
|
}
|
|
await Database.SaveChangesAsync();
|
|
|
|
EmbedBuilder embed = new EmbedBuilder();
|
|
if (res1 == 77)
|
|
{
|
|
embed.AddField($"**Rolled: Lucky cat!**", $"Result: +{((wager) - loss) / 10000d}%\nBalance: {(user.Money) / 10000d}%");
|
|
await ReplyAsync($"{Context.User.Mention}", false, embed.Build());
|
|
}
|
|
else
|
|
{
|
|
if (((wager) - loss) > 0)
|
|
{
|
|
embed.AddField($"**Rolled: {res1}**", $"Result: +{((wager) - loss) / 10000d}%\nBalance: {(user.Money) / 10000d}%");
|
|
await ReplyAsync($"{Context.User.Mention}", false, embed.Build());
|
|
}
|
|
if (((wager) - loss) < 0)
|
|
{
|
|
embed.AddField($"**Rolled: {res1}**", $"Result: {((wager) - loss) / 10000d}%\nBalance: {(user.Money) / 10000d}%");
|
|
await ReplyAsync($"{Context.User.Mention}", false, embed.Build());
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await ReplyAsync($"Hey, stop that.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
[Command("give")]
|
|
public async Task GiveShekel(IGuildUser person, int amount)
|
|
{
|
|
if (amount > 0)
|
|
{
|
|
using (var Database = new ApplicationDbContextFactory().CreateDbContext())
|
|
{
|
|
var user = Database.Users.FirstOrDefault(x => x.Id == Context.User.Id);
|
|
if (user.Money < amount)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} You don't have that much money??");
|
|
}
|
|
else
|
|
{
|
|
if (user.Id == person.Id)
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} You have transferred your money to yourself???");
|
|
}
|
|
else
|
|
{
|
|
var transfer = amount - (amount * 2);
|
|
if (!user.GrantMoney(Database.Users.FirstOrDefault(x => x.Id == person.Id), transfer))
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} You can't afford that, go back to the mines.");
|
|
}
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} **{amount / 10000d}%** has been transferred from your account.");
|
|
await Database.SaveChangesAsync();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
await Context.Channel.SendMessageAsync($"{Context.User.Mention} That's not how this works??");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//public class Event : ModuleBase<ICommandContext> /////////////////////////
|
|
//{
|
|
// [Command("coof"), Ratelimit(1, 1, Measure.Minutes)]
|
|
// public async Task Coof([Remainder] IGuildUser name)
|
|
// {
|
|
// var user = await Context.Guild.GetUserAsync(Context.User.Id).ConfigureAwait(false); ;
|
|
// if (user.RoleIds.Any(id => id == 672517021732438026))
|
|
// {
|
|
// var role = Context.Guild.GetRole(672517021732438026);
|
|
// var hearole = Context.Guild.GetRole(672759930666876991);
|
|
// if (name.RoleIds.Any(id => id == 672755435454988294))
|
|
// {
|
|
// await ReplyAsync($"{name.Mention}'s hazmat suit is protecting them from the corona");
|
|
// }
|
|
// else
|
|
// {
|
|
// await name.AddRoleAsync(role).ConfigureAwait(false);
|
|
// await name.RemoveRoleAsync(hearole).ConfigureAwait(false);
|
|
|
|
// Console.WriteLine($"{Context.User.Username} has infected {name.Username}");
|
|
|
|
// await ReplyAsync($"{Context.User.Mention} has infected {name.Mention}");
|
|
// await ReplyAsync($"Corona has been cured for now haha yeah");
|
|
// }
|
|
// }
|
|
// }
|
|
// [Command("cure"), Ratelimit(3, 30, Measure.Minutes)]
|
|
// public async Task Cure([Remainder] IGuildUser name)
|
|
// {
|
|
// var user = await Context.Guild.GetUserAsync(Context.User.Id).ConfigureAwait(false); ;
|
|
// if ((user.RoleIds.Any(id => id == 672755435454988294)) || (user.RoleIds.Any(id => id == 672759930666876991)))
|
|
// {
|
|
// var role = Context.Guild.GetRole(672759930666876991);
|
|
// var infrole = Context.Guild.GetRole(672517021732438026);
|
|
// if (name.RoleIds.Any(id => id == 672785044699611139))
|
|
// {
|
|
// await ReplyAsync($"{name.Mention} absolutely refuses to be vaccinated");
|
|
// }
|
|
// else
|
|
// {
|
|
// if (name.RoleIds.Any(id => id == 672517021732438026))
|
|
// {
|
|
// await name.AddRoleAsync(role).ConfigureAwait(false);
|
|
// await name.RemoveRoleAsync(infrole).ConfigureAwait(false);
|
|
|
|
// Console.WriteLine($"{Context.User.Username} has cured {name.Username}");
|
|
|
|
// await ReplyAsync($"{Context.User.Mention} has vaccinated {name.Mention}");
|
|
// }
|
|
// else
|
|
// {
|
|
// await ReplyAsync($"{name.Mention} is not infected??? are you super retarded???");
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
//}
|
|
|
|
public class Admin : ModuleBase ///////////////////////////////////////////////
|
|
{
|
|
[RequireRolePrecondition(AccessLevel.ServerAdmin)]
|
|
[Command("adddelet")]
|
|
public async Task AddDelet() //Listens for attachments
|
|
{
|
|
var attachments = Context.Message.Attachments;//Gets attachments as var
|
|
foreach (var item in attachments)
|
|
{
|
|
Uri link = new Uri(item.Url);
|
|
using (WebClient _webclient = new WebClient())
|
|
{
|
|
string location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "delet");
|
|
if (!Directory.Exists(location))
|
|
Directory.CreateDirectory(location);
|
|
location += "/" + item.Filename;
|
|
_webclient.DownloadFileAsync(link, location);
|
|
}
|
|
await ReplyAsync($"Delet added");
|
|
break;
|
|
}
|
|
}
|
|
[RequireRolePrecondition(AccessLevel.ServerAdmin)]
|
|
[Command("adddelet")]
|
|
public async Task AddDelet(string url) //Listens for urls
|
|
{
|
|
Uri link = new Uri(url);
|
|
using (WebClient _webclient = new WebClient())
|
|
{
|
|
string location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"delet");
|
|
if (!Directory.Exists(location))
|
|
Directory.CreateDirectory(location);
|
|
location += "/" + Guid.NewGuid() + ".jpg";
|
|
_webclient.DownloadFileAsync(link, location);
|
|
}
|
|
await ReplyAsync($"Delet added");
|
|
}
|
|
[RequireRolePrecondition(AccessLevel.ServerAdmin)]
|
|
[Command("say")]
|
|
public async Task Say(ITextChannel channel, [Remainder]string message)
|
|
{
|
|
await channel.SendMessageAsync(message);
|
|
}
|
|
[RequireRolePrecondition(AccessLevel.BotOwner)]
|
|
[Command("modifybot")]
|
|
public async Task ModifyBot(string _name)
|
|
{
|
|
//reference current bot user
|
|
var BotCurrUser = Bot._bot.CurrentUser;
|
|
await BotCurrUser.ModifyAsync(x =>
|
|
{
|
|
//sets name
|
|
x.Username = _name;
|
|
});
|
|
//reply
|
|
await ReplyAsync($"Set name to {_name}");
|
|
}
|
|
[RequireRolePrecondition(AccessLevel.BotOwner)]
|
|
[Command("savefile")]
|
|
|
|
public async Task SaveFile(string fday, string fscore)
|
|
{
|
|
string location = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "drawtasks");
|
|
string tlocation = ($"{location}/days.txt");
|
|
var attachments = Context.Message.Attachments;
|
|
string fname = $"{fday}-{fscore}";
|
|
if (File.Exists(location + "/days.txt"))
|
|
{
|
|
|
|
}
|
|
foreach (var item in attachments)
|
|
{
|
|
Uri link = new Uri(item.Url);
|
|
using (WebClient _webclient = new WebClient())
|
|
{
|
|
if (!Directory.Exists(location))
|
|
Directory.CreateDirectory(location);
|
|
location += ($"/{fday}-{fscore}.jpg");
|
|
_webclient.DownloadFileAsync(link, location);
|
|
}
|
|
await ReplyAsync($"Post archived");
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//public class _ : ModuleBase
|
|
//{
|
|
// [RequireRolePrecondition(AccessLevel.BotOwner)]
|
|
// [Command("embedtest")]
|
|
// public async Task Embedthing(bool inline, [Remainder]string text)
|
|
// {
|
|
// var BotUser = await Bot._bot.GetApplicationInfoAsync();
|
|
// EmbedBuilder embed = new EmbedBuilder();
|
|
// EmbedAuthorBuilder author = new EmbedAuthorBuilder();
|
|
// EmbedFooterBuilder footer = new EmbedFooterBuilder();
|
|
// //author stuff
|
|
// author.Name = BotUser.Name;
|
|
// author.IconUrl = BotUser.IconUrl;
|
|
// embed.Author = author;
|
|
// //footer stuff
|
|
// footer.Text = "Given at";
|
|
// embed.Footer = footer;
|
|
// //embed stuff
|
|
// embed.Timestamp = DateTime.Now;
|
|
// embed.AddInlineField("test 1", "test 1");
|
|
// embed.AddInlineField("test 2", "test 2");
|
|
// embed.AddField(x =>
|
|
// {
|
|
// x.IsInline = inline;
|
|
// x.Name = "Test Embed";
|
|
// x.Value = text;
|
|
// });
|
|
// await ReplyAsync("This is an embed test, I think I did it...", false, embed);
|
|
// }
|
|
//}
|
|
}
|
|
|