void OpenToolCupboard(BasePlayer player, string command, string[] args) { if (!permission.UserHasPermission(player.UserIDString, "tcmanager.openinv") && !player.IsAdmin) { player.ChatMessage(Lang("NoCommandPermission", player.UserIDString)); return; } BuildingPrivlidge privilege = player.GetBuildingPrivilege(); if (!privilege) { player.ChatMessage(Lang("NoBuildingPrivilege", player.UserIDString)); return; } if (!privilege.IsAuthed(player) && !player.IsAdmin) { player.ChatMessage(Lang("NoAuthorization", player.UserIDString)); return; } player.EndLooting(); timer.Once(0.1f, delegate() { LootContainer(player, privilege); }); }
private object OnCupboardAuthorize(BuildingPrivlidge privilege, BasePlayer player) { if (HasPermission(player)) { return(null); } if (!Configuration.EnforceCupboards) { return(null); } if (privilege.authorizedPlayers.Count < Configuration.MaxPlayers) { return(null); } ProcessConfiguration(player, "cupboard"); LogToFile("Cupboard", Lang("logMessage") .Replace("{time}", DateTime.UtcNow.ToShortDateString()) .Replace("{player}", player.displayName) .Replace("{steamID}", player.UserIDString) .Replace("{coordinates}", FormattedCoordinates(player)), this); return(false); }
private bool CupboardAuthCheck(BuildingPrivlidge priv, ulong hitEntityOwnerID) { string hitId = null; string entowner = null; foreach (var auth in priv.authorizedPlayers.Select(x => x.userid).ToArray()) { #if DEBUG hitId = auth.ToString(); entowner = hitEntityOwnerID.ToString(); Puts($"CupboardAuthCheck: Comparing {hitId} to {entowner}"); #endif if (auth == hitEntityOwnerID) { #if DEBUG Puts("CupboardAuthCheck: Entity/block protected by authed cupboard!"); #endif return(true); } } #if DEBUG Puts("CupboardAuthCheck: Entity/block NOT protected by authed cupboard!"); #endif return(false); }
// checks if the player is authorized to damage the entity bool CheckAuthDamage(BaseCombatEntity entity, BasePlayer player) { // check if the player is the owner of the entity if (player.userID == entity.OwnerID) { return(true); // player is the owner, allow damage } // assume no authorization by default bool authed = false; // check for cupboards which overlap the entity var hit = Physics.OverlapBox(entity.transform.position, entity.bounds.extents / 2f, entity.transform.rotation, triggerMask); // loop through cupboards foreach (var ent in hit) { // get cupboard BuildingPrivilidge BuildingPrivlidge privs = ent.GetComponentInParent <BuildingPrivlidge>(); // check if the player is authorized on the cupboard if (privs != null) { if (!privs.IsAuthed(player)) { return(false); // return false if not authorized on any single cupboard which overlaps this entity } else { authed = true; // set authed to true to indicate player is authorized on at least one cupboard } } } return(authed); }
private string GetOwnerPlayer(BuildingPrivlidge priv, ulong id = 0UL) { if (priv == null || !priv.AnyAuthed()) { return(string.Empty); } if (config.General.CupboardSettings.anyAuthed) { for (int i = 0; i < priv.authorizedPlayers.Count; i++) { var player = priv.authorizedPlayers[i]; if (player != null && permission.UserHasPermission(player.userid.ToString(), config.General.permission)) { return(player.userid.ToString()); } } } else { var player = priv.authorizedPlayers.Find(x => x.userid == id); if (player != null) { return(player.userid.ToString()); } } return(string.Empty); }
private bool RemoveFromWhiteList(BuildingPrivlidge cb, BasePlayer player) { if (!cb.IsAuthed(player)) { return(false); } int i = 0; foreach (var authedPlayer in cb.authorizedPlayers) { if (authedPlayer.userid == player.userID) { cb.authorizedPlayers.RemoveAt(i); cb.SendNetworkUpdate(); if (cb.CheckEntity(player)) { player.SetInsideBuildingPrivilege(cb, false); } return(true); } i++; } return(false); }
public void RemoveBuildingPrivilege(BuildingPrivlidge ent) { if (!(ent == null)) { buildingPrivileges.Remove(ent); } }
/////////////////////////////////////////////////////////////// /// <summary> /// Called when the player clears a cupboard /// </summary> /// <param name="privilege"></param> /// <param name="player"></param> /// /////////////////////////////////////////////////////////////// // ReSharper disable once UnusedMember.Local void OnCupboardClearList(BuildingPrivlidge privilege, BasePlayer player) { if (CheckPermission(player, UsePermission, false)) { PrintToChat(player, $"{_pluginConfig.Prefix} {Lang("Cleared", player.UserIDString)}"); } }
static bool CanAuthorize(BuildingPrivlidge cupboard) { var owner = cupboard.authorizedPlayers[0]; var ownerPlayer = RustCore.FindPlayerById(owner.userid); return(ownerPlayer?.isConnected ?? true); }
/// <summary> /// Вызывается, когда игрок что-либо построил /// </summary> /// <param name="plan">Шпатель</param> /// <param name="go">Строение, которое игрок построил</param> void OnEntityBuilt(Planner plan, GameObject go) { if (go == null || plan == null) { return; } BuildingPrivlidge privlidge = go.ToBaseEntity() as BuildingPrivlidge; if (privlidge == null) { return; } var player = plan.GetOwnerPlayer(); if (player == null) { return; } if (ignorePlayers.Contains(player.userID)) { return; } List <ulong> friends = Friends?.Call("ApiGetFriends", player.userID) as List <ulong>; if (friends == null) { return; } CupboardAuth(privlidge, friends); SendReply(player, Messages["deployCupboardMessage"]); }
private IEnumerator SetupIoEntities() { List <IOEntity> ioEntities = BaseNetworkable.serverEntities.OfType <IOEntity>().ToList(); for (int i = 0; i < ioEntities.Count; i++) { IOEntity entity = ioEntities[i]; if (entity.OwnerID == 0) { continue; } if (i % _pluginConfig.RepairsPerFrame == 0) { yield return(null); } BuildingPrivlidge priv = entity.GetBuildingPrivilege(); if (priv == null) { continue; } if (!_ioEntity.ContainsKey(priv.buildingID)) { _ioEntity[priv.buildingID] = new List <IOEntity> { entity }; } else { _ioEntity[priv.buildingID].Add(entity); } } }
/// <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(); } } } } }
public void AddBuildingPrivilege(BuildingPrivlidge ent) { if (!(ent == null) && !buildingPrivileges.Contains(ent)) { buildingPrivileges.Add(ent); } }
/// <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 void SendNotifications() { if ((bool)Config["AutomaticNotificationsEnabled"]) { timer.Repeat(Convert.ToSingle(Config["NotificationIntervalInMinutes"]) * 60, 0, () => { foreach (var player in BasePlayer.activePlayerList) { BuildingPrivlidge priv = player.GetBuildingPrivilege(); if (!priv) { return; } if (!priv.IsAuthed(player) || !player.IsAdmin) { return; } float minutesLeft = priv.GetProtectedMinutes(); if (minutesLeft < Convert.ToSingle(Config["MinutesLeftNeededToSendNotification"]) && minutesLeft > 0f) { PrintToChat(player, String.Format(lang.GetMessage("PrimaryDecayNotification", this, player.UserIDString), minutesLeft)); } else if (minutesLeft == 0f) { PrintToChat(player, lang.GetMessage("FinalDecayNotification", this, player.UserIDString)); } } }); } }
void OnEntitySpawned(BaseNetworkable entity) { if (!init) { return; } if (entity?.net?.ID == null) { return; } if (IsDecayEntity(entity) && !decayEntities.Contains((BaseCombatEntity)entity)) { decayEntities.Add((BaseCombatEntity)entity); } BuildingPrivlidge privlidge = entity as BuildingPrivlidge; if (privlidge != null) { cupboards.Add(privlidge.net.ID); } NextTick(() => { DecayEntity decEnt = entity as DecayEntity; if (decEnt != null) { decEnt.CancelInvoke("RunDecay"); } }); }
// Code stolen from Assembly-CSharp.dll -> BasePlayer.cs public static BuildingPrivlidge GetBuildingPrivilege(OBB obb) { BuildingBlock buildingBlock1 = (BuildingBlock)null; BuildingPrivlidge buildingPrivlidge = (BuildingPrivlidge)null; System.Collections.Generic.List <BuildingBlock> list = Facepunch.Pool.GetList <BuildingBlock>(); Vis.Entities <BuildingBlock>(obb.position, 16f + obb.extents.magnitude, list, 2097152, QueryTriggerInteraction.Collide); for (int index = 0; index < list.Count; ++index) { BuildingBlock buildingBlock2 = list[index]; if (buildingBlock2.IsOlderThan((BaseEntity)buildingBlock1) && (double)obb.Distance(buildingBlock2.WorldSpaceBounds()) <= 16.0) { BuildingManager.Building building = buildingBlock2.GetBuilding(); if (building != null) { BuildingPrivlidge buildingPrivilege = building.GetDominatingBuildingPrivilege(); if (!((UnityEngine.Object)buildingPrivilege == (UnityEngine.Object)null)) { buildingBlock1 = buildingBlock2; buildingPrivlidge = buildingPrivilege; } } } } Facepunch.Pool.FreeList <BuildingBlock>(ref list); return(buildingPrivlidge); }
private void OnEntityKill(BuildingPrivlidge entity) { if (IDData.IDs.ContainsKey(entity.net.ID)) { IDData.IDs.Remove(entity.net.ID); } }
void TcstatusCommand(BasePlayer player, string command, string[] args) { if (!permission.UserHasPermission(player.UserIDString, "decaynotifications.use")) { PrintToChat(player, lang.GetMessage("NoPermission", this, player.UserIDString)); return; } BuildingPrivlidge priviledge = player.GetBuildingPrivilege(); if (!priviledge) { PrintToChat(player, lang.GetMessage("NoPriviledge", this, player.UserIDString)); return; } if (!priviledge.IsAuthed(player) || !player.IsAdmin) { return; } float minutesLeft = priviledge.GetProtectedMinutes(); if (minutesLeft > 0f) { PrintToChat(player, String.Format(lang.GetMessage("PrimaryDecayNotification", this, player.UserIDString), minutesLeft)); } else if (minutesLeft == 0) { PrintToChat(player, lang.GetMessage("FinalDecayNotification", this, player.UserIDString)); } return; }
private void OnItemDeployed(Deployer deployer, BaseEntity entity) { BuildingPrivlidge cupboard = entity as BuildingPrivlidge; if (cupboard == null) { return; } BasePlayer player = deployer.ToPlayer(); if (config.RestrictToolCupboards && player != null) { IEnumerable <KeyValuePair <uint, List <PlayerNameID> > > cupboards = toolCupboards.Where(c => c.Value.Contains(new PlayerNameID { userid = player.userID })); if (cupboards.Count() > config.MaxToolCupboards) { cupboard.Kill(); Message(player.IPlayer, "MaxToolCupboards", config.MaxToolCupboards); } } else { if (!toolCupboards.ContainsKey(cupboard.net.ID)) { toolCupboards.Add(cupboard.net.ID, cupboard.authorizedPlayers); } } }
private void AuthToCupboard(BuildingPrivlidge cupboard, Dictionary <ulong, string> authList, BasePlayer player = null) { IEnumerable <ulong> currentAuth = cupboard.authorizedPlayers.Select(x => x.userid); foreach (var friend in authList) { if (currentAuth.Contains(friend.Key)) { continue; } cupboard.authorizedPlayers.Add(new ProtoBuf.PlayerNameID { userid = friend.Key, username = friend.Value, ShouldPool = true }); } cupboard.SendNetworkUpdateImmediate(); if (player != null) { player.SendNetworkUpdateImmediate(); SendReply(player, string.Format(msg("cupboardSuccess"), authList.Count)); } }
void TryLoadInfo(AreaInfo info) { BuildingPrivlidge cupboard = null; if (info.CupboardId != null) { cupboard = BaseNetworkable.serverEntities.Find((uint)info.CupboardId) as BuildingPrivlidge; if (cupboard == null) { Instance.Log($"[LOAD] Area {Id}: Cupboard entity {info.CupboardId} not found, treating as unclaimed"); return; } } if (info.FactionId != null) { Faction faction = Instance.Factions.Get(info.FactionId); if (faction == null) { Instance.Log($"[LOAD] Area {Id}: Claimed by unknown faction {info.FactionId}, treating as unclaimed"); return; } } Name = info.Name; Type = info.Type; FactionId = info.FactionId; ClaimantId = info.ClaimantId; ClaimCupboard = cupboard; if (FactionId != null) { Instance.Log($"[LOAD] Area {Id}: Claimed by {FactionId}, type = {Type}, cupboard = {Util.Format(ClaimCupboard)}"); } }
private void Split(BuildingManager.Building building) { while (building.HasBuildingBlocks()) { BuildingBlock buildingBlock = building.buildingBlocks.get_Item(0); uint newID = BuildingManager.server.NewBuildingID(); Action <BuildingBlock> action = (Action <BuildingBlock>)(b => b.AttachToBuilding(newID)); buildingBlock.EntityLinkBroadcast <BuildingBlock>(action); } while (building.HasBuildingPrivileges()) { BuildingPrivlidge buildingPrivlidge = building.buildingPrivileges.get_Item(0); BuildingBlock nearbyBuildingBlock = buildingPrivlidge.GetNearbyBuildingBlock(); buildingPrivlidge.AttachToBuilding(Object.op_Implicit((Object)nearbyBuildingBlock) ? nearbyBuildingBlock.buildingID : 0U); } while (building.HasDecayEntities()) { DecayEntity decayEntity = building.decayEntities.get_Item(0); BuildingBlock nearbyBuildingBlock = decayEntity.GetNearbyBuildingBlock(); decayEntity.AttachToBuilding(Object.op_Implicit((Object)nearbyBuildingBlock) ? nearbyBuildingBlock.buildingID : 0U); } if (!ConVar.AI.nav_carve_use_building_optimization) { return; } building.isNavMeshCarvingDirty = true; int ticks = 2; this.UpdateNavMeshCarver(building, ref ticks, 0); }
void AuthorizePlayer(BasePlayer player, string command, string[] args) { if (!permission.UserHasPermission(player.UserIDString, "tcmanager.auth") && !player.IsAdmin) { player.ChatMessage(Lang("NoCommandPermission", player.UserIDString)); return; } BuildingPrivlidge privilege = player.GetBuildingPrivilege(); if (!privilege) { player.ChatMessage(Lang("NoBuildingPrivilege", player.UserIDString)); return; } if (!privilege.IsAuthed(player)) { player.ChatMessage(Lang("NoAuthorization", player.UserIDString)); return; } if (args.Length == 0) { player.ChatMessage(Lang("AuthUsage", player.UserIDString)); return; } List <BasePlayer> playerList = FindPlayer(args[0]); if (playerList.Count == 1) { BasePlayer newPlayer = playerList[0]; privilege.authorizedPlayers.Add(new ProtoBuf.PlayerNameID() { userid = newPlayer.userID, username = newPlayer.displayName }); privilege.SendNetworkUpdateImmediate(); player.ChatMessage(Lang("AuthorizePlayer", player.UserIDString, newPlayer.displayName)); if (MasterLock) { MasterLock.Call("AddAuthorization", privilege, newPlayer, player); } } else if (playerList.Count == 0) { player.ChatMessage(Lang("PlayerNotFound", player.UserIDString, args[0].ToString())); } else { String playerNames = String.Empty; foreach (BasePlayer bPlayer in playerList) { if (!String.IsNullOrEmpty(playerNames)) { playerNames += ", "; } playerNames += bPlayer.displayName; } player.ChatMessage(Lang("MultiplePlayers", player.UserIDString, playerNames)); } }
static bool CanAuthorize(BuildingPrivlidge cupboard) { foreach (var authorized in cupboard.authorizedPlayers) { return(BasePlayer.Find(authorized.userid.ToString())); } return(false); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// Building Privilege Search /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// Dictionary <string, object> GetBuildingPrivilegeData(BuildingPrivlidge bp) { var bpdata = new Dictionary <string, object>(); bpdata.Add("pos", bp.transform.position); return(bpdata); }
public void RemoveBuildingPrivilege(BuildingPrivlidge ent) { if (Object.op_Equality((Object)ent, (Object)null)) { return; } this.buildingPrivileges.Remove(ent); }
void OnCupboardClearList(BuildingPrivlidge privlidge, BasePlayer player) { timer.Once(0.1f, () => UseBuildingImage(player)); foreach (var p in privlidge.authorizedPlayers.Select(p => BasePlayer.FindByID(p.userid)).Where(p => p != null)) { timer.Once(0.1f, () => UseBuildingImage(p)); } }
public void RemoveBuildingPrivilege(BuildingPrivlidge ent) { if (ent == null) { return; } this.buildingPrivileges.Remove(ent); }
public void AddBuildingPrivilege(BuildingPrivlidge ent) { if (Object.op_Equality((Object)ent, (Object)null) || this.buildingPrivileges.Contains(ent)) { return; } this.buildingPrivileges.Add(ent); }
public Array UserIDsFromBuildingPrivlidge(BuildingPrivlidge buildingpriv) { return buildingpriv.authorizedPlayers.Select(eid => eid.userid.ToString()).ToArray(); }
private object IOnCupboardDeauthorize(BuildingPrivlidge priviledge, BaseEntity.RPCMessage msg) { return Interface.CallHook("OnCupboardDeauthorize", priviledge, msg.player); }
private void GetToolCupboardUsers(BasePlayer player, BuildingPrivlidge cupboard) { SendReply(player, string.Format("{0} - {1} {2} {3}",Toolcupboard,Math.Round(cupboard.transform.position.x).ToString(),Math.Round(cupboard.transform.position.y).ToString(),Math.Round(cupboard.transform.position.z).ToString())); if (cupboard.authorizedPlayers.Count == 0) { SendReply(player, noCupboardPlayers); return; } foreach (ProtoBuf.PlayerNameID pnid in cupboard.authorizedPlayers) { SendReply(player, string.Format("{0} - {1}", pnid.username.ToString(), pnid.userid.ToString())); } }