object CanUseLockedEntity(BasePlayer player, CodeLock codeLock)
{
if (codeLock.IsLocked() == false)
{
return(null);
}
var building = (codeLock.GetParentEntity() as DecayEntity)?.GetBuilding();
if (building == null)
{
Puts($"Couldn't find building for {codeLock.GetParentEntity()?.PrefabName}!");
return(null);
}
if (building.buildingPrivileges.Count == 0)
{
return(null);
}
var tcLock = building.buildingPrivileges[0].GetSlot(BaseEntity.Slot.Lock) as CodeLock;
if (tcLock == null)
{
return(null);
}
if (tcLock.code != codeLock.code)
{
return(null);
}
if (tcLock.whitelistPlayers.Contains(player.userID))
{
return(true);
}
return(null);
}
public static void On_DoorCode(CodeLock doorLock, BaseEntity.RPCMessage rpc)
{
if (!doorLock.IsLocked())
{
return;
}
string code = rpc.read.String();
DoorCodeEvent dc = new DoorCodeEvent(doorLock, rpc.player, code);
OnNext("On_DoorCode", dc);
if ((!dc.IsCorrect() || !dc.allowed) && !dc.forceAllow)
{
Effect.server.Run(doorLock.effectDenied.resourcePath, doorLock, 0u, Vector3.zero, Vector3.forward);
rpc.player.Hurt(1f, Rust.DamageType.ElectricShock, doorLock, true);
return;
}
Effect.server.Run(doorLock.effectUnlocked.resourcePath, doorLock, 0u, Vector3.zero, Vector3.forward);
doorLock.SetFlag(BaseEntity.Flags.Locked, false);
doorLock.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
List <ulong> whitelist = new List <ulong>();
whitelist = (List <ulong>)doorLock.GetFieldValue("whitelistPlayers");
if (!whitelist.Contains(rpc.player.userID))
{
whitelist.Add(rpc.player.userID);
doorLock.SetFieldValue("whitelistPlayers", whitelist);
}
}
public static void DoorCode(CodeLock doorLock, BaseEntity.RPCMessage rpc)
{
if (!doorLock.IsLocked())
{
return;
}
/*DoorCodeEvent dc = new DoorCodeEvent(doorLock, rpc);
* OnDoorCode.OnNext(dc);*/
}
private bool CanPlayerBypassLock(BasePlayer player, CodeLock codeLock)
{
if (!codeLock.IsLocked())
{
return(true);
}
object hookResult = Interface.CallHook("CanUseLockedEntity", player, codeLock);
if (hookResult is bool)
{
return((bool)hookResult);
}
return(IsPlayerAuthorizedToCodeLock(player.userID, codeLock) || IsCodeLockSharedWithPlayer(player, codeLock));
}
/// <summary>
/// Initialize locks in a building
/// </summary>
/// <param name="privilege"></param>
private void InitializeMasterLock(BuildingPrivlidge privilege)
{
BaseEntity baseLock = privilege.GetSlot(BaseEntity.Slot.Lock);
if (baseLock is CodeLock)
{
string code = (baseLock as CodeLock).code;
BuildingManager.Building building = privilege.GetBuilding();
foreach (BuildingBlock block in building.buildingBlocks)
{
if (block.GetSlot(BaseEntity.Slot.Lock) is CodeLock)
{
CodeLock codeLock = (block.GetSlot(BaseEntity.Slot.Lock) as CodeLock);
if (!codeLock.IsLocked())
{
codeLock.code = code;
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
foreach (ProtoBuf.PlayerNameID player in privilege.authorizedPlayers)
{
codeLock.whitelistPlayers.Add(player.userid);
}
codeLock.SendNetworkUpdateImmediate();
}
}
}
foreach (DecayEntity entity in building.decayEntities)
{
if (entity.GetSlot(BaseEntity.Slot.Lock) is CodeLock)
{
CodeLock codeLock = (entity.GetSlot(BaseEntity.Slot.Lock) as CodeLock);
if (!codeLock.IsLocked())
{
codeLock.code = code;
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
foreach (ProtoBuf.PlayerNameID player in privilege.authorizedPlayers)
{
codeLock.whitelistPlayers.Add(player.userid);
}
codeLock.SendNetworkUpdateImmediate();
}
}
}
}
}
/// <summary>
/// Can use door hook - called when someone tries to use a door with a codelock
/// </summary>
/// <param name="player">the player who tried to use the door</param>
/// <param name="door">the door in question</param>
/// <returns>can we open the door</returns>
bool CanUseDoor(BasePlayer player, CodeLock lck)
{
// reflect to get the private code
var codeField = typeof(CodeLock).GetField("code",
BindingFlags.NonPublic |
BindingFlags.Instance);
var codeValue = (string)codeField.GetValue(lck);
// if it's not locked or the code isn't all 0s there's nothing for us to do
if (!lck.IsLocked() || codeValue != "0000")
{
return(true);
}
var door = (Door)lck.GetParentEntity();
var doorId = GetDoorId(door);
var doorOwnerId = Convert.ToString(door.OwnerID);
var playerId = Convert.ToString(player.userID);
if (!acl.ContainsKey(doorId))
{
acl[doorId] = new List <string>();
}
if (acl[doorId].IndexOf(doorOwnerId) > -1)
{
return(true);
}
else
{
if (pending2FA.IndexOf(doorId + playerId) == -1)
{
pending2FA.Add(doorId + playerId);
GetRequest(doorOwnerId, doorId, playerId);
}
return(false);
}
}
/// <summary>
/// Called from <c>CodeLock.UnlockWithCode(BaseEntity.RPCMessage)</c>
/// </summary>
public static void On_DoorCodeEntered(CodeLock codeLock, BaseEntity.RPCMessage rpc)
{
if (!codeLock.IsLocked())
return;
string code = rpc.read.String();
Pre<DoorCodeEvent> preDoorCodeEvent = new Pre<DoorCodeEvent>(codeLock, rpc.player, code);
OnNext("Pre_DoorCodeEntered", preDoorCodeEvent);
if (preDoorCodeEvent.IsCanceled || (!preDoorCodeEvent.Event.IsCorrect() && !preDoorCodeEvent.Event.ForceAllow)) {
Effect.server.Run(codeLock.effectDenied.resourcePath, codeLock, 0u, Vector3.zero, Vector3.forward);
rpc.player.Hurt(1f, global::Rust.DamageType.ElectricShock, codeLock, true);
return;
}
Effect.server.Run(codeLock.effectUnlocked.resourcePath, codeLock, 0u, Vector3.zero, Vector3.forward);
codeLock.SetFlag(BaseEntity.Flags.Locked, false);
codeLock.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
List<ulong> whitelist = new List<ulong>();
whitelist = (List<ulong>) codeLock.GetFieldValue("whitelistPlayers");
if (!whitelist.Contains(rpc.player.userID)) {
whitelist.Add(rpc.player.userID);
codeLock.SetFieldValue("whitelistPlayers", whitelist);
}
OnNext("On_DoorCodeEntered", preDoorCodeEvent.Event);
}
public static void DoorCode(CodeLock doorLock, BaseEntity.RPCMessage rpc)
{
if (!doorLock.IsLocked())
return;
string code = rpc.read.String();
DoorCodeEvent dc = new DoorCodeEvent(doorLock, rpc.player, code);
OnDoorCode.OnNext(dc);
if ((!dc.IsCorrect() || !dc.allowed) && !dc.forceAllow)
{
Effect.server.Run(doorLock.effectDenied, doorLock, 0u, Vector3.zero, Vector3.forward);
rpc.player.Hurt(1f, Rust.DamageType.ElectricShock, doorLock, true);
return;
}
Effect.server.Run(doorLock.effectUnlocked, doorLock, 0u, Vector3.zero, Vector3.forward);
doorLock.SetFlag(BaseEntity.Flags.Locked, false);
doorLock.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
List<ulong> whitelist = new List<ulong>();
whitelist = (List<ulong>)doorLock.GetFieldValue("whitelistPlayers");
if (!whitelist.Contains(rpc.player.userID))
{
whitelist.Add(rpc.player.userID);
doorLock.SetFieldValue("whitelistPlayers", whitelist);
}
}
public bool IsLocked()
{
return(CodeLock != null && CodeLock.IsLocked());
}
