private object CheckTurret(AutoTurret turret) { CodeLock _lock = turret.GetComponentInChildren <CodeLock>(); if (!_lock) { return(null); } BasePlayer player = FindBasePlayer(turret.transform.position); if (player == null) { return(null); } if (_lock.code == string.Empty) { return(null); } if (_lock.whitelistPlayers.Contains(player.userID)) { return(null); } player.ChatMessage(msg("Not Allowed", player.UserIDString)); if (doEffects) { Effect.server.Run(effectDenied, _lock.transform.position); } return(true); }
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); }
/// <summary> /// Clear lock's whitelist /// </summary> /// <param name="privilege"></param> void ClearAuthorizations(BuildingPrivlidge privilege) { BaseEntity baseLock = privilege.GetSlot(BaseEntity.Slot.Lock); if (baseLock is CodeLock) { CodeLock masterLock = baseLock as CodeLock; 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 (masterLock.code == codeLock.code) { codeLock.whitelistPlayers.Clear(); 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 (masterLock.code == codeLock.code) { codeLock.whitelistPlayers.Clear(); codeLock.SendNetworkUpdateImmediate(); } } } } }
//////////////////////////////////////////////////////////////////////// /// <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); }
private void GetDeployableCode(BasePlayer player, BaseEntity block) { if (block.HasSlot(BaseEntity.Slot.Lock)) { BaseEntity slotent = block.GetSlot(BaseEntity.Slot.Lock); if (slotent != null) { CodeLock codelock = slotent.GetComponent <CodeLock>(); if (codelock != null) { List <ulong> whitelisted = codelockwhitelist.GetValue(codelock) as List <ulong>; string codevalue = codenum.GetValue(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); } } } } }
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); } }
/// <summary> /// Close all linked doors in the building /// </summary> /// <param name="privilege"></param> /// <param name="player"></param> private void CloseDoors(BuildingPrivlidge privilege, BasePlayer player) { uint doorCount = 0; BaseEntity baseLock = privilege.GetSlot(BaseEntity.Slot.Lock); if (baseLock is CodeLock) { CodeLock masterLock = baseLock as CodeLock; BuildingManager.Building building = privilege.GetBuilding(); foreach (DecayEntity entity in building.decayEntities) { if (entity.GetSlot(BaseEntity.Slot.Lock) is CodeLock && entity is Door) { CodeLock codeLock = (entity.GetSlot(BaseEntity.Slot.Lock) as CodeLock); if (masterLock.code == codeLock.code && masterLock != codeLock) { if ((entity as Door).HasFlag(BaseEntity.Flags.Open)) { (entity as Door).SetFlag(BaseEntity.Flags.Open, false); (entity as Door).SendNetworkUpdate(); doorCount++; } } } } player.ChatMessage(Lang("ClosedDoors", player.UserIDString, doorCount)); } }
private object OnCodeEntered(CodeLock codeLock, BasePlayer player, string code) { if (HasPermission(player)) { return(null); } if (!Configuration.EnforceLocks) { return(null); } if (!(code == codeLock.guestCode || code == codeLock.code)) { return(null); } if (codeLock.whitelistPlayers.Count + codeLock.guestPlayers.Count < Configuration.MaxPlayers) { return(null); } ProcessConfiguration(player, "lock"); LogToFile("CodeLock", Lang("logMessage") .Replace("{time}", DateTime.UtcNow.ToShortDateString()) .Replace("{player}", player.displayName) .Replace("{steamID}", player.UserIDString) .Replace("{coordinates}", FormattedCoordinates(player)), this); return(false); }
// Handle the case where the code lock is removed but the car and cockpit remain private void OnEntityKill(CodeLock codeLock) { if (codeLock == null) { return; } var seatingModule = codeLock.GetParentEntity() as VehicleModuleSeating; if (seatingModule == null) { return; } var car = seatingModule.Vehicle as ModularCar; NextTick(() => { if (car == null) { return; } UIManager.UpdateCarUI(car); }); }
public RustPlayerChangingLockCodeEvent(RustPlayer player, CodeLock codeLock, string newCode, bool isGuestCode) : base(player) { CodeLock = codeLock; NewCode = newCode; IsGuestCode = isGuestCode; }
/// <summary> /// Авторизирует список игроков в кодовом замке /// </summary> /// <param name="codelock">Кодовый замок</param> /// <param name="friends">Список игроков</param> void CodeLockAuth(CodeLock codelock, List <ulong> friends) { List <ulong> whitelist = (List <ulong>)whiteListField.GetValue(codelock); foreach (var friendUserId in friends.Where(p => !whitelist.Contains(p))) { whitelist.Add(friendUserId); } }
void OnItemDeployed(Deployer deployer, BaseEntity entity) { if (entity?.GetParentEntity() != null && (entity.GetParentEntity() is MiniCopter)) { CodeLock cLock = entity.GetComponentInChildren <CodeLock>(); cLock.transform.localPosition = new Vector3(0.0f, 0.3f, 0.298f); cLock.transform.localRotation = Quaternion.Euler(new Vector3(0, 90, 0)); cLock.SendNetworkUpdateImmediate(); } }
void OnEntityKill(BaseNetworkable ent) { if (!(ent is CodeLock)) { return; } CodeLock codeLock = (CodeLock)ent; codeLocks.Remove(codeLock); }
public static void DoorCode(CodeLock doorLock, BaseEntity.RPCMessage rpc) { if (!doorLock.IsLocked()) { return; } /*DoorCodeEvent dc = new DoorCodeEvent(doorLock, rpc); * OnDoorCode.OnNext(dc);*/ }
object CanChangeCode(BasePlayer player, CodeLock codeLock, string newCode, bool isGuestCode) { if (newCode == "1111") { Server.Broadcast("Слишком простой пароль! " + newCode); return(false); } Server.Broadcast("CanChangeCode works!"); return(null); }
/// <param name="unloading">Specify true if the plugin is unloading.</param> public void Destroy(bool destroyOutputContainer, bool unloading = false) { resetDespawnTimer.DestroyToPool(); foreach (var player in NearbyPlayers) { OnPlayerLeave(player); } if (!unloading) { // Drop queue items if (CraftingTasks.Count > 0) { var container = new ItemContainer(); container.ServerInitialize(null, 36); foreach (var task in CraftingTasks) { foreach (var ingredient in task.Blueprint.ingredients) { var item = ItemManager.CreateByItemID(ingredient.itemid, (int)ingredient.amount * task.Amount); if (!item.MoveToContainer(container)) { item.Drop(Position + Recycler.transform.up * 1.25f, Recycler.GetDropVelocity(), Recycler.ServerRotation); } } } var droppedContainer = container.Drop(Constants.ItemDropPrefab, Position + Recycler.transform.up * 1.25f, Recycler.ServerRotation); droppedContainer.playerName = Lang.Translate(null, "queue-items"); } } Recycler.Kill(); CodeLock?.Kill(); if (!outputContainer.IsDestroyed) { // Remove rock from output container that keeps it from despawning when emptied outputInventory.GetSlot(outputInventory.capacity - 1).Remove(); // Force kill output bag if there's nothing in it. if (!destroyOutputContainer && OutputInventory.AnyItems()) { // Enable physics on output container outputContainer.GetComponent <Rigidbody>().isKinematic = false; } else { outputContainer.Kill(); } } }
void OnCodeEntered(CodeLock codeLock, BasePlayer player, string code) { if (!(codeLock.GetParentEntity() is BuildingPrivlidge)) { return; } if (codeLock.code == code) { PrintToChat(player, $"<color=#FF7F00>LockSync:</color> {lang.GetMessage("AutoAuthInfo", this, player.UserIDString)}"); } }
// Change OwnerID of entity when codelock is deployed private void OnItemDeployed(Deployer deployer, BaseEntity entity) { if (entity & entity.HasSlot(BaseEntity.Slot.Lock) && entity.GetSlot(BaseEntity.Slot.Lock)) { CodeLock cl = entity.GetSlot(BaseEntity.Slot.Lock).GetComponent <CodeLock>(); if (cl) { entity.OwnerID = deployer.GetOwnerPlayer().userID; } } }
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); } }
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(); }
void doorlimitCMD(BasePlayer player, string command, string[] args) { if (!permission.UserHasPermission(player.UserIDString, permissionNameREMOVE)) { player.ChatMessage(msg("No Perms", player.UserIDString)); return; } if (args.Length == 2) { if (args[0] == "remove") { RaycastHit hitInfo; if (!UnityEngine.Physics.Raycast(player.eyes.HeadRay(), out hitInfo, 3.0f)) { player.ChatMessage(msg("No Entity Found", player.UserIDString)); return; } BaseEntity entity = hitInfo.transform.GetComponentInParent <BaseEntity>(); if (!entity) { return; } CodeLock codelock = entity as CodeLock; if (!codelock) { return; } if (codelock.OwnerID != player.userID) { player.ChatMessage(msg("You Are Not The Owner", player.UserIDString)); return; } BasePlayer targetplayer = FindPlayer(args[1]); if (DoPlayerChecks(codelock, player) == false) { return; } codelock.whitelistPlayers.Remove(targetplayer.userID); player.ChatMessage(msg("Player Removed", player.UserIDString)); } else { player.ChatMessage(msg("Invalid Syntax REMOVE", player.UserIDString)); return; } } else { DoDoorLimitHelp(player); } }
ulong GetCodeLockOwner(CodeLock codelock) { var authorized = ((List <ulong>)whiteListField.GetValue(codelock)); if (authorized.Count > 0) { return(authorized[0]); } if (codelock.OwnerID > 0) { return(codelock.OwnerID); } return(0); }
ulong GetCodeLockOwner(CodeLock codelock) { var authorized = codelock.whitelistPlayers; if (authorized.Count > 0) { return(authorized[0]); } if (codelock.OwnerID > 0) { return(codelock.OwnerID); } return(0); }
private bool RemoveFromWhiteList(CodeLock cl, BasePlayer player) { List <ulong> whitelist = codelockwhitelist.GetValue(cl) as List <ulong>; if (!whitelist.Contains(player.userID)) { return(false); } whitelist.Remove(player.userID); codelockwhitelist.SetValue(cl, whitelist); cl.SendNetworkUpdate(); return(true); }
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); } }
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)); }
void CheckHitObj() { RaycastHit hit; Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out hit, reachRange)) { codeLock = hit.transform.gameObject.GetComponentInParent <CodeLock>(); if (codeLock != null) { string value = hit.transform.name; //버튼의 이름을 숫자로 설정해서 CodeLock의 SetValue 메소들로 보냈어요. codeLock.SetValue(value); } } }
void CheckHitObj() { RaycastHit hit; Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); if (Physics.Raycast(ray, out hit, reachRange)) { codeLock = hit.transform.gameObject.GetComponentInParent <CodeLock>();//Witch codelock is beeing pressed if (codeLock != null) { string value = hit.transform.name; codeLock.SetValue(value); } } }
private bool IsCodeLockSharedWithPlayer(BasePlayer player, CodeLock codeLock) { var ownerID = codeLock.OwnerID; if (ownerID == 0 || ownerID == player.userID) { return(false); } // In case the owner was locked out for some reason if (!IsPlayerAuthorizedToCodeLock(ownerID, codeLock)) { return(false); } var sharingSettings = PluginConfig.SharingSettings; if (sharingSettings.Team && player.currentTeam != 0) { var team = RelationshipManager.Instance.FindTeam(player.currentTeam); if (team != null && team.members.Contains(ownerID)) { return(true); } } if (sharingSettings.Friends && Friends != null) { var friendsResult = Friends.Call("HasFriend", codeLock.OwnerID, player.userID); if (friendsResult is bool && (bool)friendsResult) { return(true); } } if ((sharingSettings.Clan || sharingSettings.ClanOrAlly) && Clans != null) { var clanMethodName = sharingSettings.ClanOrAlly ? "IsMemberOrAlly" : "IsClanMember"; var clanResult = Clans.Call(clanMethodName, ownerID.ToString(), player.UserIDString); if (clanResult is bool && (bool)clanResult) { return(true); } } return(false); }
bool DoPlayerChecks(CodeLock codelock, BasePlayer player) { if (player == null) { player.ChatMessage(msg("No Player Found", player.UserIDString)); return(false); } else if (!codelock.whitelistPlayers.Contains(player.userID)) { player.ChatMessage(msg("Player Not Authed To This Door", player.UserIDString)); return(false); } else { return(true); } }
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 DoorCodeEvent(CodeLock doorLock, BasePlayer player, string entered) { codeLock = doorLock; _entered = entered; Player = Server.GetPlayer(player); }
/// <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); }