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);
}
