public void RemoveCode()
{
codeLock.SetFieldValue("code", "");
codeLock.SetFieldValue("hasCode", false);
codeLock.SetFlag(BaseEntity.Flags.Locked, false);
Allow();
}
////////////////////////////////////////////////////////////////////////
/// <summary>
/// Create a CodeLock add the players code to it and add them to the whitelist. Then place the codelock on the door
/// </summary>
/// <param name="player">player who placed the door</param>
/// <param name="door">the door the codelock is going to be attached too</param>
/// <param name="container">the container the codelock is going to be attached too</param>
/// ////////////////////////////////////////////////////////////////////////
private void AddLockToEntity(BasePlayer player, BaseEntity entity, string code)
{
//Create a CodeLock
BaseEntity lockentity = GameManager.server.CreateEntity(CodeLockPrefabLocation, Vector3.zero, new Quaternion());
lockentity.OnDeployed(entity);
//Add the player to the codelock whitelist
List <ulong> whitelist = (List <ulong>)_whitelistField.GetValue(lockentity);
whitelist.Add(player.userID);
_whitelistField.SetValue(lockentity, whitelist);
if (ValidCode(code))
{
CodeLock @lock = lockentity.GetComponent <CodeLock>();
_codelockField.SetValue(@lock, code);
@lock.SetFlag(BaseEntity.Flags.Locked, true);
}
else
{
PrintToChat(player, $"{_pluginConfig.Prefix} {Lang("ParseFailed", player.UserIDString, code)}");
}
//Add the codelock to the door
if (!lockentity)
{
return;
}
lockentity.gameObject.Identity();
lockentity.SetParent(entity, "lock");
lockentity.Spawn();
entity.SetSlot(BaseEntity.Slot.Lock, lockentity);
}
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);
}
}
void AddLock(BaseEntity ent)
{
CodeLock alock = GameManager.server.CreateEntity(lockPrefab) as CodeLock;
alock.Spawn();
alock.code = "789456789123";
alock.SetParent(ent, ent.GetSlotAnchorName(BaseEntity.Slot.Lock));
alock.transform.localScale += new Vector3(-50, -50, -50);
ent.SetSlot(BaseEntity.Slot.Lock, alock);
alock.SetFlag(BaseEntity.Flags.Locked, true);
alock.SendNetworkUpdateImmediate();
}
/// <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();
}
}
}
}
}
private void PlayerSetLocks(BasePlayer player, string code, bool guest = false)
{
bool HasLocks = false;
int num = 0;
foreach (var entry in UnityEngine.Object.FindObjectsOfType <BaseEntity>().Where(k => k.GetSlot(BaseEntity.Slot.Lock) != null && (k.OwnerID == player.userID || (player.IsAdmin && k.OwnerID == 0))))
{
BaseEntity lockSlot = entry.GetSlot(BaseEntity.Slot.Lock);
CodeLock codelock = lockSlot?.GetComponent <CodeLock>();
if (codelock != null)
{
HasLocks = true;
if (guest)
{
CurrentGuestCode.SetValue(codelock, code);
hasGuestCode.SetValue(codelock, true);
hasCode.SetValue(codelock, true);
}
else
{
CurrentCode.SetValue(codelock, code);
hasGuestCode.SetValue(codelock, true);
hasCode.SetValue(codelock, true);
List <ulong> whitelisted = CodeLockWhiteList.GetValue(codelock) as List <ulong>;
if (!whitelisted.Contains(player.userID))
{
whitelisted.Add(player.userID);
}
CodeLockWhiteList.SetValue(codelock, whitelisted);
codelock.SetFlag(BaseEntity.Flags.Locked, true);
}
num++;
}
}
if (!HasLocks)
{
GetSendMSG(player, "NoCodeLocksFound");
}
else
{
GetSendMSG(player, "NumberCodeLocksReset", num.ToString());
}
}
void SetupCodelock(ulong uid, CodeLock codeLock)
{
codeLock.OwnerID = uid;
codeLocks.Add(codeLock);
var owner = GetCodeLockOwner(codeLock);
var cfg = GetPlayerCfg(owner);
if (!cfg.AutoLock)
{
return;
}
codeLock.code = RandomString(4);
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
codeLock.whitelistPlayers = new List <ulong>()
{
owner
};
}
/// <summary>
/// Set code on new lock in master lock privilege area
/// </summary>
/// <param name="entity"></param>
void OnEntitySpawned(BaseNetworkable entity)
{
if (!initialized)
{
return;
}
if (entity is CodeLock)
{
CodeLock codeLock = entity as CodeLock;
BuildingPrivlidge privilege = codeLock.GetBuildingPrivilege();
if (!privilege)
{
return;
}
if (data.buildings.ContainsKey(privilege.net.ID))
{
if (data.buildings[privilege.net.ID])
{
BaseEntity lockEntity = privilege.GetSlot(BaseEntity.Slot.Lock);
if (lockEntity is CodeLock)
{
codeLock.code = (lockEntity as CodeLock).code;
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
foreach (ProtoBuf.PlayerNameID player in privilege.authorizedPlayers)
{
codeLock.whitelistPlayers.Add(player.userid);
}
codeLock.SendNetworkUpdateImmediate();
}
}
}
}
else if (entity is BuildingPrivlidge && (bool)Config["Display Tooltips"])
{
BasePlayer player = BasePlayer.FindByID((entity as BuildingPrivlidge).OwnerID);
ShowGameTip(player, Lang("AddLock", player.UserIDString));
}
}
/// <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 void Build(Vector3 spawnAt)
{
foreach (StructureComponent component in StructureComponents.Values)
{
Vector3 v3 = (component.LocalPosition.ToVector3() + spawnAt);
BaseEntity ent = GameManager.server.CreateEntity(component.Prefab, v3, component.LocalRotation.ToQuaternion());
ent.SpawnAsMapEntity();
BuildingBlock bb = ent.GetComponent <BuildingBlock>();
bb.blockDefinition = PrefabAttribute.server.Find <Construction>(bb.prefabID);
bb.grade = component.Grade;
bb.health = component.Health;
if (bb.HasSlot(BaseEntity.Slot.Lock))
{
if (component.HasCodeLock)
{
BaseEntity baseEntity = GameManager.server.CreateEntity("build/locks/lock.code", Vector3.zero, new Quaternion());
baseEntity.OnDeployed(bb);
if (!string.IsNullOrEmpty(component.LockCode))
{
CodeLock codeLock = baseEntity.GetComponent <CodeLock>();
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
codeLock.SetFieldValue("code", component.LockCode);
codeLock.SetFieldValue("whitelistPlayers", component.LockWList);
}
baseEntity.gameObject.Identity();
baseEntity.SetParent(bb, "lock");
baseEntity.Spawn();
bb.SetSlot(BaseEntity.Slot.Lock, baseEntity);
}
else if (component.HasKeyLock)
{
BaseEntity baseEntity = GameManager.server.CreateEntity("build/locks/lock.key", Vector3.zero, new Quaternion());
baseEntity.OnDeployed(bb);
int code = int.Parse(component.LockCode);
if ((code & 0x80) != 0)
{
KeyLock keyLock = baseEntity.GetComponent <KeyLock>();
keyLock.SetFieldValue("keycode", (code & 0x7F));
keyLock.SetFieldValue("firstKeyCreated", true);
keyLock.SetFlag(BaseEntity.Flags.Locked, true);
}
baseEntity.gameObject.Identity();
baseEntity.SetParent(bb, "lock");
baseEntity.Spawn();
bb.SetSlot(BaseEntity.Slot.Lock, baseEntity);
}
}
bb.SendNetworkUpdateImmediate();
}
foreach (DeployableComponent component in DeployableComponents.Values)
{
Vector3 v3 = (component.LocalPosition.ToVector3() + spawnAt);
BaseEntity ent = GameManager.server.CreateEntity(component.Prefab, v3, component.LocalRotation.ToQuaternion());
ent.SpawnAsMapEntity();
if (component.HasOwner)
{
SleepingBag sleepingBag = ent.GetComponent <SleepingBag>();
sleepingBag.deployerUserID = component.DeployedBy;
sleepingBag.niceName = component.BagName;
}
else if (component.IsCupBoard)
{
BuildingPrivlidge buildingPrivlidge = ent.GetComponent <BuildingPrivlidge>();
buildingPrivlidge.authorizedPlayers = component.AuthedPlayers;
}
else if (component.HasStorage)
{
StorageContainer storageContainer = ent.GetComponent <StorageContainer>();
var items = component.ItemList;
foreach (var item in items)
{
Item newItem = ItemManager.CreateByItemID((int)item["id"], (int)item["amount"], (bool)item["blueprint"]);
newItem.MoveToContainer(storageContainer.inventory);
}
if (ent.HasSlot(BaseEntity.Slot.Lock))
{
if (component.HasCodeLock)
{
BaseEntity baseEntity = GameManager.server.CreateEntity("build/locks/lock.code", Vector3.zero, new Quaternion());
baseEntity.OnDeployed(ent);
if (!string.IsNullOrEmpty(component.LockCode))
{
CodeLock codeLock = baseEntity.GetComponent <CodeLock>();
codeLock.SetFlag(BaseEntity.Flags.Locked, true);
codeLock.SetFieldValue("code", component.LockCode);
codeLock.SetFieldValue("whitelistPlayers", component.LockWList);
}
baseEntity.gameObject.Identity();
baseEntity.SetParent(ent, "lock");
baseEntity.Spawn();
ent.SetSlot(BaseEntity.Slot.Lock, baseEntity);
}
else if (component.HasKeyLock)
{
BaseEntity baseEntity = GameManager.server.CreateEntity("build/locks/lock.key", Vector3.zero, new Quaternion());
baseEntity.OnDeployed(ent);
int code = int.Parse(component.LockCode);
if ((code & 0x80) != 0)
{
KeyLock keyLock = baseEntity.GetComponent <KeyLock>();
keyLock.SetFieldValue("keycode", (code & 0x7F));
keyLock.SetFieldValue("firstKeyCreated", true);
keyLock.SetFlag(BaseEntity.Flags.Locked, true);
}
baseEntity.gameObject.Identity();
baseEntity.SetParent(ent, "lock");
baseEntity.Spawn();
ent.SetSlot(BaseEntity.Slot.Lock, baseEntity);
}
}
}
else if (component.HasPainting)
{
Signage signage = ent.GetComponent <Signage>();
if (component.Painting != null)
{
byte[] painting = component.Painting;
signage.textureID = FileStorage.server.Store(painting, FileStorage.Type.png, signage.net.ID);
}
if (component.PaintingLocked)
{
signage.SetFlag(BaseEntity.Flags.Locked, true);
}
signage.SendNetworkUpdate();
}
ent.SendNetworkUpdateImmediate();
}
foreach (SpawnableComponent component in SpawnableComponents.Values)
{
Vector3 v3 = (component.LocalPosition.ToVector3() + spawnAt);
BaseEntity ent = GameManager.server.CreateEntity(component.Prefab, v3, component.LocalRotation.ToQuaternion());
ent.SpawnAsMapEntity();
ent.SendNetworkUpdateImmediate();
}
}
private void CmdLockQuarry(IPlayer iplayer)
{
if (iplayer == null)
{
return;
}
BasePlayer player = iplayer.Object as BasePlayer;
if (player == null)
{
return;
}
if (configData.globalSettings.usePermission && !permission.UserHasPermission(iplayer.Id, PERMISSION_USE))
{
if (!configData.globalSettings.adminsAllowed || !iplayer.IsAdmin)
{
Print(iplayer, Lang("NotAllowed", iplayer.Id));
return;
}
}
RaycastHit rhit;
BaseEntity entity = null;
if (Physics.Raycast(player.eyes.HeadRay(), out rhit))
{
entity = rhit.GetEntity();
}
if (entity == null)
{
Print(iplayer, Lang("NotLookingAtQuarry", iplayer.Id));
return;
}
Vector3 cordinates;
if (entity.ShortPrefabName == "mining.pumpjack")
{
cordinates = new Vector3(-3.38f, 6.30f, -0.30f);
}
else if (entity.ShortPrefabName == "mining_quarry")
{
cordinates = new Vector3(1.35f, 10.15f, 0.00f);
}
else
{
Print(iplayer, Lang("NotAQuarry", iplayer.Id));
return;
}
if (entity.OwnerID != player.userID)
{
Print(iplayer, Lang("Ownership", iplayer.Id));
return;
}
if (entity.GetComponentInChildren <CodeLock>() != null)
{
Print(iplayer, Lang("Already", iplayer.Id));
return;
}
if (player.inventory.FindItemID(1159991980) == null)
{
Print(iplayer, Lang("NoLock", iplayer.Id));
return;
}
player.inventory.Take(null, 1159991980, 1);
CodeLock codelock = GameManager.server.CreateEntity("assets/prefabs/locks/keypad/lock.code.prefab", cordinates) as CodeLock;
if (codelock != null)
{
codelock.Spawn();
codelock.SetParent(entity.GetComponent <BaseResourceExtractor>());
if (configData.globalSettings.autoLock)
{
codelock.code = Random.Range(1000, 9999).ToString();
codelock.SetFlag(BaseEntity.Flags.Locked, true);
codelock.whitelistPlayers.Add(player.userID);
}
Print(iplayer, Lang("Added", iplayer.Id));
}
}
public void SetIsLocked(bool locked)
{
PlayEffectAtEntity(locked ? CodeLock.effectLocked : CodeLock.effectUnlocked);
CodeLock.SetFlag(BaseEntity.Flags.Locked, locked, false);
CodeLock.SendNetworkUpdate();
}
