public static async Task SyncRolesAsync(DiscordGuild guild)
{
Config.Log.Debug("Syncing moderator list to the sudoer role");
var modRoleList = guild.Roles.Where(kvp => kvp.Value.Name.Equals("Moderator")).ToList();
if (modRoleList.Count == 0)
{
return;
}
var modRole = modRoleList.First().Value;
var members = await guild.GetAllMembersAsync().ConfigureAwait(false);
var guildMods = members.Where(m => m.Roles.Any(r => r.Id == modRole.Id) && !m.IsBot && !m.IsCurrent).ToList();
foreach (var mod in guildMods)
{
if (!IsMod(mod.Id))
{
Config.Log.Debug($"Making {mod.Username}#{mod.Discriminator} a bot mod");
await AddAsync(mod.Id).ConfigureAwait(false);
}
if (!IsSudoer(mod.Id))
{
Config.Log.Debug($"Making {mod.Username}#{mod.Discriminator} a bot sudoer");
await MakeSudoerAsync(mod.Id).ConfigureAwait(false);
}
}
}
public static async Task <DiscordUser> FindUserByName(DiscordGuild server, string name, string discrim)
{
var members = await server.GetAllMembersAsync();
if (discrim == null)
{
//Try searching without discrim
var matches = members.Where(x => x.Username.ToLower() == name.ToLower());
if (matches.Count() == 1)
{
return(matches.First());
}
else
{
return(null);
}
}
else
{
//Try searching with discrim
var matches = members.Where(x => x.Username.ToLower() == name.ToLower() && x.Discriminator == discrim.ToString());
if (matches.Count() == 1)
{
return(matches.First());
}
else
{
return(null);
}
}
}
public async Task <List <DiscordMember> > GetAllNonBotMembers(DiscordClient discord)
{
DiscordGuild guild = await discord.GetGuildAsync(GuildConfiguration.Id);
var members = (await guild.GetAllMembersAsync()).Where(x => !x.IsBot).ToList();
return(members);
}
private async Task <int> JoinPosition(DiscordMember member, DiscordGuild guild)
{
var members = await guild.GetAllMembersAsync();
var joinPosition = members.OrderBy(x => x.JoinedAt).ToList().FindIndex(x => x.Id == member.Id) + 1;
return(joinPosition);
}
public async Task Add(DiscordGuild G)
{
var Members = await G.GetAllMembersAsync();
foreach (DiscordMember M in Members)
{
await this.Add(M);
}
}
public async Task <DiscordMember> FindMemberByName(DiscordGuild guild, string username)
{
foreach (var member in await guild.GetAllMembersAsync())
{
if (member.Username.ToLower().Contains(username.ToLower()))
{
return(member);
}
}
return(null);
}
public static async Task <Dictionary <string, string> > GetStringDictionaryAsync(DiscordGuild guild)
{
var allmembers = await guild.GetAllMembersAsync();
return(new Dictionary <string, string>
{
["AllMembersCount"] = NumberUtils.FormatSize(guild.MemberCount),
["MemberCount"] = NumberUtils.FormatSize(allmembers.LongCount(x => !x.IsBot)),
["BotsCount"] = NumberUtils.FormatSize(allmembers.LongCount(x => x.IsBot)),
["BoostCount"] = NumberUtils.FormatSize((int)guild.PremiumSubscriptionCount)
});
}
public async Task RunBotAsync()
{
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);
var cfg = new DiscordConfiguration
{
Token = cfgjson.Token,
TokenType = TokenType.Bot,
AutoReconnect = true,
LogLevel = LogLevel.Debug,
UseInternalLogHandler = true
};
this.Client = new DiscordClient(cfg);
this.Client.Ready += this.Client_Ready;
this.Client.GuildAvailable += this.Client_GuildAvailable;
this.Client.ClientErrored += this.Client_ClientError;
this.Client.MessageCreated += Client_MessageCreated;
this.Client.MessageReactionAdded += Client_MessageReactionAdded;
this.Client.VoiceStateUpdated += Client_VoiceStateUpdated;
await this.Client.ConnectAsync();
DiscordGuild wondergames = await Client.GetGuildAsync(ulong.Parse(cfgjson.WonderServer));
if (!File.Exists(filepath))
{
IReadOnlyCollection <DiscordUser> userbase = await wondergames.GetAllMembersAsync();
LastSeen = new Dictionary <ulong, DateTime>();
foreach (DiscordUser user in userbase)
{
LastSeen.Add(user.Id, DateTime.MinValue);
}
File.WriteAllText(filepath, JsonConvert.SerializeObject(LastSeen, Formatting.Indented));
}
else
{
LastSeen = JsonConvert.DeserializeObject <Dictionary <ulong, DateTime> >(File.ReadAllText(filepath));
}
await Task.Delay(-1);
}
public static async Task <int> GetOfflineCountAsync(this DiscordGuild guild)
{
int offlineCount = 0;
foreach (DiscordMember member in await guild.GetAllMembersAsync().ConfigureAwait(false))
{
if (member.Presence == null || member.Presence.Status == UserStatus.Invisible)
{
offlineCount++;
}
}
return(offlineCount);
}
public static async Task <int> GetBotCountAsync(this DiscordGuild guild)
{
int botCount = 0;
foreach (DiscordMember member in await guild.GetAllMembersAsync().ConfigureAwait(false))
{
if (member.IsBot)
{
botCount++;
}
}
return(botCount);
}
public List <DiscordMember> AddRoleAsActive(DiscordGuild guild, DiscordRole role)
{
var result = new List <DiscordMember>();
foreach (var user in guild.GetAllMembersAsync().Result)
{
if (user.Roles.Contains(role))
{
SetActive(user);
result.Add(user);
}
}
return(result);
}
public static async Task <DiscordColor> returnDiscordRoleColourAsync(string username)
{
DiscordColor colorDiscord = DiscordColor.White;
DiscordGuild guild = returnDiscordGuild(retrieveDiscordGuildID(Program.listeningGuild));
IReadOnlyList <DiscordMember> users = await guild.GetAllMembersAsync();
foreach (DiscordMember user in users)
{
if (user.Username == username)
{
colorDiscord = user.Color;
}
}
return(colorDiscord);
}
public async Task <Administrator[]> GetAdministratorsAsync(DiscordGuild guild)
{
var members = await guild.GetAllMembersAsync();
var AdministratorObjectList = members.Where(member => member.Roles.Any(role => role.Permissions.HasPermission(Permissions.KickMembers)));
var AdministratorIDList = new List <Administrator>();
foreach (var admin in AdministratorObjectList)
{
AdministratorIDList.Add(new Administrator()
{
ID = admin.Id
});
}
return(AdministratorIDList.ToArray());
}
public static async Task <int> GetOnlineCountAsync(this DiscordGuild guild)
{
int onlineCount = 0;
foreach (DiscordMember member in await guild.GetAllMembersAsync().ConfigureAwait(false))
{
if (member.Presence != null)
{
if (member.Presence.Status == UserStatus.Online || member.Presence.Status == UserStatus.Idle || member.Presence.Status == UserStatus.DoNotDisturb)
{
onlineCount++;
}
}
}
return(onlineCount);
}
public static async Task <IReadOnlyCollection <DiscordMember> > GetGuildMembersAsync(DiscordGuild guild)
{
if (!BotHasIntent(DiscordIntents.GuildMembers))
{
Logger.Error("Attempted to get full guild member list without the bot having the privileged GuildMembers intent");
return(null);
}
try
{
return(await guild.GetAllMembersAsync());
}
catch (Exception e)
{
Logger.Error("Error occured when attempting to fetch all guild members. Error message: " + e);
return(null);
}
}
public static async Task UpdateUserList(DiscordGuild e, bool update)
{
var members = await e.GetAllMembersAsync();
foreach (var user in members)
{
if (!RPClass.Users.Any(x => x.UserData.UserID == user.Id))
{
RPClass.Users.Add(new UserObject.RootObject(user.Id));
}
}
if (update)
{
await XPClass.UpdateStats();
await XPClass.UpdatePlayerRanking(e);
await XPClass.UpdateGuildRanking(e);
}
}
public async Task CreateGuild(CommandContext e, string lang = "fr")
{
try
{
Global.Client = e.Client;
SetLanguage(lang);
var msgs = (await e.Guild.GetDefaultChannel().GetMessagesAsync(10)).ToList()
.FindAll(m => m.Author == e.Client.CurrentUser || m.Content.Contains("!go"));
if (msgs.Count > 0)
{
await e.Guild.GetDefaultChannel().DeleteMessagesAsync(msgs);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
while (Guild == null)
{
try
{
Guild = e.Client.CreateGuildAsync("Loup Garou").GetAwaiter().GetResult();
GuildId = Guild.Id;
await Guild.ModifyAsync(x => x.SystemChannel = null);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
await GameBuilder.CreateDiscordRoles(this);
await GameBuilder.GetMember(Guild, Global.Client.CurrentUser).GrantRoleAsync(Global.Roles[CustomRoles.Admin]);
await(await Guild.GetAllMembersAsync()).First().ModifyAsync(m => m.Nickname = Texts.BotName);
Console.WriteLine("Guild Created");
DiscordChannels = new Dictionary <GameChannel, DiscordChannel>();
Console.WriteLine("Delatation faite");
await e.TriggerTypingAsync();
var generalChannel = Guild.GetDefaultChannel();
await generalChannel.ModifyAsync(x => x.Name = "Bot");
DiscordChannels.Add(GameChannel.BotText, generalChannel);
var botVChannel = await Guild.CreateChannelAsync("Bot", ChannelType.Voice, generalChannel.Parent);
DiscordChannels.Add(GameChannel.BotVoice, botVChannel);
e.Client.GuildMemberAdded += NewGuildMember;
e.Client.GuildMemberAdded += StartMember;
var inv = await generalChannel.CreateInviteAsync();
var msgInv = await e.RespondAsync(inv.ToString());
var embed = new DiscordEmbedBuilder
{
Title = Texts.BotWantPlay,
Color = Color.PollColor
};
var askMessage = await generalChannel.SendMessageAsync(embed : embed.Build());
var emoji = DiscordEmoji.FromName(e.Client, ":thumbsup:");
await askMessage.CreateReactionAsync(emoji);
var players = new List <DiscordMember>();
try
{
var timeToJoin = 10;
await Task.Delay(timeToJoin * 1000);
var users = await(await Guild.GetDefaultChannel().GetMessageAsync(askMessage.Id))
.GetReactionsAsync(emoji);
foreach (var usr in users)
{
if (!usr.IsBot)
{
var dm = await Guild.GetMemberAsync(usr.Id);
await dm.RevokeRoleAsync(Global.Roles[CustomRoles.Spectator]);
await dm.GrantRoleAsync(Global.Roles[CustomRoles.Player]);
players.Add(dm);
}
}
// DEBUG
foreach (var discordMember in players)
{
WriteDebug($"Il y a {discordMember.Username} dans le jeu");
}
e.Client.GuildMemberAdded -= StartMember;
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine(13);
try
{
GameBuilder.Debug(this);
var channelsToRemove = new List <DiscordChannel>();
while (Guild.Channels.Count != DiscordChannels.Count)
{
foreach (var c in Guild.Channels)
{
try
{
if (!DiscordChannels.ContainsValue(c))
{
channelsToRemove.Add(c);
}
}
catch (NotFoundException exception)
{
Console.WriteLine(exception.JsonMessage);
}
}
foreach (var dm in channelsToRemove)
{
await dm.DeleteAsync();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("Supr fini");
await RoleAssignment(msgInv, e, players);
foreach (var p in PersonnagesList)
{
WriteDebug($"Y : {p.Me.Username}");
DiscordMember usr = GameBuilder.GetMember(Guild, p.Me);
await DiscordChannels[GameChannel.BotVoice].AddOverwriteAsync(usr, Permissions.None,
GameBuilder.CreatePerms(Permissions.AccessChannels, Permissions.UseVoice));
}
if (PersonnagesList.Count < 2)
{
Victory = Victory.NotPlayable;
embed = new DiscordEmbedBuilder
{
Title = $"{Texts.NotEnoughPlayer} {PersonnagesList.Count}",
Color = Color.InfoColor
};
await DiscordChannels[GameChannel.TownText].SendMessageAsync(embed: embed.Build());
}
while (Victory == Victory.None && Victory != Victory.NotPlayable)
{
await PlayAsync();
}
}
/// <summary>
/// Attempts to get a member via three distinct methods: <para/>
/// First, it will attempt to cast <paramref name="data"/> into a ulong and see if it is a user GUID (this includes processing pings, like <@GUID_HERE>)<para/>
/// Second, it will attempt to see if <paramref name="data"/> is a discriminator (only if data is formatted as #XXXX where XXXX is four digits)<para/>
/// Finally, and only if the second method had no results or wasn't used, it will attempt to find <paramref name="data"/> as a nickname or username.<para/>
/// This will throw a NonSingularResultException if the query can return more than one user.
/// </summary>
/// <param name="server">The Discord server to target.</param>
/// <param name="data">The query to get a XanBotMember from. This can be a ulong as a string, a user ping (<@ulong>), a server nickname, a username (or optionally username#discriminator)</param>
/// <exception cref="NonSingularResultException"/>
/// <returns></returns>
public static async Task <XanBotMember> GetMemberFromDataAsync(DiscordGuild server, string data)
{
// Wait! If it's a ping, it will start with <@ and end with >
string newdata = data;
if (data.StartsWith("<@") && data.EndsWith(">"))
{
newdata = data.Substring(2, data.Length - 3);
}
// I don't know if this method is used but it's one Discord supports so I have to support it too.
if (data.StartsWith("<@!") && data.EndsWith(">"))
{
newdata = data.Substring(3, data.Length - 4);
}
if (ulong.TryParse(newdata, out ulong uuid))
{
try
{
DiscordUser user = await XanBotCoreSystem.Client.GetUserAsync(uuid);
// Catch case: Someone's username is a bunch of numbers OR they link a user ID that isn't in the server.
if (user != null)
{
XanBotMember member = XanBotMember.GetMemberFromUser(server, user);
if (member != null)
{
return(member);
}
}
}
catch (NotFoundException)
{
// The person typed in a number, it doesn't correspond to a discord GUID, so we'll catch the NotFoundException and let the code continue.
}
}
List <XanBotMember> potentialReturns = new List <XanBotMember>();
string dataLower = data.ToLower();
// Discriminator searching:
if (dataLower.Length == 5 && dataLower.First() == '#' && ushort.TryParse(dataLower.Substring(1), out ushort _))
{
// This is a discriminator -- Length is 5, starts with #, and the last 4 chars are numbers.
foreach (DiscordUser user in server.Members.Values)
{
string ud = "#" + user.Discriminator;
if (dataLower == ud)
{
potentialReturns.Add(XanBotMember.GetMemberFromUser(server, user));
}
}
}
if (potentialReturns.Count == 0)
{
// ONLY if discriminator searching found nothing will we search by display name or username.
if (NeedsNewMemberCache)
{
LastCheckTime = DateTime.Now;
Members = await server.GetAllMembersAsync();
}
foreach (DiscordMember member in Members)
{
//foreach (DiscordMember member in server.Members.Values) { // DO NOT USE THIS. It's not fully populated in large servers.
string fullName = member.Username + "#" + member.Discriminator;
string nickName = member.Nickname ?? "";
fullName = fullName.ToLower();
nickName = nickName.ToLower();
if (nickName.Length >= dataLower.Length && dataLower == nickName.Substring(0, dataLower.Length))
{
potentialReturns.Add(XanBotMember.GetMemberFromUser(server, member));
}
else if (fullName.Length >= dataLower.Length && dataLower == fullName.Substring(0, dataLower.Length))
{
potentialReturns.Add(XanBotMember.GetMemberFromUser(server, member));
}
// Do NOT break if there are multiple. This is necessary for the values in a potential NonSingularResultException
}
}
XanBotMember[] potentialReturnsArray = potentialReturns.ToArray();
if (potentialReturnsArray.Length == 0)
{
return(null);
}
else if (potentialReturnsArray.Length == 1)
{
return(potentialReturnsArray[0]);
}
else
{
throw new NonSingularResultException(string.Format("More than one member of the server was found with the search query `{0}`!", data), potentialReturnsArray);
}
}
public async Task GetGuildMemberList(CommandContext commandContext)
{
DiscordGuild guild = commandContext.Member.Guild;
System.Collections.Generic.IReadOnlyCollection <DiscordMember> readOnlyCollections = await guild.GetAllMembersAsync();
await commandContext.Channel.SendMessageAsync("Guild " + guild.Name + " members count " + readOnlyCollections.Count.ToString());
string memberList = string.Empty;
foreach (DiscordMember member in readOnlyCollections)
{
memberList += member.DisplayName + ",";
}
await commandContext.Channel.SendMessageAsync(memberList.TrimEnd(','));
}
public static async Task UpdatePlayerRanking(DiscordGuild e)
{
var ocs = RPClass.Users.Where(x => x.UserData.Xp > 0);
if (!ocs.Any())
{
return;
}
var members = await e.GetAllMembersAsync();
DiscordChannel RankingChannel = RPClass.StatsChannel;
int longestName = ocs.Max(x => members.First(y => y.Id == x.UserData.UserID).DisplayName.Length) + 1;
if (longestName < 5)
{
longestName = 5;
}
int longestCount = 4;
int longestGuild = RPClass.Guilds.Select(x => x.Name.Length).DefaultIfEmpty(7).Max() + 1;
if (longestGuild < 8)
{
longestGuild = 8;
}
string Count = "Pos".PadRight(longestCount) + "| ";
string Name = "Name".PadRight(longestName) + "| ";
string Faction = "Faction".PadRight(longestGuild) + "| ";
string Rank = "Rank";
string value = "";
value += $"```{Count}{Name}{Faction}{Rank}\n{new string('-', $"{Count}{Name}{Faction}{Rank}".Length + 4)}\n";
List <UserObject.RootObject> SortedUsers = new List <UserObject.RootObject>();
SortedUsers = ocs.OrderByDescending(x => (x.UserData.Xp)).ToList();
try
{
await RankingChannel.DeleteMessagesAsync(await RankingChannel.GetMessagesAsync(100));
}
catch { }
int countNum = 1;
foreach (UserObject.RootObject user in SortedUsers)
{
string UserRank = user.UserData.GetRank();
string UserFaction = "";
if (user.UserData.FactionID == 0)
{
UserFaction += "N/A";
}
else
{
UserFaction += RPClass.Guilds.First(x => x.Id == user.UserData.FactionID).Name;
}
if (value.Length > 1500)
{
await RankingChannel.SendMessageAsync(value + "```");
value = "```";
}
value += (countNum.ToString().PadRight(longestCount) + "| " + members.First(y => y.Id == user.UserData.UserID).DisplayName.PadRight(longestName) + "| " + UserFaction.PadRight(longestGuild) + "| " + UserRank + "\n");
countNum += 1;
}
await RankingChannel.SendMessageAsync(value + "```");
}
public static async Task AddOrUpdateUsers(DiscordGuild guild, bool update)
{
List <DiscordMember> AllUsers = new List <DiscordMember>(await guild.GetAllMembersAsync());
AllUsers.RemoveAll(x => x.IsBot);
List <DiscordChannel> Channels = new List <DiscordChannel>(await guild.GetChannelsAsync());
foreach (DiscordMember user in AllUsers)
{
int role = 0;
/*312980663638818817 = Pro Hero
* 312981984790052866 = Sidekick
* 312980292086530048 = Academy Student
* 312982325908471808 = Villain
* 317915877775245312 = Rogue
*
*/
if (user.Roles.Any(x => x.Id == 312980663638818817))
{
role = 1;
}
else if (user.Roles.Any(x => x.Id == 312982325908471808))
{
role = 2;
}
else if (user.Roles.Any(x => x.Id == 317915877775245312))
{
role = 3;
}
else if (user.Roles.Any(x => x.Id == 312981984790052866 || x.Id == 312980292086530048))
{
role = 4;
}
if (!Users.Any(x => x.UserData.UserID == user.Id))
{
Users.Add(new UserObject.RootObject(new UserObject.UserData(user.Id, user.DisplayName, role), new UserObject.InvData()));
}
if (Users.Find(x => x.UserData.UserID == user.Id).UserData.Username != user.DisplayName)
{
Users.Find(x => x.UserData.UserID == user.Id).UserData.Username = user.DisplayName;
}
if (Users.Find(x => x.UserData.UserID == user.Id).UserData.Role != role)
{
Users.Find(x => x.UserData.UserID == user.Id).UserData.Role = role;
}
}
if (update)
{
await XPClass.UpdateStats(StatsChannel);
await XPClass.UpdateGuildRanking(guild);
await XPClass.UpdatePlayerRanking(guild, 1);
await XPClass.UpdatePlayerRanking(guild, 2);
await XPClass.UpdatePlayerRanking(guild, 3);
await XPClass.UpdatePlayerRanking(guild, 4);
}
SaveData(-1);
}
public async Task AssignMassRoleToGuildMembersAsync(DiscordGuild guild, DiscordRole guildRole) => await Task.WhenAll((await guild.GetAllMembersAsync()).Select(member => member.GrantRoleAsync(guildRole)));
public async Task CreateGuild(CommandContext e)
{
try
{
if (Global.InGame)
{
var embed = new DiscordEmbedBuilder
{
Color = Color.InfoColor,
Title = Texts.Errors.AnotherGameIsPlaying
};
await e.Channel.SendMessageAsync(embed : embed.Build());
}
else
{
try
{
Global.Client = e.Client;
var msgs = (await e.Guild.GetDefaultChannel().GetMessagesAsync(10)).ToList()
.FindAll(m => m.Author == e.Client.CurrentUser || m.Content.Contains("!go"));
if (msgs.Count > 0)
{
await e.Guild.GetDefaultChannel().DeleteMessagesAsync(msgs);
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
}
Console.WriteLine(File.ReadAllText(@"..//Locale/fr/lang.json", Encoding.UTF8));
while (Guild == null)
{
try
{
Guild = e.Client.CreateGuildAsync("Loup Garou").GetAwaiter().GetResult();
GuildId = Guild.Id;
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
await Guild.ModifyAsync(x => x.SystemChannel = new Optional <DiscordChannel>(null));
await Guild.ModifyAsync(opt =>
opt.DefaultMessageNotifications = DefaultMessageNotifications.MentionsOnly);
Global.InGame = true;
WriteDebug("1");
await GameBuilder.CreateDiscordRoles(); // Role Admin, Joueur, Spectateur
WriteDebug("2");
await Global.Client.CurrentUser.GetMember().GrantRoleAsync(Global.Roles[PublicRole.Admin]);
WriteDebug("3");
await(await Guild.GetAllMembersAsync()).First()
.ModifyAsync(m => m.Nickname = Texts.DiscordRoles.BotName);
WriteDebug("4");
Console.WriteLine("Guild Created");
DiscordChannels = new Dictionary <GameChannel, DiscordChannel>();
await e.TriggerTypingAsync();
var generalChannel = Guild.GetDefaultChannel();
await generalChannel.ModifyAsync(x => x.Name = "Bot");
DiscordChannels.Add(GameChannel.BotText, generalChannel);
var botVChannel = await Guild.CreateChannelAsync("Bot", ChannelType.Voice, generalChannel.Parent);
DiscordChannels.Add(GameChannel.BotVoice, botVChannel);
Global.Client.GuildMemberAdded += NewGuildMember;
Global.Client.GuildMemberAdded += StartMember;
var inv = await generalChannel.CreateInviteAsync();
var msgInv = await e.RespondAsync(inv.ToString());
var embed = new DiscordEmbedBuilder
{
Title = Texts.Annoucement.BotWantPlay,
Color = Color.PollColor
};
await generalChannel.SendMessageAsync(embed : embed.Build());
var players = new List <DiscordMember>();
await Task.Delay(Global.Config.JoinTime);
foreach (var usr in botVChannel.Users)
{
await usr.RevokeRoleAsync(Global.Roles[PublicRole.Spectator]);
await usr.GrantRoleAsync(Global.Roles[PublicRole.Player]);
players.Add(usr);
WriteDebug(usr.Username);
}
Global.Client.GuildMemberAdded -= StartMember;
Global.Client.MessageReactionAdded += Listeners.PreventMultiVote;
Global.Client.MessageReactionAdded += Listeners.PreventSpectatorFromVote;
Console.WriteLine(13);
try
{
GameBuilder.Debug(this);
var channelsToRemove = new List <DiscordChannel>();
while (Guild.Channels.Count != DiscordChannels.Count)
{
foreach (var c in Guild.Channels)
{
try
{
if (!DiscordChannels.ContainsValue(c))
{
channelsToRemove.Add(c);
}
}
catch (NotFoundException exception)
{
Console.WriteLine(exception.JsonMessage);
}
}
foreach (var dm in channelsToRemove)
{
await dm.DeleteAsync();
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.WriteLine("Supr fini");
await RoleAssignment(msgInv, e, players);
foreach (var p in PersonnagesList)
{
WriteDebug($"Y : {p.Me.Username}");
var usr = GameBuilder.GetMember(Guild, p.Me);
await DiscordChannels[GameChannel.BotVoice].AddOverwriteAsync(usr, Permissions.None,
GameBuilder.CreatePerms(Permissions.AccessChannels, Permissions.UseVoice));
}
if (PersonnagesList.Count < 2)
{
Victory = Victory.NotPlayable;
embed = new DiscordEmbedBuilder
{
Title = $"{Texts.Errors.NotEnoughPlayer} {PersonnagesList.Count}",
Color = Color.InfoColor
};
await DiscordChannels[GameChannel.TownText].SendMessageAsync(embed: embed.Build());
await Task.Delay(Global.Config.JoinTime);
await Global.Game.Guild.DeleteAsync();
}
else
{
e.Client.VoiceStateUpdated += Listeners.KillLeaver;
}
while (Victory == Victory.None && Victory != Victory.NotPlayable)
{
await PlayAsync();
}
}
}
catch (Exception e4)
{
Console.WriteLine(e4);
}
}
public async Task RemoveMassRoleOnGuildMembersAsync(DiscordGuild guild, DiscordRole guildRole) => await Task.WhenAll((await guild.GetAllMembersAsync()).Select(member => member.RevokeRoleAsync(guildRole)));
public async Task <int> UpdatePatrons()
{
List <string> patrons = new List <string>();
List <string> patronizer = new List <string>();
List <string> patronized = new List <string>();
Dictionary <string, string> emojis = new Dictionary <string, string>();
// collect ids of patron members
DiscordGuild typotestground = await Program.Client.GetGuildAsync(779435254225698827);
foreach (DiscordMember member in await typotestground.GetAllMembersAsync())
{
if (member.Roles.Any(role => role.Id == 832744566905241610))
{
patrons.Add(member.Id.ToString());
}
if (member.Roles.Any(role => role.Id == 859100010184572938))
{
patronizer.Add(member.Id.ToString());
}
}
;
PatronCount = patrons.Count();
PalantirDbContext db = new PalantirDbContext();
// iterate through palantir members and set flags
await db.Members.ForEachAsync(member =>
{
PermissionFlag flag = new PermissionFlag((byte)member.Flag);
flag.Patron = patrons.Any(patron => member.Member.Contains(patron));
if (patronizer.Any(id => member.Member.Contains(id)))
{
flag.Patronizer = true;
if (member.Patronize is not null)
{
patronized.Add(member.Patronize.Split("#")[0]);
}
}
else
{
flag.Patronizer = false;
}
string emoji = String.IsNullOrEmpty(member.Emoji) ? "" : member.Emoji;
if (flag.Patron || flag.BotAdmin)
{
emojis.Add(member.Login, emoji);
}
member.Flag = flag.CalculateFlag();
});
// set flags of patronized members
patronized.ForEach(id =>
{
if (db.Members.Any(member => member.Member.Contains(id)))
{
MemberEntity member = db.Members.FirstOrDefault(member => member.Member.Contains(id));
PermissionFlag flag = new PermissionFlag((byte)member.Flag);
flag.Patron = true;
string emoji = String.IsNullOrEmpty(member.Emoji) ? "" : member.Emoji;
emojis.Add(member.Login, emoji);
member.Flag = flag.CalculateFlag();
}
});
db.SaveChanges();
db.Dispose();
PatronEmojis = emojis;
return(patrons.Count);
}
public async Task <IEnumerable <Moderator> > GetModeratorsAsync(DiscordGuild guild) => (await guild.GetAllMembersAsync()) .Where(member => member.HasPermission(Permissions.KickMembers) && !member.IsBot) .Select(mod => new Moderator(mod.Id));
public async Task <IEnumerable <Administrator> > GetAdministratorsAsync(DiscordGuild guild) => (await guild.GetAllMembersAsync()) .Where(member => member.HasPermission(Permissions.Administrator) && !member.IsBot) .Select(admin => new Administrator(admin.Id));
public async Task Populations(CommandContext ctx)
{
if (districts is null)
{
sv = await ctx.Client.GetGuildAsync(798307000206360588);
districts = new()
{
sv.GetRole(840302532165500959), //Voopmont
sv.GetRole(840303040572424252), //Katonia
sv.GetRole(840303004347531285), //New Avalon
sv.GetRole(840303014362742784), //Landing Cove
sv.GetRole(840303153564090388), //Los Vooperis
sv.GetRole(840303011271671828), //Lanatia
sv.GetRole(840303023925755944), //Kōgi
sv.GetRole(840303033635962921), //Ardenti Terra
sv.GetRole(840303017391423508), //New Spudland
sv.GetRole(840303030443966524), //New Vooperis
sv.GetRole(840303007886475265), //San Vooperisco
sv.GetRole(840303044037836870), //Old King Peninsula
sv.GetRole(840303026979864617), //Avalon
sv.GetRole(840303020855918602), //Novastella
sv.GetRole(840303037162455090), //Thesonica
};
}
var members = await sv.GetAllMembersAsync();
IOrderedEnumerable <(string Name, int Count)> fields =
districts.Select(role => (role.Name, members.Where(X => X.Roles.Contains(role)).Count()))
.OrderByDescending(x => x.Item2);
DiscordEmbedBuilder embed = new()
{
Title = $"Discord District Populations ({(int)fields.Average(x => x.Count)} Average)",
Color = new DiscordColor("2CC26C")
};
var array = fields.Select(x => (double)x.Count).ToArray();
var median = fields.ElementAt(7).Count;
var lower = Percentile(array, 75);
var upper = Percentile(array, 25);
embed.Footer = new DiscordEmbedBuilder.EmbedFooter()
{
Text = $"Lower Quartile: {lower}\nUpper Quartile: {upper}"
};
int i = 0;
int realI = 0;
int count = 0;
foreach (var(Name, Count) in fields)
{
realI++;
if (count != Count)
{
i = realI;
}
count = Count;
embed.AddField($"{i}. {Name}" + (median == Count ? " (Median)" : ""), Count.ToString());
}
await ctx.RespondAsync(embed);
}
