C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using Newtonsoft.Json.Linq;
using Oxide.Core.Libraries;
using Oxide.Core.Libraries.Covalence;
using Oxide.Core.Plugins;
using System;
using System.Collections.Generic;
using UnityEngine;
namespace Oxide.Plugins
{
[Info("SharedDoors", "dbteku", "2.0.1")]
[Description("Making sharing doors easier.")]
public class SharedDoors : RustPlugin
{
[PluginReference]
private Plugin Clans;
[PluginReference]
private Plugin Friends;
private static SharedDoors instance;
private const string CLANS_NAME = "Clans";
private const string CLANS_AUTHOR_NAME = "k1lly0u";
private const string FRIENDS_NAME = "Friends";
private const string FRIENDS_AUTHOR_NAME = "MrBlue";
private const string FRIENDS_AUTHOR_NAME_ALTERNATE = "Wulf";
private const string RUST_CLANS_HOOK = "SharedDoors now hooking to Clans by k1lly0u";
private const string RUST_CLANS_UNHOOK = "SharedDoors now un-hooking from Clans";
private const string RUST_FRIENDS_HOOK = "SharedDoors now hooking to Friends by MrBlue";
private const string RUST_FRIENDS_UNHOOK = "SharedDoors now unhooking from Friends.";
private const string RUST_CLANS_NOT_FOUND = "Rust Clans by k1lly0u has not been found.";
private const string RUST_FRIENDS_NOT_FOUND = "Rust Friends by MrBlue has not been found.";
private const string WRONG_CLANS_PLUGIN = "You are using the wrong Clans plugin.Please use the Clans by the author: k1lly0u.";
private const string MASTER_PERM = "shareddoors.master";
private MasterKeyHolders holders;
private void OnServerInitialized()
{
instance = this;
permission.RegisterPermission(MASTER_PERM, this);
holders = new MasterKeyHolders();
if (Clans == null)
{
Puts(RUST_CLANS_NOT_FOUND);
}
else
{
Puts(RUST_CLANS_HOOK);
}
if(Friends == null)
{
Puts(RUST_FRIENDS_NOT_FOUND);
}
else
{
Puts(RUST_FRIENDS_HOOK);
}
}
private void Unload()
{
instance = null;
}
private void OnPluginLoaded(Plugin plugin)
{
if (plugin.Name == CLANS_NAME)
{
if(plugin.Author == CLANS_AUTHOR_NAME)
{
Puts(RUST_CLANS_HOOK);
Clans = plugin;
}
else
{
Puts(WRONG_CLANS_PLUGIN);
}
}
if(plugin.Name == FRIENDS_NAME)
{
if (plugin.Author == FRIENDS_AUTHOR_NAME || plugin.Author == FRIENDS_AUTHOR_NAME_ALTERNATE)
{
Puts(RUST_FRIENDS_HOOK);
Friends = plugin;
}
}
}
private void OnPluginUnloaded(Plugin plugin)
{
if (plugin.Name == CLANS_NAME && plugin.Author == CLANS_AUTHOR_NAME)
{
Puts(RUST_CLANS_UNHOOK);
Clans = null;
}
if(plugin.Name == FRIENDS_NAME && (plugin.Author == FRIENDS_AUTHOR_NAME || plugin.Author == FRIENDS_AUTHOR_NAME_ALTERNATE))
{
Puts(RUST_FRIENDS_UNHOOK);
Friends = null;
}
}
private void OnPlayerInit(BasePlayer player)
{
IPlayer iPlayer = covalence.Players.FindPlayerById(player.userID.ToString());
if (player.IsAdmin || iPlayer.HasPermission(MASTER_PERM))
{
holders.AddMaster(player.userID.ToString());
}
}
private void OnPlayerDisconnected(BasePlayer player, string reason)
{
IPlayer iPlayer = covalence.Players.FindPlayerById(player.userID.ToString());
if (player.IsAdmin || iPlayer.HasPermission(MASTER_PERM))
{
holders.RemoveMaster(player.userID.ToString());
}
}
private bool CanUseLockedEntity(BasePlayer player, BaseLock door)
{
IPlayer iPlayer = covalence.Players.FindPlayerById(player.userID.ToString());
bool canUse = false;
canUse = (player.IsAdmin && holders.IsAKeyMaster(player.userID.ToString()))
|| (iPlayer.HasPermission(MASTER_PERM) && holders.IsAKeyMaster(player.userID.ToString()))
|| new DoorAuthorizer(door, player).CanOpen();
return canUse;
}
#region Commands
[ChatCommand("sd")]
private void SharedDoorsCommand(BasePlayer basePlayer, string command, string[] args)
{
IPlayer player = covalence.Players.FindPlayerById(basePlayer.userID.ToString());
if (args.Length > 0)
{
if (args[0].ToLower() == "help")
{
PlayerResponder.NotifyUser(player, "Master Mode Toggle: /sd masterMode");
}
else if (args[0].ToLower() == "mastermode" || args[0].ToLower() == "mm")
{
if (player.IsAdmin || player.HasPermission(MASTER_PERM))
{
if (holders.HasMaster(player.Id))
{
holders.ToggleMasterMode(player.Id);
if (holders.IsAKeyMaster(player.Id))
{
PlayerResponder.NotifyUser(player, "Master Mode Enabled.You can now open all doors and chests.");
}
else
{
PlayerResponder.NotifyUser(player, "Master Mode Disabled.You can no longer open all doors and chests.");
}
}
else
{
holders.AddMaster(player.Id);
holders.GiveMasterKey(player.Id);
PlayerResponder.NotifyUser(player, "Master Mode Enabled.You can now open all doors and chests.");
}
}
else
{
PlayerResponder.NotifyUser(player, "Master Mode Not Available.You don't have permission to use this command.");
}
}
}
else
{
PlayerResponder.NotifyUser(player, "Master Mode Toggle: /sd masterMode");
}
}
#endregion
public static SharedDoors getInstance()
{
return instance;
}
private class PlayerResponder
{
private const string PREFIX = "<color=#00ffffff>[</color><color=#ff0000ff>SharedDoors</color><color=#00ffffff>]</color>";
public static void NotifyUser(IPlayer player, String message)
{
player.Message(message, PREFIX);
}
}
/*
*
* Door Handler Class
*
* */
private class DoorAuthorizer
{
public BaseLock BaseDoor { get; protected set; }
public BasePlayer Player { get; protected set; }
private ToolCupboardChecker checker;
private FriendsClansHandler handler;
public DoorAuthorizer(BaseLock door, BasePlayer player)
{
this.BaseDoor = door;
this.Player = player;
checker = new ToolCupboardChecker(Player);
handler = new FriendsClansHandler(this);
}
public bool CanOpen()
{
bool canUse = false;
if (BaseDoor.IsLocked())
{
if (BaseDoor is CodeLock)
{
CodeLock codeLock = (CodeLock)BaseDoor;
canUse = CanOpenCodeLock(codeLock, Player);
}
else if (BaseDoor is KeyLock)
{
KeyLock keyLock = (KeyLock)BaseDoor;
canUse = CanOpenKeyLock(keyLock, Player);
}
}
else
{
canUse = true;
}
return canUse;
}
private bool CanOpenCodeLock(CodeLock door, BasePlayer player)
{
bool canUse = false;
var whitelist = door.whitelistPlayers;
canUse = whitelist.Contains(player.userID);
if (!canUse)
{
bool isAuthorizedByTC = (player.CanBuild() && checker.IsPlayerAuthorized());
bool solution = canUse;
if (isAuthorizedByTC && !solution && handler.ClansAvailable())
{
canUse = handler.IsInClan(player.UserIDString, door.OwnerID.ToString());
solution = canUse;
}
if(isAuthorizedByTC && !solution && handler.FriendsAvailable())
{
canUse = handler.IsFriend(player.UserIDString, door.OwnerID.ToString());
}
if (!handler.FriendsAvailable() && !handler.ClansAvailable())
{
canUse = isAuthorizedByTC;
}
}
PlaySound(canUse, door, player);
return canUse;
}
private bool CanOpenKeyLock(KeyLock door, BasePlayer player)
{
bool canUse = door.HasLockPermission(player);
if (!canUse)
{
bool isAuthorizedByTC = (player.CanBuild() && checker.IsPlayerAuthorized());
bool solution = canUse;
if (isAuthorizedByTC && !solution && handler.ClansAvailable())
{
canUse = handler.IsInClan(player.UserIDString, door.OwnerID.ToString());
solution = canUse;
}
if (isAuthorizedByTC && !solution && handler.FriendsAvailable())
{
canUse = handler.IsFriend(player.UserIDString, door.OwnerID.ToString());
}
if(!handler.FriendsAvailable() && !handler.ClansAvailable())
{
canUse = isAuthorizedByTC;
}
}
return canUse;
}
private void PlaySound(bool canUse, CodeLock door, BasePlayer player)
{
if (canUse)
{
Effect.server.Run(door.effectUnlocked.resourcePath, player.transform.position, Vector3.zero, null, false);
}
else
{
Effect.server.Run(door.effectDenied.resourcePath, player.transform.position, Vector3.zero, null, false);
}
}
}
/*
*
* Tool Cupboard Tool
*
* */
private class ToolCupboardChecker
{
public BasePlayer Player { get; protected set; }
public ToolCupboardChecker(BasePlayer player)
{
this.Player = player;
}
public bool IsPlayerAuthorized()
{
return Player.IsBuildingAuthed();
}
}
/*
*
* RustIO Handler
*
* */
private class FriendsClansHandler
{
private const string GET_CLAN_OF_PLAYER = "GetClanOf";
private const string IS_CLAN_MEMBER = "IsClanMember";
public Plugin Clans { get; protected set; }
public Plugin Friends { get; protected set; }
public ulong OriginalPlayerID { get; protected set; }
public DoorAuthorizer Door { get; protected set; }
public FriendsClansHandler(DoorAuthorizer door)
{
if (door.BaseDoor is CodeLock)
{
CodeLock codeLock = door.BaseDoor as CodeLock;
List<ulong> whitelist = codeLock.whitelistPlayers;
if (whitelist.Count > 0)
{
this.OriginalPlayerID = whitelist[0];
}
else
{
this.OriginalPlayerID = 0;
}
}
this.Door = door;
this.Clans = SharedDoors.getInstance().Clans;
this.Friends = SharedDoors.getInstance().Friends;
}
public bool IsInClan(string playerId, string playerDoorOwner)
{
bool isInClan = false;
if (ClansAvailable())
{
string clanName = Clans.Call<string>(GET_CLAN_OF_PLAYER, playerId);
if (!string.IsNullOrWhiteSpace(clanName))
{
isInClan = Clans.Call<bool>(IS_CLAN_MEMBER, playerDoorOwner, playerId);
}
}
return isInClan;
}
public bool IsFriend(string playerId, string playerDoorOwner)
{
return Friends.IsLoaded && Friends.Call<bool>("IsFriend", playerId, playerDoorOwner);
}
public bool ClansAvailable()
{
return this.Clans != null && Clans.IsLoaded;
}
public bool FriendsAvailable()
{
return this.Friends != null && Friends.IsLoaded;
}
}
/*
*
* Admin Mode Handler
*
* */
private class MasterKeyHolders
{
private Dictionary<string, PlayerSettings> keyMasters;
public MasterKeyHolders()
{
keyMasters = new Dictionary<string, PlayerSettings>();
}
public void AddMaster(String id)
{
this.keyMasters.Add(id, new PlayerSettings(false));
}
public void RemoveMaster(String id)
{
this.keyMasters.Remove(id);
}
public void GiveMasterKey(String id)
{
PlayerSettings settings = null;
bool exists = keyMasters.TryGetValue(id, out settings);
if (exists)
{
settings.IsMasterKeyHolder = true;
}
}
public void RemoveMasterKey(String id)
{
PlayerSettings settings = null;
bool exists = keyMasters.TryGetValue(id, out settings);
if (exists)
{
settings.IsMasterKeyHolder = false;
}
}
public bool IsAKeyMaster(String id)
{
bool isKeyMaster = false;
PlayerSettings settings = null;
bool exists = keyMasters.TryGetValue(id, out settings);
if (exists)
{
isKeyMaster = settings.IsMasterKeyHolder;
}
return isKeyMaster;
}
public void ToggleMasterMode(String id)
{
PlayerSettings settings = null;
bool exists = keyMasters.TryGetValue(id, out settings);
if (exists)
{
settings.ToggleMasterMode();
}
}
public bool HasMaster(string id)
{
return keyMasters.ContainsKey(id);
}
}
/*
*
* Player Settings
*
* */
private class PlayerSettings
{
public bool IsMasterKeyHolder { get; set; }
public PlayerSettings(bool isMasterKeyHolder)
{
IsMasterKeyHolder = isMasterKeyHolder;
}
public void ToggleMasterMode()
{
IsMasterKeyHolder = !IsMasterKeyHolder;
}
}
}
}