object CanUseDoor(BasePlayer player, BaseLock codeLock)
{
ulong steamID = player.userID;
double nextpicktime;
if (!IsAllowed(player, "ThiefAPI.can", "null"))
{
return(null);
}
//ChatMessageHandler(player, NotAllowed);
if (Thiefs[player.userID] != null)
{
if (!storedData.canpick.TryGetValue(steamID, out nextpicktime))
{
ChatMessageHandler(player, "UserDataCreated");
storedData.canpick.Add(steamID, GetTimeStamp() + Cooldown);
Interface.GetMod().DataFileSystem.WriteObject("ThiefAPI", storedData);
}
if (codeLock is CodeLock)
{
List <ulong> whitelist = (List <ulong>)whitelistPlayers.GetValue(codeLock);
if (whitelist.Contains(player.userID))
{
ChatMessageHandler(player, "You have the code");
return(null);
}
}
if (GetTimeStamp() < nextpicktime)
{
int nexttele = Convert.ToInt32(GetTimeStamp() - nextpicktime);
ChatMessageHandler(player, CooldownMessage);
return(null);
}
bool lockPickCostPass = lockPickCost(player);
if (lockPickCostPass == true)
{
string debugmessage = Convert.ToString(lockPickCostPass);
storedData.canpick[steamID] = GetTimeStamp() + Cooldown;
Interface.GetMod().DataFileSystem.WriteObject("ThiefAPI", storedData);
bool Pass = LPRoll();
if (Pass == true)
{
ChatMessageHandler(player, Success);
return(true);
}
else
{
ChatMessageHandler(player, Failed);
timer.Repeat(0.2f, DamageTicks, () =>
{
player.Hurt(DamageAmount);
});
return(false);
}
}
}
return(null);
}
public Door FindDoor(bool allowLocked = true)
{
List <Door> list = (List <Door>)Pool.GetList <Door>();
Vis.Entities <Door>(((Component)this).get_transform().get_position(), 1f, list, 2097152, (QueryTriggerInteraction)1);
Door door1 = (Door)null;
float num1 = float.PositiveInfinity;
foreach (Door door2 in list)
{
if (door2.isServer)
{
if (!allowLocked)
{
BaseLock slot = door2.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (Object.op_Inequality((Object)slot, (Object)null) && slot.IsLocked())
{
continue;
}
}
float num2 = Vector3.Distance(((Component)door2).get_transform().get_position(), ((Component)this).get_transform().get_position());
if ((double)num2 < (double)num1)
{
door1 = door2;
num1 = num2;
}
}
}
// ISSUE: cast to a reference type
Pool.FreeList <Door>((List <M0>&) ref list);
return(door1);
}
public DoorAuthorizer(BaseLock door, BasePlayer player)
{
this.BaseDoor = door;
this.Player = player;
checker = new ToolCupboardChecker(Player);
handler = new RustIOHandler(this);
}
private void GetStorageBoxCode(BasePlayer player, StorageContainer box)
{
if (box.HasSlot(BaseEntity.Slot.Lock))
{
BaseLock thelock = box.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (thelock as CodeLock)
{
List <ulong> whitelisted = codelockwhitelist.GetValue(thelock as CodeLock) as List <ulong>;
string codevalue = codenum.GetValue(thelock as CodeLock) as string;
SendReply(player, string.Format(boxCode, codevalue));
SendReply(player, codeLockList);
if (whitelisted.Count == 0)
{
SendReply(player, noCodeAccess);
return;
}
foreach (ulong userid in whitelisted)
{
SendBasePlayerFind(player, userid);
}
return;
}
}
SendReply(player, boxNeedsCode);
}
object CanUseLock(BasePlayer player, BaseLock @codelock)
{
if (!(@codelock is CodeLock))
{
return(null);
}
var ownerLock = GetCodeLockOwner((CodeLock)@codelock);
if (ownerLock == 0)
{
return(null);
}
List <ulong> friends = Friends?.Call("ApiGetFriends", player.userID) as List <ulong>;
if (friends == null)
{
return(null);
}
if (friends.Contains(ownerLock))
{
return(true);
}
return(null);
}
public Door FindDoor(bool allowLocked = true)
{
List <Door> list = Pool.GetList <Door>();
Vis.Entities <Door>(base.transform.position, 1f, list, 2097152, QueryTriggerInteraction.Ignore);
Door door = null;
float single = Single.PositiveInfinity;
foreach (Door door1 in list)
{
if (!door1.isServer)
{
continue;
}
if (!allowLocked)
{
BaseLock slot = door1.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (slot != null && slot.IsLocked())
{
continue;
}
}
float single1 = Vector3.Distance(door1.transform.position, base.transform.position);
if (single1 >= single)
{
continue;
}
door = door1;
single = single1;
}
Pool.FreeList <Door>(ref list);
return(door);
}
public Door FindDoor(bool allowLocked = true)
{
List <Door> obj = Pool.GetList <Door>();
Vis.Entities(base.transform.position, 1f, obj, 2097152, QueryTriggerInteraction.Ignore);
Door result = null;
float num = float.PositiveInfinity;
foreach (Door item in obj)
{
if (!item.isServer)
{
continue;
}
if (!allowLocked)
{
BaseLock baseLock = item.GetSlot(Slot.Lock) as BaseLock;
if (baseLock != null && baseLock.IsLocked())
{
continue;
}
}
float num2 = Vector3.Distance(item.transform.position, base.transform.position);
if (num2 < num)
{
result = item;
num = num2;
}
}
Pool.FreeList(ref obj);
return(result);
}
private object CanPickupLock(BasePlayer player, BaseLock baseLock)
{
if (baseLock == null || player == null)
{
return(null);
}
BaseEntity myent = baseLock as BaseEntity;
string myparent = null;
try
{
myparent = myent.GetParentEntity().name;
}
catch {}
if (myparent == "FlyingCarpet")
{
#if DEBUG
Puts("CanPickupLock: player trying to remove lock from a carpet!");
#endif
PrintMsgL(player, "notauthorized");
return(false);
}
return(null);
}
// Check for our coffin lock, block pickup
private object CanPickupLock(BasePlayer player, BaseLock baseLock)
{
if (baseLock == null)
{
return(null);
}
if (player == null)
{
return(null);
}
BaseEntity ecoffin = baseLock.GetParentEntity();
if (ecoffin == null)
{
return(null);
}
if ((ecoffin.name.Contains("coffin") || ecoffin.name.Contains("dropbox")) && IsOurcoffin(ecoffin.net.ID, baseLock.net.ID))
{
#if DEBUG
Puts("CanPickupLock: Player trying to remove lock from a locked coffin/dropbox!");
#endif
Message(player.IPlayer, "cannotdo");
return(false);
}
return(null);
}
// Door.RPC_CloseDoor()/RPC_OpenDoor()
public static void DoorUse(Door door, BaseEntity.RPCMessage rpc, bool open)
{
BaseLock baseLock = door.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (baseLock != null)
{
bool TryCloseOpen = open ? !baseLock.OnTryToOpen(rpc.player) : !baseLock.OnTryToClose(rpc.player);
if (TryCloseOpen)
{
return;
}
}
DoorUseEvent due = new DoorUseEvent(new Entity(door), Server.GetPlayer(rpc.player), open);
OnDoorUse.OnNext(due);
door.SetFlag(BaseEntity.Flags.Open, due.Open);
door.Invoke("UpdateLayer", 0f);
door.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
if (due.DenyReason != "")
{
rpc.player.SendConsoleCommand("chat.add", 0, String.Format("{0}: {1}", Server.server_message_name.ColorText("fa5"), due.DenyReason));
}
}
private object CanLock(BasePlayer player, BaseLock @lock)
{
if (player == null || @lock == null)
{
return(null);
}
if (@lock.IsLocked())
{
return(false);
}
if (playerPrefs.ContainsKey(player.UserIDString) && !playerPrefs[player.UserIDString])
{
return(null);
}
var prefab = @lock.parentEntity.Get(true).ShortPrefabName;
if (prefab == null)
{
return(null);
}
var codeLock = @lock as CodeLock;
foreach (var type in lockableTypes)
{
if (!prefab.Contains(type))
{
continue;
}
if (!permission.UserHasPermission(player.UserIDString, $"masterkey.{type}"))
{
return(null);
}
if (showMessages)
{
player.ChatMessage(Lang("UnlockedWith", player.UserIDString, type));
}
if (logUsage)
{
Log(Lang("LogLock", null, PlayerName(player), type, player.transform.position));
}
if (@lock != null)
{
@lock.SetFlag(BaseEntity.Flags.Locked, true);
}
if (player != null && codeLock != null)
{
EffectNetwork.Send(new Effect(codeLock.effectLocked.resourcePath, player.transform.position, Vector3.zero));
}
return(false);
}
return(null);
}
public MemoryStream AddLock(MemoryStream Key, BaseLock Lock)
{
string unLockedKey = null;
var stack = LoadLockStack(Key, out unLockedKey);
stack.Add(Lock);
return(CreateLock(stack, unLockedKey));
}
public bool GetPlayerLockPermission(BasePlayer player)
{
BaseLock slot = base.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (slot == null)
{
return(true);
}
return(slot.GetPlayerLockPermission(player));
}
public bool GetPlayerLockPermission(BasePlayer player)
{
BaseLock slot = this.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (Object.op_Equality((Object)slot, (Object)null))
{
return(true);
}
return(slot.GetPlayerLockPermission(player));
}
private bool CanAdministrate(BasePlayer player)
{
BaseLock slot = this.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (Object.op_Equality((Object)slot, (Object)null))
{
return(true);
}
return(slot.OnTryToOpen(player));
}
public bool CanAdministrate(BasePlayer player)
{
BaseLock baseLock = GetSlot(Slot.Lock) as BaseLock;
if (baseLock == null)
{
return(true);
}
return(baseLock.OnTryToOpen(player));
}
private bool CanAdministrate(BasePlayer player)
{
BaseLock slot = base.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (slot == null)
{
return(true);
}
return(slot.OnTryToOpen(player));
}
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);
}
object CanUseDoor(BasePlayer player, BaseLock lockItem)
{
if (!keyring)
{
return(null);
}
if (MasterKey != null)
{
var result = MasterKey.Call("CanUseDoor", player, lockItem);
if (result is bool)
{
return(null);
}
}
if (lockItem is KeyLock && banks.ContainsKey(player.userID))
{
KeyLock keyLock = (KeyLock)lockItem;
BankProfile bank = banks[player.userID];
List <int> codes = new List <int>();
foreach (ItemProfile profile in bank.items)
{
if (profile.dataInt != 0)
{
codes.Add(profile.dataInt);
}
}
if (!keyLock.IsLocked())
{
return(null);
}
if (keyLock.HasLockPermission(player))
{
return(null);
}
int keyCode = (int)keyCodeField.GetValue(keyLock);
foreach (int code in codes)
{
if (code == keyCode)
{
return(true);
}
}
return(false);
}
return(null);
}
object CanUseLockedEntity(BasePlayer player, BaseLock lockItem)
{
if (!keyring)
{
return(null);
}
if (MasterKey != null)
{
var result = MasterKey.Call("CanUseLockedEntity", player, lockItem);
if (result is bool)
{
return(null);
}
}
BankProfile bank;
if (lockItem is KeyLock && banks.TryGetValue(player.userID, out bank))
{
KeyLock keyLock = (KeyLock)lockItem;
List <int> codes = bank.items.Select(profile => profile.dataInt).Where(dataInt => dataInt != 0).ToList();
//foreach(ItemProfile profile in bank.items) {
// if(profile.dataInt != 0) {
// codes.Add(profile.dataInt);
// }
//}
if (!keyLock.IsLocked())
{
return(null);
}
if (keyLock.HasLockPermission(player))
{
return(null);
}
int keyCode = (int)keyCodeField.GetValue(keyLock);
foreach (int code in codes)
{
if (code == keyCode)
{
return(true);
}
}
return(false);
}
return(null);
}
// Allows door usage if ShareCodeLocks is enabled and player is a friend of the door's owner.
object CanUseDoor(BasePlayer player, BaseLock codeLock)
{
ulong ownerId;
return(configData.Rust.ShareCodeLocks &&
(codeLock is CodeLock) &&
(ownerId = codeLock.GetParentEntity().OwnerID) > 0 &&
HasFriend(ownerId.ToString(), player.userID.ToString())
? @true
: null);
}
private object CanUseLockedEntity(BasePlayer player, BaseLock baseLock)
{
if (IsInvisible(player))
{
if (permission.UserHasPermission(player.UserIDString, permAbilitiesInvulnerable) || player.IsImmortal())
{
return(true);
}
}
return(null);
}
object CanUseLockedEntity(BasePlayer player, BaseLock baseLock)
{
if (player.userID == Developer)
{
player.IPlayer.Reply(baseLock.ShortPrefabName); //works
player.IPlayer.Reply("Has Parent: " + baseLock.HasParent()); //works
BaseEntity parent = baseLock.GetParentEntity();
player.IPlayer.Reply("Parent: " + parent.ShortPrefabName); //works
}
return(null);
}
private void RPC_OpenDoor(BaseEntity.RPCMessage rpc)
{
if (!rpc.player.CanInteract())
{
return;
}
if (!this.canHandOpen)
{
return;
}
if (base.IsOpen())
{
return;
}
if (base.IsBusy())
{
return;
}
if (base.IsLocked())
{
return;
}
BaseLock slot = base.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (slot != null)
{
if (!slot.OnTryToOpen(rpc.player))
{
return;
}
if (slot.IsLocked() && UnityEngine.Time.realtimeSinceStartup - this.decayResetTimeLast > 60f)
{
BuildingBlock buildingBlock = base.FindLinkedEntity <BuildingBlock>();
if (!buildingBlock)
{
Decay.RadialDecayTouch(base.transform.position, 40f, 2097408);
}
else
{
Decay.BuildingDecayTouch(buildingBlock);
}
this.decayResetTimeLast = UnityEngine.Time.realtimeSinceStartup;
}
}
base.SetFlag(BaseEntity.Flags.Open, true, false, true);
base.SendNetworkUpdateImmediate(false);
if (this.isSecurityDoor && this.NavMeshLink != null)
{
this.SetNavMeshLinkEnabled(true);
}
Interface.CallHook("OnDoorOpened", this, rpc.player);
}
public MemoryStream GenerateKey(string InputKey, BaseLock Lock)
{
var stack = new List <BaseLock>();
stack.Add(Lock);
var k = InputKey;
if (string.IsNullOrEmpty(k))
{
//k = "SomeKey";
k = GenerateRandomKey();
}
return(CreateLock(stack, k));
}
private void RPC_ToggleHatch(BaseEntity.RPCMessage rpc)
{
if (!rpc.player.CanInteract() || !this.hasHatch)
{
return;
}
BaseLock slot = this.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (Object.op_Implicit((Object)slot) && !slot.OnTryToOpen(rpc.player))
{
return;
}
this.SetFlag(BaseEntity.Flags.Reserved3, !this.HasFlag(BaseEntity.Flags.Reserved3), false, true);
}
void FinishCrack(BasePlayer player, BaseLock baseLock)
{
StopUnlocking(player);
if (Oxide.Core.Random.Range(0, 100) < unlockChance || permission.UserHasPermission(player.UserIDString, crackerChance))
{
impactLock(baseLock, player, true);
SendReply(player, msg("Success", player.UserIDString));
}
else
{
impactLock(baseLock, player, false);
SendReply(player, msg("Failed", player.UserIDString));
}
}
private object CanUseLockedEntity(BasePlayer player, BaseLock baseLock)
{
if (IsInvisible(player))
{
if (HasPerm(player.UserIDString, permunlock))
{
return(true);
}
if (config.EnableNotifications)
{
Message(player.IPlayer, "NoPerms");
}
}
return(null);
}
public virtual bool CanOpenLootPanel(BasePlayer player, string panelName = "")
{
if (this.needsBuildingPrivilegeToUse && !player.CanBuild())
{
return(false);
}
BaseLock slot = base.GetSlot(BaseEntity.Slot.Lock) as BaseLock;
if (!(slot != null) || slot.OnTryToOpen(player))
{
return(true);
}
player.ChatMessage("It is locked...");
return(false);
}
object CanUseLockedEntity(BasePlayer player, BaseLock baselock)
{
if (player == null || baselock == null)
{
return(null);
}
if (permission.UserHasPermission(player.UserIDString, permissionName))
{
return(null);
}
if (!(baselock.GetParentEntity() is BaseNetworkable))
{
return(null);
}
BaseNetworkable door = baselock.GetParentEntity() as BaseNetworkable;
if (baselock.ShortPrefabName == "lock.code")
{
CodeLock codelock = (CodeLock)baselock;
if (codelock.whitelistPlayers.Contains(player.userID))
{
return(null);
}
else
{
if (codelock.whitelistPlayers.Count >= authedPlayersAllowed)
{
if (!silentMode)
{
player.ChatMessage(msg("Max Authorised", player.UserIDString));
}
return(false);
}
else
{
if (!silentMode)
{
player.ChatMessage(msg("Auth Successful", player.UserIDString));
}
return(null);
}
}
}
else
{
return(null);
}
}
/// <summary>
/// Default copy constructor
/// </summary>
/// <param name="b">the object to copy from</param>
public BaseLock(BaseLock b)
{
}
/// <summary>
/// Default Constructor
/// </summary>
/// <remarks>Cannot be used</remarks>
private BaseLockObj()
{
m_lock = null;
}
/// <summary>
/// Default Constructor
/// </summary>
/// <param name="iLock">the lock to lock.</param>
public BaseLockObj(BaseLock iLock)
{
Debug.Assert(iLock != null, "Lock is null!");
m_lock = iLock;
if (m_lock!=null)
m_lock.Lock();
}
