C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using System;
using System.Linq;
using System.Collections.Generic;
using Oxide.Core;
using Oxide.Core.Plugins;
using Oxide.Core.Configuration;
using Oxide.Core.Libraries.Covalence;
using Oxide.Game.Rust.Cui;
using UnityEngine;
namespace Oxide.Plugins {
[Info("Permission Effects", "noname", "1.1.1")]
[Description("Enhance the permission system by abstracting Oxide permission system")]
class PermissionEffects : CovalencePlugin {
[PluginReference]
private Plugin PlaytimeTracker, UIScaleManager;
public static PermissionEffects Plugin;
public static string permissioneffects_admin_perm_admin_perm = "permissioneffects.admin";
#region GUIField
Dictionary<string, Timer> PlayersViewingUi = new Dictionary<string, Timer>();
string CursorUIPanel = "CursorUIPanel";
string UIBaseInvPanel = "UIBaseInvPanel";
string UIBasePanel = "UIBasePanel";
string BackGroundPanel = "BackGroundPanel";
string UIBaseBtnPanel = "UIBaseBtnPanel";
string UIPMBtn = "UIPMBtn";
string ESBtn = "ESBtn";
#endregion
#region Hooks
private new void LoadDefaultConfig() {
PrintWarning("Creating a new configuration file");
Config.WriteObject(GetDefaultConfig(), true);
}
private void Init() {
LoadConfig();
LoadPlayersData();
LoadGroupsData();
LoadThreadsData();
LoadPlayersGUIData();
}
void OnServerSave() {
puts("Saving Permission Effects DataFile...");
SavePlayersData();
SaveGroupsData();
SaveThreadsData();
SavePlayersGUIData();
}
void Unload() {
puts("Saving Permission Effects DataFile...");
SavePlayersData();
SaveGroupsData();
SaveThreadsData();
SavePlayersGUIData();
PlayersRemoveBaseinvUI();
Plugin = null;
}
private void OnServerInitialized() {
Plugin = this;
RegisterPermissions();
RegisterCommands();
StartTimer();
playersUIData.ResetOnlinePlayersData();
PlayersAddBaseinvUI();
RegisterTestEffects();
}
private void OnPlayerConnected(BasePlayer player) {
if (player.IsNpc) return;
playersUIData.ResetPlayerData(player);
timer.Once(5f, () => {
PlayerAddBaseinvUI(player);
UpdatePlayerGUI(player);
}
);
}
#endregion
#region Classes
#region BaseThread
private enum PlayerThreadType {
BasePlayerEffectThread, EffectThread, RealtimeEffectThread, PlaytimeEffectThread
}
private enum DataThreadType {
BaseDataEffectThread, EffectThreadData, RealtimeEffectThreadData, PlaytimeEffectThreadData
}
private class BasePlayerEffectThread : IEquatable<BasePlayerEffectThread> {
public PlayerThreadType PlayerThreadType {
get;
set;
}
public string ThreadName {
get;
set;
}
public string ThreadColor {
get;
set;
}
public List<string> Permissions {
get;
set;
}
public DateTime DisconnectAutoExpireDate {
get;
set;
}
public TimeSpan? DisconnectAutoExpireTime {
get;
set;
}
public DateTime ExpireDate {
get;
set;
}
public TimeSpan ExpireTime {
get;
set;
}
public BasePlayerEffectThread() {
PlayerThreadType = PlayerThreadType.BasePlayerEffectThread;
}
public bool Equals(BasePlayerEffectThread other) {
return other != null && ThreadName == other.ThreadName && ThreadColor == other.ThreadColor && PlayerThreadType == other.PlayerThreadType;
}
public override bool Equals(object obj) {
var other = obj as BasePlayerEffectThread;
return other != null && ThreadName == other.ThreadName && ThreadColor == other.ThreadColor && PlayerThreadType == other.PlayerThreadType;
}
public override int GetHashCode() {
var hashCode = 909284198;
hashCode = hashCode * -1521134295 + PlayerThreadType.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(ThreadName);
hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(ThreadColor);
return hashCode;
}
public void GrantUserPermissions(string id) {
foreach (var item in Permissions) {
Plugin.permission.GrantUserPermission(id, item, null);
}
}
public void GrantGroupPermissions(string groupName) {
foreach (var item in Permissions) {
Plugin.permission.GrantGroupPermission(groupName, item, null);
}
}
public void RevokeUserPermissions(string id, Dictionary<string, BasePlayerEffectThread> PlayerEffectThreads) {
foreach (var item in Permissions) {
bool OthersContains = false;
foreach (var item2 in PlayerEffectThreads) {
if (item2.Value.ThreadName != ThreadName && item2.Value.Permissions.Contains(item)) {
OthersContains = true;
break;
}
}
if (OthersContains == false) Plugin.permission.RevokeUserPermission(id, item);
}
}
public void RevokeUserPermissions(string id) {
foreach (var item in Permissions) {
Plugin.permission.RevokeUserPermission(id, item);
}
}
public void RevokeGroupPermissions(string groupName, Dictionary<string, BasePlayerEffectThread> PlayerEffectThreads) {
foreach (var item in Permissions) {
bool OthersContains = false;
foreach (var item2 in PlayerEffectThreads) {
if (item2.Value.ThreadName != ThreadName && item2.Value.Permissions.Contains(item)) {
OthersContains = true;
break;
}
}
if (OthersContains == false) Plugin.permission.RevokeGroupPermission(groupName, item);
}
}
public void RevokeGroupPermissions(string groupName) {
foreach (var item in Permissions) {
Plugin.permission.RevokeGroupPermission(groupName, item);
}
}
}
private class BaseDataEffectThread {
public DataThreadType DataThreadType {
get;
set;
}
public string ThreadName {
get;
set;
}
public string ThreadColor {
get;
set;
}
public List<string> Permissions {
get;
set;
}
public TimeSpan? DisconnectAutoExpireTime {
get;
set;
}
public TimeSpan ExpireTime {
get;
set;
}
public BaseDataEffectThread() {
DataThreadType = DataThreadType.BaseDataEffectThread;
}
public BasePlayerEffectThread ToPlayerEffectThread(string PlayerID) {
switch (DataThreadType) {
case DataThreadType.BaseDataEffectThread : return new EffectThread(ThreadName, ThreadColor, Permissions, DisconnectAutoExpireTime);
case DataThreadType.EffectThreadData : return new EffectThread(ThreadName, ThreadColor, Permissions, DisconnectAutoExpireTime);
case DataThreadType.RealtimeEffectThreadData : return new RealtimeEffectThread(ThreadName, ThreadColor, Permissions, DisconnectAutoExpireTime, ExpireTime);
case DataThreadType.PlaytimeEffectThreadData : return new PlaytimeEffectThread(ThreadName, ThreadColor, Permissions, DisconnectAutoExpireTime, ExpireTime, PlayerID);
default : return null;
}
}
}
#endregion
#region PlayerThread
private class EffectThread : BasePlayerEffectThread {
public EffectThread() {
PlayerThreadType = PlayerThreadType.EffectThread;
}
public EffectThread(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme) //default
{
PlayerThreadType = PlayerThreadType.EffectThread;
ThreadName = threadName;
ThreadColor = threadColor;
Permissions = permissions;
if (AutoExpireTIme != null) DisconnectAutoExpireDate = DateTime.Now + (TimeSpan)AutoExpireTIme;
DisconnectAutoExpireTime = AutoExpireTIme;
}
}
private class RealtimeEffectThread : EffectThread {
public RealtimeEffectThread() {
PlayerThreadType = PlayerThreadType.RealtimeEffectThread;
}
public RealtimeEffectThread(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme, TimeSpan expireTime) //realtime
: base(threadName, threadColor, permissions, AutoExpireTIme) {
PlayerThreadType = PlayerThreadType.RealtimeEffectThread;
ExpireDate = DateTime.Now + expireTime;
}
}
private class PlaytimeEffectThread : EffectThread {
public PlaytimeEffectThread() {
PlayerThreadType = PlayerThreadType.PlaytimeEffectThread;
}
public PlaytimeEffectThread(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme, TimeSpan expireTime, string PlayerID) //playtime
: base(threadName, threadColor, permissions, AutoExpireTIme) {
PlayerThreadType = PlayerThreadType.PlaytimeEffectThread;
TimeSpan? PlayerPlaytime = Plugin.GetPlayerPlaytime(PlayerID);
if (PlayerPlaytime == null) {
ExpireTime = new TimeSpan();
}
else {
ExpireTime = (TimeSpan)PlayerPlaytime + expireTime;
}
}
}
#endregion
#region DataThread
private class EffectThreadData : BaseDataEffectThread {
public EffectThreadData() {
DataThreadType = DataThreadType.EffectThreadData;
}
public EffectThreadData(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme) {
DataThreadType = DataThreadType.EffectThreadData;
ThreadName = threadName;
ThreadColor = threadColor;
Permissions = permissions;
DisconnectAutoExpireTime = AutoExpireTIme;
}
}
private class RealtimeEffectThreadData : EffectThreadData {
public RealtimeEffectThreadData() {
DataThreadType = DataThreadType.RealtimeEffectThreadData;
}
public RealtimeEffectThreadData(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme, TimeSpan expireTime) : base(threadName, threadColor, permissions, AutoExpireTIme) {
DataThreadType = DataThreadType.RealtimeEffectThreadData;
ExpireTime = expireTime;
}
}
private class PlaytimeEffectThreadData : EffectThreadData {
public PlaytimeEffectThreadData() {
DataThreadType = DataThreadType.PlaytimeEffectThreadData;
}
public PlaytimeEffectThreadData(string threadName, string threadColor, List<string> permissions, TimeSpan? AutoExpireTIme, TimeSpan expireTime) : base(threadName, threadColor, permissions, AutoExpireTIme) {
DataThreadType = DataThreadType.PlaytimeEffectThreadData;
ExpireTime = expireTime;
}
}
#endregion
#endregion
#region PluginIO
#region ConfigManage
private PluginConfig config;
private new void LoadConfig() {
config = Config.ReadObject<PluginConfig>();
if (config == null) config = GetDefaultConfig();
VersionUpdate(config);
}
private void VersionUpdate(PluginConfig config) {
if (config.ConfigVersion < new VersionNumber(1, 0, 5)) {
config.UIPosions = GetUIPosionConfig();
}
if (config.ConfigVersion < this.Version) {
config.ConfigVersion = this.Version;
Config.WriteObject(config, true);
Puts("Config version has been updated");
}
}
private class PluginConfig {
public bool use_BroadCast;
public bool use_Message;
public bool use_ConsoleMessage;
public int UIUpdateTimerInterval;
public int TimeLimitTimerInterval;
public int DisconnectDetectTimerInterval;
public string EPSCommand;
public string EffectCommand;
public Dictionary<int, Posion> UIPosions;
public class Posion {
public float YAnchorMax;
public float YAnchorMin;
public float XAnchorMax;
public float XAnchorMin;
}
public VersionNumber ConfigVersion;
}
private PluginConfig GetDefaultConfig() {
PluginConfig pluginConfig = new PluginConfig {
use_BroadCast = false, use_Message = true, use_ConsoleMessage = true, UIUpdateTimerInterval = 4, TimeLimitTimerInterval = 4, DisconnectDetectTimerInterval = 10, EPSCommand = "eps", EffectCommand = "effect", ConfigVersion = this.Version
}
;
pluginConfig.UIPosions = GetUIPosionConfig();
return pluginConfig;
}
private Dictionary<int, PluginConfig.Posion> GetUIPosionConfig() {
return new Dictionary<int, PluginConfig.Posion> {
{
10, new PluginConfig.Posion() {
YAnchorMax = 0.11f, YAnchorMin = 0.11f, XAnchorMax = 0.6395f, XAnchorMin = 0.3445f
}
}
, {
8, new PluginConfig.Posion() {
YAnchorMax = 0.11f, YAnchorMin = 0.11f, XAnchorMax = 0.6105f, XAnchorMin = 0.375f
}
}
, {
6, new PluginConfig.Posion() {
YAnchorMax = 0.11f, YAnchorMin = 0.11f, XAnchorMax = 0.5825f, XAnchorMin = 0.4056f
}
}
}
;
}
#endregion
#region DataManage
#region PlayersData
DynamicConfigFile playersdataFile = Interface.Oxide.DataFileSystem.GetDatafile("PermissionEffects/PlayerData");
PlayersData playersData;
private void LoadPlayersData() {
playersData = playersdataFile.ReadObject<PlayersData>();
if (playersData == null) playersData = new PlayersData();
}
private void SavePlayersData() {
playersdataFile.WriteObject(playersData);
}
private class PlayersData {
public Dictionary<string, PlayerInfo> Players {
get;
set;
}
public PlayersData() {
Players = new Dictionary<string, PlayerInfo>();
}
public void ResetData(IPlayer player) {
foreach (var item in Players) {
foreach (var EffectThread in item.Value.PlayerEffectThreads) {
EffectThread.Value.RevokeUserPermissions(item.Value.Id);
}
}
Players.Clear();
Plugin.UpdatePlayersGUI();
Plugin.SendReplyMessage(player, Plugin.Lang("Reseted PlayersData", player?.Id));
}
public void UpdatePlayers() {
List<string> ClonedUsersKey = new List<string>();
foreach (var item in Players) {
ClonedUsersKey.Add(item.Key);
}
foreach (var item in ClonedUsersKey) {
Players[item].UpdateEffects();
}
}
public void AddEffectToPlayer(IPlayer target, IPlayer player, string EffectThreadName) {
if (Players.ContainsKey(target.Id) == false) {
Players.Add(target.Id, new PlayerInfo(target));
}
Players[target.Id].AddEffect(EffectThreadName, player);
}
public void DeleteEffectFromPlayer(IPlayer target, IPlayer player, string EffectThreadName) {
if (Players.ContainsKey(target.Id) == false) {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Player", player?.Id, EffectThreadName));
return;
}
Players[target.Id].DeleteEffect(EffectThreadName, player);
}
public void DeleteEffectFromPlayer(string target, IPlayer player, string EffectThreadName) {
if (Players.ContainsKey(target) == false) {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Player", player?.Id, EffectThreadName));
return;
}
Players[target].DeleteEffect(EffectThreadName, player);
}
public void DeleteAllEffectFromPlayer(IPlayer target, IPlayer player) {
if (Players.ContainsKey(target.Id) == false) {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Player", player?.Id, "All"));
return;
}
Players[target.Id].DeleteAllEffect(player);
}
public bool PlayerHasEffect(string playerId, string effectThreadName) {
if (playerId.IsSteamId() == false) {
return false;
}
if (Players.ContainsKey(playerId) == false) {
return false;
}
PlayerInfo playerInfo = Players[playerId];
if (playerInfo.PlayerEffectThreads.ContainsKey(effectThreadName)) {
if (playerInfo.PlayerEffectThreads[effectThreadName].PlayerThreadType == PlayerThreadType.PlaytimeEffectThread && Plugin.PlaytimeTracker == null) {
return false;
}
else {
return true;
}
}
else {
foreach (string Groupname in Plugin.permission.GetUserGroups(playerId)) {
if (Plugin.groupsData.GroupHasEffect(Groupname, effectThreadName) == true) {
return true;
}
}
return false;
}
}
public TimeSpan? GetPlayerEffectLeftTime(string playerId, string effectThreadName) {
if (Players.ContainsKey(playerId) == false) {
return null;
}
PlayerInfo playerInfo = Players[playerId];
TimeSpan EffectLeftTime = new TimeSpan(0, 0, 0);
if (playerInfo.PlayerEffectThreads.ContainsKey(effectThreadName)) {
BasePlayerEffectThread baseEffectThread = playerInfo.PlayerEffectThreads[effectThreadName];
switch (baseEffectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : EffectLeftTime = TimeSpan.FromSeconds(-1);
break;
case PlayerThreadType.RealtimeEffectThread : EffectLeftTime = baseEffectThread.ExpireDate.Subtract(DateTime.Now);
break;
case PlayerThreadType.PlaytimeEffectThread : TimeSpan? PlayerPlaytime = Plugin.GetPlayerPlaytime(playerId);
if (PlayerPlaytime == null) {
break;
}
EffectLeftTime = baseEffectThread.ExpireTime - (TimeSpan)PlayerPlaytime;
break;
default : break;
}
}
string[] userGroups = Plugin.permission.GetUserGroups(playerId);
if (userGroups.Length == 0) {
return EffectLeftTime;
}
foreach (string Groupname in userGroups) {
if (Plugin.groupsData.Groups.ContainsKey(Groupname) == false) continue;
var Group = Plugin.groupsData.Groups[Groupname];
if (Group.PlayerEffectThreads.ContainsKey(effectThreadName)) {
BasePlayerEffectThread baseEffectThread = Group.PlayerEffectThreads[effectThreadName];
switch (baseEffectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : if (TimeSpan.FromSeconds(-1) > EffectLeftTime) EffectLeftTime = TimeSpan.FromSeconds(-1);
return EffectLeftTime;
case PlayerThreadType.RealtimeEffectThread : TimeSpan LeftTime = baseEffectThread.ExpireDate.Subtract(DateTime.Now);
if (LeftTime > EffectLeftTime) EffectLeftTime = LeftTime;
return EffectLeftTime;
default : break;
}
}
}
return null;
}
}
private class PlayerInfo {
public string Id {
get;
set;
}
public string Name {
get;
set;
}
public Dictionary<string, BasePlayerEffectThread> PlayerEffectThreads {
get;
set;
}
public PlayerInfo() {
}
public PlayerInfo(IPlayer player) {
Id = player.Id;
Name = player.Name;
PlayerEffectThreads = new Dictionary<string, BasePlayerEffectThread>();
}
public void UpdateEffects() {
List<BasePlayerEffectThread> DeleteThreads = new List<BasePlayerEffectThread>();
var PlayerEffectThreadsList = PlayerEffectThreads.ToList();
for (int j = 0; j < PlayerEffectThreadsList.Count; j++) {
BasePlayerEffectThread effectThread = PlayerEffectThreadsList[j].Value;
switch (effectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : break;
case PlayerThreadType.RealtimeEffectThread : DateTime dt = effectThread.ExpireDate;
DateTime dtnow = DateTime.Now;
if (DateTime.Compare(dt, dtnow) <= 0) {
DeleteThreads.Add(effectThread);
}
break;
case PlayerThreadType.PlaytimeEffectThread : if (Plugin.PlaytimeTracker == null) {
break;
}
TimeSpan? PlayerPlaytime = Plugin.GetPlayerPlaytime(Id);
if (PlayerPlaytime != null && PlayerPlaytime > effectThread.ExpireTime) {
DeleteThreads.Add(effectThread);
}
break;
default : break;
}
}
foreach (var item in DeleteThreads) {
DeleteEffect(item.ThreadName, null);
}
}
public void UpdateEffect(string EffectName) {
if (PlayerEffectThreads.ContainsKey(EffectName) == false) return;
BasePlayerEffectThread effectThread = PlayerEffectThreads[EffectName];
switch (effectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : break;
case PlayerThreadType.RealtimeEffectThread : DateTime dt = effectThread.ExpireDate;
DateTime dtnow = DateTime.Now;
if (DateTime.Compare(dt, dtnow) <= 0) {
DeleteEffect(EffectName, null);
}
break;
case PlayerThreadType.PlaytimeEffectThread : if (Plugin.PlaytimeTracker == null) {
break;
}
TimeSpan? PlayerPlaytime = Plugin.GetPlayerPlaytime(Id);
if (PlayerPlaytime != null && PlayerPlaytime > effectThread.ExpireTime) {
DeleteEffect(EffectName, null);
}
break;
default : break;
}
}
public void AddEffect(string EffectThreadName, IPlayer player) {
if (Plugin.registeredThreads.DataEffectThreads.ContainsKey(EffectThreadName)) {
if (PlayerEffectThreads.ContainsKey(EffectThreadName)) {
BaseDataEffectThread regeffectThread = Plugin.registeredThreads.DataEffectThreads[EffectThreadName];
if (regeffectThread.DataThreadType == DataThreadType.PlaytimeEffectThreadData && Plugin.PlaytimeTracker == null) {
Plugin.SendChatMessage(player, Plugin.Lang("PlaytimeTracker not Found", player?.Id));
return;
}
BasePlayerEffectThread effectThread = regeffectThread.ToPlayerEffectThread(Id);
PlayerEffectThreads[EffectThreadName] = effectThread;
effectThread.GrantUserPermissions(Id);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectOverwrittedConsoleNotice", player?.Id, EffectThreadName, Name));
Plugin.SendChatMessage(Plugin.GetPlayer(Id), Plugin.Lang("EffectOverwrittedNotice", player?.Id, EffectThreadName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectOverwrittedConsoleNotice", player?.Id, EffectThreadName, Name));
}
else {
BaseDataEffectThread regeffectThread = Plugin.registeredThreads.DataEffectThreads[EffectThreadName];
if (regeffectThread.DataThreadType == DataThreadType.PlaytimeEffectThreadData && Plugin.PlaytimeTracker == null) {
Plugin.SendChatMessage(player, Plugin.Lang("PlaytimeTracker not Found", player?.Id));
return;
}
BasePlayerEffectThread effectThread = regeffectThread.ToPlayerEffectThread(Id);
PlayerEffectThreads.Add(EffectThreadName, effectThread);
effectThread.GrantUserPermissions(Id);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectAddedConsoleNotice", player?.Id, EffectThreadName, Name));
Plugin.SendChatMessage(Plugin.GetPlayer(Id), Plugin.Lang("EffectAddedNotice", player?.Id, EffectThreadName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectAddedConsoleNotice", player?.Id, EffectThreadName, Name));
}
Plugin.UpdatePlayerGUI(Id);
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist", player?.Id, EffectThreadName));
}
}
public void DeleteEffect(string EffectThreadName, IPlayer player) {
if (PlayerEffectThreads.ContainsKey(EffectThreadName)) {
PlayerEffectThreads[EffectThreadName].RevokeUserPermissions(Id, PlayerEffectThreads);
PlayerEffectThreads.Remove(EffectThreadName);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectRemovedConsoleNotice", player?.Id, EffectThreadName, Name));
Plugin.SendChatMessage(Plugin.GetPlayer(Id), Plugin.Lang("EffectRemovedNotice", player?.Id, EffectThreadName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectRemovedConsoleNotice", player?.Id, EffectThreadName, Name));
Plugin.UpdatePlayersGUI();
if (PlayerEffectThreads.Count == 0) {
Plugin.playersData.Players.Remove(Id);
}
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Player", player?.Id, EffectThreadName));
}
}
public void DeleteAllEffect(IPlayer player) {
if (PlayerEffectThreads.Count == 0) {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Player", player?.Id, "All"));
return;
}
else {
foreach (var item in PlayerEffectThreads) {
item.Value.RevokeUserPermissions(Id);
}
Plugin.playersData.Players.Remove(Id);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectRemovedConsoleNotice", player?.Id, "All", Name));
Plugin.SendChatMessage(Plugin.GetPlayer(Id), Plugin.Lang("EffectRemovedNotice", player?.Id, "All"));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectRemovedConsoleNotice", player?.Id, "All", Name));
Plugin.UpdatePlayerGUI(Id);
}
}
}
#endregion
#region GroupsData
DynamicConfigFile groupsdataFile = Interface.Oxide.DataFileSystem.GetDatafile("PermissionEffects/GroupData");
GroupsData groupsData;
private void LoadGroupsData() {
groupsData = groupsdataFile.ReadObject<GroupsData>();
if (groupsData == null) groupsData = new GroupsData();
}
private void SaveGroupsData() {
groupsdataFile.WriteObject(groupsData);
}
private class GroupsData {
public Dictionary<string, GroupInfo> Groups {
get;
set;
}
public GroupsData() {
Groups = new Dictionary<string, GroupInfo>();
}
public void ResetData(IPlayer player) {
foreach (var item in Groups) {
foreach (var EffectThread in item.Value.PlayerEffectThreads) {
EffectThread.Value.RevokeGroupPermissions(item.Value.GroupName);
}
}
Groups.Clear();
Plugin.UpdatePlayersGUI();
Plugin.SendReplyMessage(player, Plugin.Lang("Reseted GroupsData", player?.Id));
}
public void UpdateGroup() {
List<string> ClonedGroupKey = new List<string>();
foreach (var item in Groups) {
ClonedGroupKey.Add(item.Key);
}
var permissionGroups = Plugin.permission.GetGroups();
foreach (var item in ClonedGroupKey) {
Groups[item].UpdateEffects();
}
foreach (var item in ClonedGroupKey) {
if (permissionGroups.Contains(item) == false) {
if (Groups.ContainsKey(item)) Groups.Remove(item);
}
}
}
public void AddEffectToGroup(string GroupName, IPlayer player, string EffectThreadName) {
if (Plugin.permission.GroupExists(GroupName) == false) {
Plugin.SendReplyMessage(player, Plugin.Lang("GroupNotExist", player?.Id, GroupName));
return;
}
if (Groups.ContainsKey(GroupName) == false) {
Groups.Add(GroupName, new GroupInfo(GroupName));
}
Groups[GroupName].AddEffect(EffectThreadName, player);
}
public void DeleteEffectFromGroup(string GroupName, IPlayer player, string EffectThreadName) {
if (Plugin.permission.GroupExists(GroupName) == false) {
Groups.Remove(GroupName);
}
if (Groups.ContainsKey(GroupName) == false) {
return;
}
Groups[GroupName].DeleteEffect(EffectThreadName, player);
}
public void DeleteAllEffectFromGroup(string GroupName, IPlayer player) {
if (Groups.ContainsKey(GroupName) == false) {
Plugin.SendReplyMessage(player, Plugin.Lang("GroupNotExist", player?.Id, GroupName));
return;
}
Groups[GroupName].DeleteAllEffect(player);
}
public bool GroupHasEffect(string groupName, string effectThreadName) {
if (Groups.ContainsKey(groupName) == false) {
return false;
}
GroupInfo groupInfo = Groups[groupName];
if (groupInfo.PlayerEffectThreads.ContainsKey(effectThreadName)) {
return true;
}
else {
return false;
}
}
public TimeSpan? GetGroupEffectLeftTime(string groupName, string effectThreadName) {
if (Plugin.groupsData.Groups.ContainsKey(groupName) == false) return null;
var Group = Plugin.groupsData.Groups[groupName];
if (Group.PlayerEffectThreads.ContainsKey(effectThreadName)) {
BasePlayerEffectThread baseEffectThread = Group.PlayerEffectThreads[effectThreadName];
switch (baseEffectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : return TimeSpan.FromSeconds(-1);
case PlayerThreadType.RealtimeEffectThread : TimeSpan LeftTime = baseEffectThread.ExpireDate.Subtract(DateTime.Now);
return LeftTime;
default : break;
}
}
return null;
}
}
private class GroupInfo {
public string GroupName {
get;
set;
}
public Dictionary<string, BasePlayerEffectThread> PlayerEffectThreads {
get;
set;
}
public GroupInfo() {
}
public GroupInfo(string groupName) {
GroupName = groupName;
PlayerEffectThreads = new Dictionary<string, BasePlayerEffectThread>();
}
public void UpdateEffects() {
List<BasePlayerEffectThread> DeleteThreads = new List<BasePlayerEffectThread>();
var PlayerEffectThreadsList = PlayerEffectThreads.ToList();
for (int j = 0; j < PlayerEffectThreadsList.Count; j++) {
BasePlayerEffectThread effectThread = PlayerEffectThreadsList[j].Value;
switch (effectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : break;
case PlayerThreadType.RealtimeEffectThread : DateTime dt = effectThread.ExpireDate;
DateTime dtnow = DateTime.Now;
if (DateTime.Compare(dt, dtnow) <= 0) {
DeleteThreads.Add(effectThread);
}
break;
default : break;
}
}
foreach (var item in DeleteThreads) {
DeleteEffect(item.ThreadName, null);
}
}
public void UpdateEffect(string EffectName) {
if (PlayerEffectThreads.ContainsKey(EffectName) == false) return;
BasePlayerEffectThread effectThread = PlayerEffectThreads[EffectName];
switch (effectThread.PlayerThreadType) {
case PlayerThreadType.EffectThread : break;
case PlayerThreadType.RealtimeEffectThread : DateTime dt = effectThread.ExpireDate;
DateTime dtnow = DateTime.Now;
if (DateTime.Compare(dt, dtnow) <= 0) {
DeleteEffect(EffectName, null);
}
break;
default : break;
}
}
public void AddEffect(string EffectThreadName, IPlayer player) {
if (Plugin.registeredThreads.DataEffectThreads.ContainsKey(EffectThreadName)) {
if (PlayerEffectThreads.ContainsKey(EffectThreadName)) {
BaseDataEffectThread regeffectThread = Plugin.registeredThreads.DataEffectThreads[EffectThreadName];
if (regeffectThread.DataThreadType == DataThreadType.PlaytimeEffectThreadData) {
Plugin.SendReplyMessage(player, Plugin.Lang("CantAddPlaytimeEffectToGroup", player?.Id));
return;
}
BasePlayerEffectThread effectThread = regeffectThread.ToPlayerEffectThread(null);
PlayerEffectThreads[EffectThreadName] = effectThread;
effectThread.GrantGroupPermissions(GroupName);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectOverwrittedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectOverwrittedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
}
else {
BaseDataEffectThread regeffectThread = Plugin.registeredThreads.DataEffectThreads[EffectThreadName];
if (regeffectThread.DataThreadType == DataThreadType.PlaytimeEffectThreadData) {
Plugin.SendReplyMessage(player, Plugin.Lang("CantAddPlaytimeEffectToGroup", player?.Id));
return;
}
BasePlayerEffectThread effectThread = regeffectThread.ToPlayerEffectThread(null);
PlayerEffectThreads.Add(EffectThreadName, effectThread);
effectThread.GrantGroupPermissions(GroupName);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectAddedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectAddedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
}
Plugin.UpdatePlayersGUI();
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist", player?.Id, EffectThreadName));
}
}
public void DeleteEffect(string EffectThreadName, IPlayer player) {
if (PlayerEffectThreads.ContainsKey(EffectThreadName)) {
PlayerEffectThreads[EffectThreadName].RevokeGroupPermissions(GroupName, PlayerEffectThreads);
PlayerEffectThreads.Remove(EffectThreadName);
if (PlayerEffectThreads.Count == 0) {
Plugin.groupsData.Groups.Remove(GroupName);
}
Plugin.SendReplyMessage(player, Plugin.Lang("EffectRemovedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectRemovedConsoleNoticeGroup", player?.Id, EffectThreadName, GroupName));
Plugin.UpdatePlayersGUI();
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Group", player?.Id, EffectThreadName));
}
}
public void DeleteAllEffect(IPlayer player) {
if (PlayerEffectThreads.Count != 0) {
foreach (var item in PlayerEffectThreads) {
item.Value.RevokeGroupPermissions(GroupName);
}
Plugin.groupsData.Groups.Remove(GroupName);
Plugin.SendReplyMessage(player, Plugin.Lang("EffectRemovedConsoleNoticeGroup", player?.Id, "All", GroupName));
Plugin.SendBroadcastMessage(Plugin.Lang("EffectRemovedConsoleNoticeGroup", player?.Id, "All", GroupName));
Plugin.UpdatePlayersGUI();
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist On Group", player?.Id, "All"));
}
}
}
#endregion
#region ThreadsData
DynamicConfigFile threadsdataFile = Interface.Oxide.DataFileSystem.GetDatafile("PermissionEffects/Threads");
RegisteredThreads registeredThreads;
private void LoadThreadsData() {
registeredThreads = threadsdataFile.ReadObject<RegisteredThreads>();
if (registeredThreads == null) registeredThreads = new RegisteredThreads();
}
private void SaveThreadsData() {
threadsdataFile.WriteObject(registeredThreads);
}
private class RegisteredThreads {
public Dictionary<string, BaseDataEffectThread> DataEffectThreads {
get;
set;
}
public RegisteredThreads() {
DataEffectThreads = new Dictionary<string, BaseDataEffectThread>();
}
public void RegisterThread(BaseDataEffectThread dataEffectThread, IPlayer player) {
dataEffectThread.Permissions = dataEffectThread.Permissions.Distinct().ToList();
List<string> DeletePerms = new List<string>();
foreach (var permission in dataEffectThread.Permissions) {
if (Plugin.permission.PermissionExists(permission) == false) DeletePerms.Add(permission);
}
foreach (var DeletePerm in DeletePerms) {
Plugin.SendReplyMessage(player, Plugin.Lang("Permission Is Not Exist", player?.Id, DeletePerm));
dataEffectThread.Permissions.Remove(DeletePerm);
}
if (dataEffectThread.Permissions.Count == 0) {
Plugin.SendReplyMessage(player, Plugin.Lang("Permission Is Empty", player?.Id, dataEffectThread.ThreadName));
}
else if (DataEffectThreads.ContainsKey(dataEffectThread.ThreadName)) {
DataEffectThreads[dataEffectThread.ThreadName] = dataEffectThread;
Plugin.SendReplyMessage(player, Plugin.Lang("OverwriteThread", player?.Id, dataEffectThread.ThreadName));
}
else {
DataEffectThreads.Add(dataEffectThread.ThreadName, dataEffectThread);
Plugin.SendReplyMessage(player, Plugin.Lang("RegisterThread", player?.Id, dataEffectThread.ThreadName));
}
}
public void UnRegisterThread(string effectThreadName, IPlayer player) {
if (DataEffectThreads.ContainsKey(effectThreadName)) {
DataEffectThreads.Remove(effectThreadName);
Plugin.SendReplyMessage(player, Plugin.Lang("UnregisterThread", player?.Id, effectThreadName));
}
else {
Plugin.SendReplyMessage(player, Plugin.Lang("Effect Is Not Exist", player?.Id, effectThreadName));
}
}
public bool ThreadIsExist(string ThreadName) {
if (DataEffectThreads.ContainsKey(ThreadName)) {
return true;
}
else {
return false;
}
}
}
#endregion
#region PlayersGUIData
DynamicConfigFile playersuidataFile = Interface.Oxide.DataFileSystem.GetDatafile("PermissionEffects/PlayerGUIData");
PlayersGUIData playersUIData;
private void LoadPlayersGUIData() {
playersUIData = playersuidataFile.ReadObject<PlayersGUIData>();
if (playersUIData == null) playersUIData = new PlayersGUIData();
}
private void SavePlayersGUIData() {
playersuidataFile.WriteObject<PlayersGUIData>(playersUIData);
}
private class PlayersGUIData {
public Dictionary<string, PlayerGUIInfo> Players = new Dictionary<string, PlayerGUIInfo>();
public PlayersGUIData() {
}
public void ResetPlayerData(BasePlayer player) {
if (!Players.ContainsKey(player.UserIDString)) {
Players.Add(player.UserIDString, new PlayerGUIInfo(player.IPlayer));
}
}
public void ResetOnlinePlayersData() {
foreach (BasePlayer player in BasePlayer.activePlayerList) {
ResetPlayerData(player);
}
}
}
private class PlayerGUIInfo {
public string Id;
public string Name;
public bool useUI = true;
public int EffectPage = 0;
public PlayerGUIInfo() {
}
public PlayerGUIInfo(IPlayer player) {
Id = player.Id;
Name = player.Name;
}
}
#endregion
#endregion
#region LangManage
protected override void LoadDefaultMessages() {
lang.RegisterMessages(new Dictionary<string, string> {
["No Permission"]
= "You do not have permission to use the '{0}' command.", ["SteamID Not Found"] =
// ... [Code preview truncated due to length. Full source in attached file] ...