private async Task RemoveUserFromVoice(DiscordUser user, DiscordGuild guild)
{
var channel = await guild.CreateChannelAsync("tempVoiceChannel", ChannelType.Voice);
var member = guild.Members.Where(x => x.Id == user.Id).First();
await member.PlaceInAsync(channel);
await channel.DeleteAsync();
Program.Logger.Log($"Removing user {user.Id} : {user.Username} from voice channel.");
userSubjectToDC.Remove(user.Id);
}
private async Task SetupGuildDefaults(DiscordGuild guild)
{
if (Guild == null)
{
Guild = guild;
try
{
InformationChannel = await guild.CreateChannelAsync("Information", ChannelType.Text);
SpawnEnemiesChannel = await guild.CreateChannelAsync("SpawnEnemies", ChannelType.Text);
IncomeFeedChannel = await guild.CreateChannelAsync("IncomeFeed", ChannelType.Text);
CheckBalanceChannel = await guild.CreateChannelAsync("CheckBalance", ChannelType.Text);
}
catch { }
var invite = await InformationChannel.CreateInviteAsync();
Debug.Log($"{Log.Timestamp()} Join: https://discord.gg/{invite.Code}");
PushNotification.Instance.Add($"Join: https://discord.gg/{invite.Code}", PushColor.Success);
}
}
public CrabgileMeeting(DiscordMember hostMember)
{
this.hostMember = hostMember;
guild = hostMember.Guild;
channels = new ConcurrentBag <DiscordChannel>();
if (!GuildMeetings.ContainsKey(guild.Id))
{
GuildMeetings.TryAdd(guild.Id, new ConcurrentDictionary <ulong, CrabgileMeeting>());
}
registrySuccess = GuildMeetings[guild.Id].TryAdd(hostMember.Id, this);
if (registrySuccess)
{
Task.Run(async() => {
meetingCategory = await guild.CreateChannelCategoryAsync($"::{hostMember.Id}::");
AddChannelToMeeting(meetingCategory);
meetingTextChannel = await guild.CreateChannelAsync("meeting-chat", DSharpPlus.ChannelType.Text, meetingCategory, "A minuted text channel for the timebox meeting.");
//AddChannelToMeeting(meetingTextChannel);
//Don't add the channel to the bag, as it shouldn't get destroyed.
});
}
}
internal async Task OnReactionAdded(DiscordClient client, MessageReactionAddEventArgs e)
{
if (e.Message.Id != Config.reactionMessage)
{
return;
}
DiscordGuild guild = e.Message.Channel.Guild;
DiscordMember member = await guild.GetMemberAsync(e.User.Id);
if (!Config.HasPermission(member, "new") || Database.IsBlacklisted(member.Id))
{
return;
}
if (reactionTicketCooldowns.ContainsKey(member.Id))
{
if (reactionTicketCooldowns[member.Id] > DateTime.Now)
{
return; // cooldown has not expired
}
else
{
reactionTicketCooldowns.Remove(member.Id); // cooldown exists but has expired, delete it
}
}
DiscordChannel category = guild.GetChannel(Config.ticketCategory);
DiscordChannel ticketChannel = await guild.CreateChannelAsync("ticket", ChannelType.Text, category);
if (ticketChannel == null)
{
return;
}
ulong staffID = 0;
if (Config.randomAssignment)
{
staffID = Database.GetRandomActiveStaff(0)?.userID ?? 0;
}
long id = Database.NewTicket(member.Id, staffID, ticketChannel.Id);
reactionTicketCooldowns.Add(member.Id, DateTime.Now.AddSeconds(10)); // add a cooldown which expires in 10 seconds
string ticketID = id.ToString("00000");
await ticketChannel.ModifyAsync(model => model.Name = "ticket-" + ticketID);
await ticketChannel.AddOverwriteAsync(member, Permissions.AccessChannels, Permissions.None);
await ticketChannel.SendMessageAsync("Hello, " + member.Mention + "!\n" + Config.welcomeMessage);
// Remove user's reaction
await e.Message.DeleteReactionAsync(e.Emoji, e.User);
// Refreshes the channel as changes were made to it above
ticketChannel = await SupportBoi.GetClient().GetChannelAsync(ticketChannel.Id);
if (staffID != 0)
{
DiscordEmbed assignmentMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket was randomly assigned to <@" + staffID + ">."
};
await ticketChannel.SendMessageAsync(assignmentMessage);
if (Config.assignmentNotifications)
{
DiscordEmbed message = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "You have been randomly assigned to a newly opened support ticket: " +
ticketChannel.Mention
};
try
{
DiscordMember staffMember = await guild.GetMemberAsync(staffID);
await staffMember.SendMessageAsync(message);
}
catch (NotFoundException)
{
}
catch (UnauthorizedException)
{
}
}
}
// Log it if the log channel exists
DiscordChannel logChannel = guild.GetChannel(Config.logChannel);
if (logChannel != null)
{
DiscordEmbed logMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket " + ticketChannel.Mention + " opened by " + member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter {
Text = "Ticket " + ticketID
}
};
await logChannel.SendMessageAsync(logMessage);
}
}
internal async Task OnReactionAdded(MessageReactionAddEventArgs e)
{
if (e.Message.Id != Config.reactionMessage)
{
return;
}
DiscordGuild guild = e.Message.Channel.Guild;
DiscordMember member = await guild.GetMemberAsync(e.User.Id);
if (!Config.HasPermission(member, "new") || Database.IsBlacklisted(member.Id))
{
return;
}
DiscordChannel category = guild.GetChannel(Config.ticketCategory);
DiscordChannel ticketChannel = await guild.CreateChannelAsync("ticket", ChannelType.Text, category);
if (ticketChannel == null)
{
return;
}
ulong staffID = 0;
if (Config.randomAssignment)
{
staffID = Database.GetRandomActiveStaff(0)?.userID ?? 0;
}
long id = Database.NewTicket(member.Id, staffID, ticketChannel.Id);
string ticketID = id.ToString("00000");
await ticketChannel.ModifyAsync("ticket-" + ticketID);
await ticketChannel.AddOverwriteAsync(member, Permissions.AccessChannels, Permissions.None);
await ticketChannel.SendMessageAsync("Hello, " + member.Mention + "!\n" +
Config.welcomeMessage);
// Refreshes the channel as changes were made to it above
ticketChannel = await SupportBoi.GetClient().GetChannelAsync(ticketChannel.Id);
if (staffID != 0)
{
DiscordEmbed assignmentMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket was randomly assigned to <@" + staffID + ">."
};
await ticketChannel.SendMessageAsync("", false, assignmentMessage);
if (Config.assignmentNotifications)
{
DiscordEmbed message = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "You have been randomly assigned to a newly opened support ticket: " +
ticketChannel.Mention
};
try
{
DiscordMember staffMember = await guild.GetMemberAsync(staffID);
await staffMember.SendMessageAsync("", false, message);
}
catch (NotFoundException)
{
}
catch (UnauthorizedException)
{
}
}
}
// Log it if the log channel exists
DiscordChannel logChannel = guild.GetChannel(Config.logChannel);
if (logChannel != null)
{
DiscordEmbed logMessage = new DiscordEmbedBuilder
{
Color = DiscordColor.Green,
Description = "Ticket " + ticketChannel.Mention + " opened by " + member.Mention + ".\n",
Footer = new DiscordEmbedBuilder.EmbedFooter {
Text = "Ticket " + ticketID
}
};
await logChannel.SendMessageAsync("", false, logMessage);
}
// Adds the ticket to the google sheets document if enabled
Sheets.AddTicketQueued(member, ticketChannel, id.ToString(), staffID.ToString(),
Database.TryGetStaff(staffID, out Database.StaffMember staffMemberEntry)
? staffMemberEntry.userID.ToString()
: null);
}
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 RoleAssignment(DiscordMessage msgInv, CommandContext e, List <DiscordMember> players)
{
try
{
// Création de tous les channels sans Droit
var chsPerso = await Global.Game.Guild
.CreateChannelAsync(Global.Game.Texts.Channels.PersoGroup, ChannelType.Category);
Global.Game.DiscordChannels.Add(GameChannel.PersoGroup, chsPerso);
var wolfGrpChannel =
await Global.Game.Guild.CreateChannelAsync(Global.Game.Texts.Channels.WolvesChannel,
ChannelType.Category);
var townGrpChannel = await Global.Game.Guild
.CreateChannelAsync(Global.Game.Texts.Channels.TownChannel, ChannelType.Category);
var townTChannel =
await Guild.CreateChannelAsync(Texts.Channels.TownChannel, ChannelType.Text, townGrpChannel);
var townVChannel =
await Guild.CreateChannelAsync(Texts.Channels.TownChannel, ChannelType.Voice, townGrpChannel);
DiscordChannels.Add(GameChannel.TownText, townTChannel);
DiscordChannels.Add(GameChannel.TownVoice, townVChannel);
var wolfTChannel =
await Guild.CreateChannelAsync(Texts.Channels.WolvesChannel, ChannelType.Text, wolfGrpChannel);
var wolfVChannel =
await Guild.CreateChannelAsync(Texts.Channels.WolvesChannel, ChannelType.Voice, wolfGrpChannel);
DiscordChannels.Add(GameChannel.WolfText, wolfTChannel);
DiscordChannels.Add(GameChannel.WolfVoice, wolfVChannel);
var graveyardGrpChannel =
await Guild.CreateChannelAsync(Texts.Channels.GraveyardChannel, ChannelType.Category);
var graveyardTChannel = await Guild.CreateChannelAsync(Texts.Channels.GraveyardChannel,
ChannelType.Text, graveyardGrpChannel);
var graveyardVChannel = await Guild.CreateChannelAsync(Texts.Channels.GraveyardChannel,
ChannelType.Voice, graveyardGrpChannel);
await graveyardTChannel.AddOverwriteAsync(Global.Roles[PublicRole.Spectator], GameBuilder.UsrPerms);
DiscordChannels.Add(GameChannel.GraveyardText, graveyardTChannel);
DiscordChannels.Add(GameChannel.GraveyardVoice, graveyardVChannel);
foreach (var discordMember in Guild.Members)
{
if (discordMember.Roles.Contains(Global.Roles[PublicRole.Spectator]))
{
await graveyardVChannel.AddOverwriteAsync(discordMember,
GameBuilder.CreatePerms(Permissions.UseVoiceDetection, Permissions.UseVoice,
Permissions.Speak));
}
}
await GameBuilder.CreatePersonnages(players);
await(await e.Channel.GetMessageAsync(msgInv.Id)).ModifyAsync((await townTChannel.CreateInviteAsync())
.ToString());
Global.Client.MessageReactionAdded += GameBuilder.Spectator_ReactionAdd;
Global.Client.MessageReactionRemoved += GameBuilder.Spectator_ReactionRem;
}
catch (SystemException ex)
{
Console.WriteLine(ex);
}
}
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();
}
}
