C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Oxide.Core.Libraries.Covalence;
using Oxide.Core.Plugins;
using Oxide.Ext.Discord;
using Oxide.Ext.Discord.Attributes;
using Oxide.Ext.Discord.Constants;
using Oxide.Ext.Discord.Entities;
using Oxide.Ext.Discord.Entities.Applications;
using Oxide.Ext.Discord.Entities.Channels;
using Oxide.Ext.Discord.Entities.Gatway;
using Oxide.Ext.Discord.Entities.Gatway.Events;
using Oxide.Ext.Discord.Entities.Guilds;
using Oxide.Ext.Discord.Entities.Permissions;
using Oxide.Ext.Discord.Entities.Voice;
using Oxide.Ext.Discord.Libraries.Linking;
using Oxide.Ext.Discord.Logging;
namespace Oxide.Plugins
{
[Info("Discord Team", "Owned", "2.0.0")]
[Description("Creates a private voice channel in Discord when creating a team in-game")]
class DiscordTeam : CovalencePlugin
{
#region Plugin variables
[DiscordClient] private DiscordClient _client;
private DiscordRole role;
private Hash<string, DiscordChannel> listTeamChannels = new Hash<string, DiscordChannel>();
private confData config;
private bool _init;
private readonly DiscordSettings _settings = new DiscordSettings
{
Intents = GatewayIntents.Guilds | GatewayIntents.GuildMembers | GatewayIntents.GuildVoiceStates
};
private readonly DiscordLink _link = GetLibrary<DiscordLink>();
private DiscordGuild _guild;
#endregion
protected override void LoadDefaultConfig()
{
Config.WriteObject(new confData(),true);
}
public class confData
{
[JsonProperty("Discord Bot Token")]
public string Token = string.Empty;
[JsonProperty(PropertyName = "Discord Server ID (Optional if bot only in 1 guild)")]
public Snowflake GuildId { get; set; }
[JsonProperty("Change channel when user create the team")]
public bool moveLeader = true;
[JsonProperty("Discord users can see other team's private vocal channel")]
public bool seeOtherTeam = false;
[JsonProperty("Using roles")]
public bool roleUsage = false;
[JsonProperty("Name of the player's role on discord (not @everyone)")]
public string rolePlayer = "Player";
[JsonProperty("Max players in a voice channel")]
public int maxPlayersChannel = 3;
[JsonConverter(typeof(StringEnumConverter))]
[DefaultValue(DiscordLogLevel.Info)]
[JsonProperty(PropertyName = "Discord Extension Log Level (Verbose, Debug, Info, Warning, Error, Exception, Off)")]
public DiscordLogLevel ExtensionDebugging { get; set; } = DiscordLogLevel.Info;
}
protected override void LoadDefaultMessages()
{
lang.RegisterMessages(new Dictionary<string, string>
{
["messageChannelCreated"] = "A private voice channel was created on Discord for your team !",
["messageChannelDeleted"] = "Your private voice channel on Discord has been deleted !",
["messageMemberJoin"] = "You have been added to your team's private voice channel on Discord !",
["messageMemberLeft"] = "You have been removed from your team's private voice channel on Discord !",
["channelName"] = "{0}'s Team"
}, this);
lang.RegisterMessages(new Dictionary<string, string>
{
["messageChannelCreated"] = "Un salon vocal privé a été crée sur Discord pour votre équipe !",
["messageChannelDeleted"] = "Votre salon vocal privé sur Discord a été supprimé !",
["messageMemberJoin"] = "Vous avez été ajouté au salon vocal privé de votre équipe sur Discord !",
["messageMemberLeft"] = "Vous avez été retiré du salon vocal privé de votre équipe sur Discord !",
["channelName"] = "L'équipe de {0}"
}, this, "fr");
}
string GetMessage(string key, string steamId = null) => lang.GetMessage(key, this, steamId);
private void Init()
{
config = Config.ReadObject<confData>();
}
private void OnServerInitialized()
{
StartDiscordTeam();
}
private void StartDiscordTeam()
{
if (!string.IsNullOrEmpty(config.Token))
{
_settings.ApiToken = config.Token;
_settings.LogLevel = config.ExtensionDebugging;
_client.Connect(_settings);
}
else
{
PrintError("Discord Bot Token (API key) in the configuration file is missing");
}
}
[HookMethod(DiscordHooks.OnDiscordGatewayReady)]
private void OnDiscordGatewayReady(GatewayReadyEvent ready)
{
if (ready.Guilds.Count == 0)
{
PrintError("Your bot was not found in any discord servers.Please invite it to a server and reload the plugin.");
return;
}
DiscordGuild guild = null;
if (ready.Guilds.Count == 1 && !config.GuildId.IsValid())
{
guild = ready.Guilds.Values.FirstOrDefault();
}
if (guild == null)
{
guild = ready.Guilds[config.GuildId];
}
if (guild == null)
{
PrintError("Failed to find a matching guild for the Discord Server Id." +
"Please make sure your guild Id is correct and the bot is in the discord server.");
return;
}
if (!_client.Bot.Application.Flags.HasValue || !_client.Bot.Application.Flags.Value.HasFlag(ApplicationFlags.GatewayGuildMembersLimited))
{
PrintError($"You need to enable \"Server Members Intent\" for {_client.Bot.BotUser.Username} @ https://discord.com/developers/applications\n" +
$"{Name} will not function correctly until that is fixed.Once updated please reload {Name}.");
return;
}
_guild = guild;
if(config.roleUsage)
{
if(string.IsNullOrEmpty(config.rolePlayer))
{
PrintError("The role specified in the configuration file is missing");
return;
}
}
Puts("Discord Team initialized");
_init = true;
initializeTeam();
}
void Unload()
{
if(_init)
{
if(listTeamChannels.Count > 0)
{
foreach(var leaderGameId in listTeamChannels)
{
deleteChannel(listTeamChannels[leaderGameId.Key]);
}
listTeamChannels.Clear();
}
}
}
private void OnUserConnected(IPlayer player)
{
if(_init)
{
string info = GetDiscord(player.Id);
if (info == null)
{
return;
}
else
{
BasePlayer basePlayer = player.Object as BasePlayer;
var currentTeam = basePlayer.currentTeam;
if(currentTeam != 0)
{
RelationshipManager.PlayerTeam team = RelationshipManager.ServerInstance.FindTeam(currentTeam);
string leaderId = team.teamLeader.ToString();
if(listTeamChannels[leaderId] != null)
{
if(basePlayer.UserIDString != leaderId)
{
addPlayerChannel(basePlayer, listTeamChannels[leaderId]);
}
}
else
{
if(basePlayer.UserIDString == leaderId)
{
CreateChannelGuild(basePlayer);
}
}
}
}
}
}
object OnTeamCreate(BasePlayer player)
{
if(_init)
{
string info = GetDiscord(player.UserIDString);
if(info != null)
{
CreateChannelGuild(player);
}
}
return null;
}
object OnTeamPromote(RelationshipManager.PlayerTeam team, BasePlayer newLeader)
{
if(_init)
{
string info = GetDiscord(newLeader.UserIDString);
if(info != null)
{
string newLeaderId = newLeader.UserIDString;
string oldLeaderId = team.teamLeader.ToString();
if(listTeamChannels[oldLeaderId] != null)
{
listTeamChannels[newLeaderId] = listTeamChannels[oldLeaderId];
listTeamChannels.Remove(oldLeaderId);
renameChannel(listTeamChannels[newLeaderId], newLeader);
}
}
}
return null;
}
object OnTeamLeave(RelationshipManager.PlayerTeam team, BasePlayer player)
{
if(_init)
{
string info = GetDiscord(player.UserIDString);
if(info != null)
{
string leaderId = team.teamLeader.ToString();
if(listTeamChannels[leaderId] != null)
{
if(leaderId != player.UserIDString)
{
removePlayerChannel(player, listTeamChannels[leaderId]);
}
}
}
}
return null;
//quit channel
}
object OnTeamKick(RelationshipManager.PlayerTeam team, BasePlayer player)
{
if(_init)
{
string info = GetDiscord(player.UserIDString);
if(info != null)
{
string leaderId = team.teamLeader.ToString();
if(listTeamChannels[leaderId] != null)
{
removePlayerChannel(player, listTeamChannels[leaderId]);
}
}
}
return null;
}
object OnTeamAcceptInvite(RelationshipManager.PlayerTeam team, BasePlayer player)
{
if(_init)
{
string info = GetDiscord(player.UserIDString);
if(info != null)
{
string leaderId = team.teamLeader.ToString();
if(listTeamChannels[leaderId] != null)
{
addPlayerChannel(player, listTeamChannels[leaderId]);
}
}
}
return null;
}
void OnTeamDisbanded(RelationshipManager.PlayerTeam team)
{
if(_init)
{
string leaderId = team.teamLeader.ToString();
var player = team.GetLeader();
if(listTeamChannels[leaderId] != null)
{
deleteChannel(listTeamChannels[leaderId]);
listTeamChannels.Remove(leaderId);
if(player != null)
{
player.ChatMessage(GetMessage("messageChannelDeleted", leaderId));
}
}
}
}
public void CreateChannelGuild(BasePlayer player)
{
Snowflake discordId = GetDiscord(player.UserIDString);
if(discordId.IsValid())
{
string playerId = player.UserIDString;
List<Overwrite> permissionList = new List<Overwrite>();
DiscordRole rolePlayer;
if(config.roleUsage)
{
rolePlayer = GetRoleByName(config.rolePlayer);
DiscordRole roleEveryone = _guild.EveryoneRole;
permissionList.Add(new Overwrite {Id = roleEveryone.Id,Type = PermissionType.Role ,Deny = (PermissionFlags)66061568});
}
else
{
rolePlayer = _guild.EveryoneRole;
}
if(config.seeOtherTeam)
{
permissionList.Add(new Overwrite {Id = rolePlayer.Id,Type = PermissionType.Role,Allow = (PermissionFlags)1024,Deny = (PermissionFlags)66060544});
}
else
{
permissionList.Add(new Overwrite {Id = rolePlayer.Id,Type = PermissionType.Role,Deny = (PermissionFlags)66060544});
}
permissionList.Add(new Overwrite {Id = discordId,Type =PermissionType.Member, Allow = (PermissionFlags)36701184});
GuildMember guildMember = GetGuildMember(player.UserIDString);
_guild.CreateGuildChannel(_client, new ChannelCreate
{
Name = string.Format(GetMessage("channelName", playerId), player.displayName),
Type = ChannelType.GuildVoice,
UserLimit = config.maxPlayersChannel,
PermissionOverwrites = permissionList
},
channelCreated =>
{
listTeamChannels[playerId] = channelCreated;
if(config.moveLeader)
{
_guild.ModifyGuildMember(_client, guildMember.Id, new GuildMemberUpdate
{
ChannelId = channelCreated.Id
});
}
player.ChatMessage(GetMessage("messageChannelCreated", player.UserIDString));
});
}
}
public void addPlayerChannel(BasePlayer player, DiscordChannel channel)
{
Snowflake discordId = GetDiscord(player.UserIDString);
if(discordId.IsValid())
{
channel.EditChannelPermissions(_client, discordId, (PermissionFlags)36701184, null, PermissionType.Member);
player.ChatMessage(GetMessage("messageMemberJoin", player.UserIDString));
}
}
public void removePlayerChannel(BasePlayer player, DiscordChannel channel)
{
Snowflake discordId = GetDiscord(player.UserIDString);
if(discordId.IsValid())
{
string playerId = player.UserIDString;
GuildMember guildMember = GetGuildMember(playerId);
GuildMemberUpdate update = new GuildMemberUpdate();
VoiceState playerVoice = _guild.VoiceStates[guildMember.Id];
if (playerVoice?.ChannelId != null && playerVoice.ChannelId != channel.Id)
{
update.ChannelId = playerVoice.ChannelId;
}
_guild.ModifyGuildMember(_client, guildMember.Id, update);
if(config.seeOtherTeam)
{
channel.EditChannelPermissions(_client, discordId, (PermissionFlags)1024, (PermissionFlags)66060544, PermissionType.Member);
}
else
{
channel.EditChannelPermissions(_client, discordId, null, (PermissionFlags)66060544, PermissionType.Member);
}
player.ChatMessage(GetMessage("messageMemberLeft", player.UserIDString));
}
}
public void initializeTeam()
{
if(_init)
{
foreach (var player in BasePlayer.activePlayerList)
{
if(player.currentTeam != 0)
{
RelationshipManager.PlayerTeam team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
string leaderId = team.teamLeader.ToString();
if(leaderId == player.UserIDString)
{
if(listTeamChannels[leaderId] != null)
{
foreach (var teamMember in team.members)
{
if(teamMember.ToString() != leaderId)
{
string discordId = GetDiscord(player.UserIDString);
if(discordId != null)
{
BasePlayer member = RelationshipManager.FindByID(teamMember);
if(member != null)
{
addPlayerChannel(member, listTeamChannels[leaderId]);
}
}
}
}
}
else
{
string discordId = GetDiscord(player.UserIDString);
if(discordId != null)
{
CreateChannelGuild(player);
}
}
}
}
}
}
}
#region Discord functions
public void deleteChannel(DiscordChannel channel)
{
channel.DeleteChannel(_client);
}
public void renameChannel(DiscordChannel channel, BasePlayer newLeader)
{
channel.ModifyGuildChannel(_client, new GuildChannelUpdate
{
Name = string.Format(GetMessage("channelName", newLeader.UserIDString), newLeader.displayName)
});
}
public DiscordRole GetRoleByName(string roleName)
{
return _guild.GetRole(roleName);
}
private Snowflake GetDiscord(string steamId)
{
return _link.GetDiscordId(steamId) ?? default(Snowflake);
}
public GuildMember GetGuildMember(string steamId)
{
Snowflake discordId = GetDiscord(steamId);
if(discordId.IsValid())
{
return _guild.Members[discordId];
}
return null;
}
#endregion
}
}