C#:
using Facepunch;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Oxide.Core;
using Oxide.Core.Configuration;
using Oxide.Core.Plugins;
using Oxide.Game.Rust.Cui;
using Rust;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using JetBrains.Annotations;
using UnityEngine;
using Debug = UnityEngine.Debug;
namespace Oxide.Plugins {
[Info("Zone Manager", "k1lly0u", "3.1.2")]
[Description("An advanced management system for creating in-game zones")]
public class ZoneManager : RustPlugin {
#region Fields
[PluginReference]
Plugin Backpacks, PopupNotifications, Spawns;
private StoredData storedData;
private DynamicConfigFile data;
private readonly Hash<string, Zone> zones = new Hash<string, Zone>();
private readonly Hash<ulong, EntityZones> zonedPlayers = new Hash<ulong, EntityZones>();
private readonly Hash<NetworkableId, EntityZones> zonedEntities = new Hash<NetworkableId, EntityZones>();
private readonly Dictionary<ulong, string> lastPlayerZone = new Dictionary<ulong, string>();
private readonly ZoneFlags globalFlags = new ZoneFlags();
private readonly ZoneFlags adminBypass = new ZoneFlags();
private static readonly ZoneFlags tempFlags = new ZoneFlags();
private static readonly StringBuilder sb = new StringBuilder();
private bool zonesInitialized = false;
private static ZoneManager Instance {
get;
set;
}
private const string PERMISSION_ZONE = "zonemanager.zone";
private const string PERMISSION_IGNORE_FLAG = "zonemanager.ignoreflag.";
private const int PLAYER_MASK = 131072;
private const int TARGET_LAYERS = ~(1 << 10 | 1 << 18 | 1 << 28 | 1 << 29);
#endregion
#region Oxide Hooks
private void Init() {
Instance = this;
adminBypass.SetFlags(ZoneFlags.NoBuild, ZoneFlags.NoDeploy, ZoneFlags.NoCup, ZoneFlags.NoUpgrade, ZoneFlags.NoChat, ZoneFlags.NoVoice, ZoneFlags.KillSleepers, ZoneFlags.EjectSleepers, ZoneFlags.NoSignUpdates);
lang.RegisterMessages(Messages, this);
permission.RegisterPermission(PERMISSION_ZONE, this);
foreach (string flag in ZoneFlags.NameToIndex.Keys) permission.RegisterPermission(PERMISSION_IGNORE_FLAG + flag.ToLower(), this);
LoadData();
}
private void OnServerInitialized() {
InitializeZones();
InitializeUpdateBehaviour();
}
private void OnTerrainInitialized() => InitializeZones();
private void OnPlayerConnected(BasePlayer player) => updateBehaviour.QueueUpdate(player);
private void OnEntityKill(BaseEntity baseEntity) {
if (!baseEntity || !baseEntity.IsValid() || baseEntity.IsDestroyed) return;
EntityZones entityZones;
if (zonedEntities.TryGetValue(baseEntity.net.ID, out entityZones)) {
for (int i = entityZones.Zones.Count - 1; i >= 0; i--) {
Zone zone = entityZones.Zones.ElementAt(i);
if (zone) zone.OnEntityExitZone(baseEntity, false, true);
}
zonedEntities.Remove(baseEntity.net.ID);
}
}
private void Unload() {
DestroyUpdateBehaviour();
foreach (BasePlayer player in BasePlayer.activePlayerList) CuiHelper.DestroyUi(player, ZMUI);
foreach (KeyValuePair<string, Zone> kvp in zones) UnityEngine.Object.DestroyImmediate(kvp.Value.gameObject);
zones.Clear();
Instance = null;
Configuration = null;
}
#endregion
#region UpdateQueue
private UpdateBehaviour updateBehaviour;
private void InitializeUpdateBehaviour() {
updateBehaviour = new GameObject("ZoneManager.UpdateBehaviour").AddComponent<UpdateBehaviour>();
foreach (BasePlayer player in BasePlayer.activePlayerList) updateBehaviour.QueueUpdate(player);
}
private void DestroyUpdateBehaviour() {
if (updateBehaviour != null) UnityEngine.Object.Destroy(updateBehaviour.gameObject);
}
// Queue and check players for new zones and that they are still in old zones.Previously any plugin that put a player to sleep and teleports them out of a zone
// without calling the OnPlayerSleep hook would bypass a player zone update which would result in players being registered in zones they were no longer in.// Options are to either continually check and update players, or have every plugin that teleports players call the hook...private class UpdateBehaviour : MonoBehaviour
{
private readonly System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
private readonly Queue<BasePlayer> playerUpdateQueue = new Queue<BasePlayer>();
private const float MAX_MS = 0.25f;
private void OnDestroy() {
playerUpdateQueue.Clear();
}
public void QueueUpdate(BasePlayer player) {
if (!playerUpdateQueue.Contains(player)) playerUpdateQueue.Enqueue(player);
}
public void Reset() => playerUpdateQueue.Clear();
private void Update() {
if (Time.frameCount % 10 != 0) return;
sw.Reset();
sw.Start();
while (playerUpdateQueue.Count > 0) {
if (sw.Elapsed.TotalMilliseconds >= MAX_MS) {
sw.Stop();
return;
}
BasePlayer player = playerUpdateQueue.Dequeue();
if (!player || !player.IsConnected) continue;
Instance?.UpdatePlayerZones(player);
InvokeHandler.Invoke(this, () => QueueUpdate(player), 2f);
}
}
}
#endregion
#region Flag Hooks
private void OnEntityBuilt(Planner planner, GameObject gameObject) {
if (!planner || !gameObject) return;
BasePlayer player = planner.GetOwnerPlayer();
if (!player) return;
BaseEntity entity = gameObject.ToBaseEntity();
if (!entity) return;
if (entity is BuildingBlock) {
if (HasPlayerFlag(player, ZoneFlags.NoBuild)) {
List<ItemAmount> list = (entity as BuildingBlock).BuildCost();
entity.Invoke(() => {
if (list != null) {
for (int i = 0; i < list.Count; i++) {
ItemAmount itemAmount = list[i];
player.GiveItem(ItemManager.Create(itemAmount.itemDef, Mathf.Clamp(Mathf.RoundToInt(itemAmount.amount), 1, int.MaxValue)));
}
}
if (entity && !entity.IsDestroyed) entity.Kill(BaseNetworkable.DestroyMode.Gib);
}
, 0.1f);
SendMessage(player, Message("noBuild", player.UserIDString));
}
}
else if (entity is SimpleBuildingBlock) {
if (HasPlayerFlag(player, ZoneFlags.NoBuild)) {
KillEntityAndReturnItem(player, entity, planner.GetItem());
SendMessage(player, Message("noBuild", player.UserIDString));
}
}
else {
if (entity is BuildingPrivlidge) {
if (HasPlayerFlag(player, ZoneFlags.NoCup)) {
KillEntityAndReturnItem(player, entity, planner.GetItem());
SendMessage(player, Message("noCup", player.UserIDString));
}
}
else {
if (HasPlayerFlag(player, ZoneFlags.NoDeploy)) {
KillEntityAndReturnItem(player, entity, planner.GetItem());
SendMessage(player, Message("noDeploy", player.UserIDString));
}
}
}
}
private object OnStructureUpgrade(BuildingBlock buildingBlock, BasePlayer player, BuildingGrade.Enum grade) {
if (HasPlayerFlag(player, ZoneFlags.NoUpgrade)) {
SendMessage(player, Message("noUpgrade", player.UserIDString));
return true;
}
return null;
}
private void OnItemDeployed(Deployer deployer, ItemModDeployable itemModDeployable, BaseEntity deployedEntity) // DoDeploy_Regular
{
BasePlayer player = deployer.GetOwnerPlayer();
if (!player) return;
if (HasPlayerFlag(player, ZoneFlags.NoDeploy)) {
KillEntityAndReturnItem(player, deployedEntity, deployer.GetItem());
SendMessage(player, Message("noDeploy", player.UserIDString));
}
}
private void OnItemDeployed(Deployer deployer, BaseEntity parentEntity, BaseEntity deployedEntity) // DoDeploy_Slot
{
BasePlayer player = deployer.GetOwnerPlayer();
if (!player) return;
if (HasPlayerFlag(player, ZoneFlags.NoDeploy)) {
KillEntityAndReturnItem(player, deployedEntity, deployer.GetItem());
SendMessage(player, Message("noDeploy", player.UserIDString));
}
}
private void KillEntityAndReturnItem(BasePlayer player, BaseEntity entity, Item item) {
ItemDefinition itemDefinition = item == null ? null : item.info;
int amount = item.amount;
ulong skin = item == null ? 0UL : item.skin;
entity.Invoke(() => {
if (entity && !entity.IsDestroyed) entity.Kill(BaseNetworkable.DestroyMode.Gib);
if (itemDefinition != null) player.GiveItem(ItemManager.Create(itemDefinition, amount, skin));
}
, 0.1f);
}
private void OnItemUse(Item item, int amount) {
BaseEntity entity = item?.parent?.entityOwner;
if (!entity) return;
if (entity is FlameTurret || entity is AutoTurret || entity is GunTrap) {
if (HasEntityFlag(entity, ZoneFlags.InfiniteTrapAmmo)) item.amount += amount;
return;
}
if (entity is SearchLight) {
if (HasEntityFlag(entity, ZoneFlags.AlwaysLights)) {
item.amount += amount;
return;
}
if (HasEntityFlag(entity, ZoneFlags.AutoLights)) {
if (TOD_Sky.Instance.Cycle.Hour > Configuration.AutoLights.OnTime || TOD_Sky.Instance.Cycle.Hour < Configuration.AutoLights.OffTime) item.amount += amount;
}
}
}
private object OnPlayerChat(BasePlayer player, string message, ConVar.Chat.ChatChannel channel) {
if (!player) return null;
if (HasPlayerFlag(player, ZoneFlags.NoChat)) {
SendMessage(player, Message("noChat", player.UserIDString));
return true;
}
return null;
}
private object OnBetterChat(Oxide.Core.Libraries.Covalence.IPlayer iPlayer, string message) {
BasePlayer player = iPlayer.Object as BasePlayer;
return OnPlayerChat(player, message, ConVar.Chat.ChatChannel.Global);
}
private object OnPlayerVoice(BasePlayer player, Byte[] data) {
if (HasPlayerFlag(player, ZoneFlags.NoVoice)) {
SendMessage(player, Message("noVoice", player.UserIDString));
return true;
}
return null;
}
private object OnServerCommand(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
if (!player || string.IsNullOrEmpty(arg.cmd?.Name)) return null;
if (arg.cmd.Name == "kill" && HasPlayerFlag(player, ZoneFlags.NoSuicide)) {
SendMessage(player, Message("noSuicide", player.UserIDString));
return true;
}
return null;
}
private void OnPlayerDisconnected(BasePlayer player) {
if (!player) return;
if (HasPlayerFlag(player, ZoneFlags.KillSleepers)) {
player.Die();
return;
}
if (HasPlayerFlag(player, ZoneFlags.EjectSleepers)) {
EntityZones entityZones;
if (!zonedPlayers.TryGetValue(player.userID, out entityZones) || entityZones.Count == 0) return;
for (int i = 0; i < entityZones.Count; i++) {
Zone zone = entityZones.Zones.ElementAt(i);
if (!zone) continue;
if (HasFlag(zone, ZoneFlags.EjectSleepers)) {
EjectPlayer(player, zone);
return;
}
}
}
}
private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitinfo) {
if (!entity || entity.GetComponent<ResourceDispenser>() != null) return null;
BasePlayer attacker = hitinfo.InitiatorPlayer;
BasePlayer victim = entity as BasePlayer;
if (victim != null) {
if (hitinfo.damageTypes.GetMajorityDamageType() == DamageType.Fall) {
if (HasPlayerFlag(victim, ZoneFlags.NoFallDamage)) return true;
}
if (victim.IsSleeping() && HasPlayerFlag(victim, ZoneFlags.SleepGod)) return true;
if (attacker != null) {
if (IsNpc(victim)) return null;
if (HasPlayerFlag(victim, ZoneFlags.PvpGod)) {
if (attacker == victim && hitinfo.damageTypes.GetMajorityDamageType() == DamageType.Suicide) {
if (HasPlayerFlag(victim, ZoneFlags.NoSuicide)) return true;
return null;
}
if (IsNpc(attacker) && Configuration.NPCHurtPvpGod) return null;
return true;
}
else if (HasPlayerFlag(attacker, ZoneFlags.PvpGod) && !IsNpc(attacker)) return true;
}
else if (HasPlayerFlag(victim, ZoneFlags.PveGod) && !IsNpc(victim)) return true;
else if (hitinfo.Initiator is FireBall && HasPlayerFlag(victim, ZoneFlags.PvpGod)) return true;
return null;
}
BaseNpc baseNpc = entity as BaseNpc;
if (baseNpc) {
if (HasEntityFlag(baseNpc, ZoneFlags.NoPve)) {
if (attacker && CanBypass(attacker, ZoneFlags.NoPve)) return null;
return true;
}
return null;
}
if (entity is BuildingBlock || entity is SimpleBuildingBlock) {
if (attacker && HasEntityFlag(entity, ZoneFlags.NoBuildingDamage) && !CanBypass(attacker, ZoneFlags.NoBuildingDamage)) return true;
}
if (!(entity is LootContainer) && !(entity is BaseHelicopter)) {
if (HasEntityFlag(entity, ZoneFlags.UnDestr)) {
if (attacker && CanBypass(attacker, ZoneFlags.UnDestr)) return null;
if (hitinfo.damageTypes.GetMajorityDamageType() == DamageType.Decay && Configuration.DecayDamageUndestr) return null;
return true;
}
}
return null;
}
private void OnEntitySpawned(BaseNetworkable baseNetworkable) {
if (baseNetworkable is BaseEntity) timer.In(2, () => CanSpawn(baseNetworkable as BaseEntity));
}
private void CanSpawn(BaseEntity baseEntity) {
if (!baseEntity.IsValid() || baseEntity.IsDestroyed) return;
if (Interface.CallHook("CanSpawnInZone", baseEntity) != null) return;
if (baseEntity is BaseCorpse) {
if (HasEntityFlag(baseEntity, ZoneFlags.NoCorpse) && !CanBypass((baseEntity as BaseCorpse).OwnerID, ZoneFlags.NoCorpse)) baseEntity.Invoke(() => baseEntity.Kill(BaseNetworkable.DestroyMode.None), 0.1f);
}
if (baseEntity is LootContainer || baseEntity is JunkPile) {
if (HasEntityFlag(baseEntity, ZoneFlags.NoLootSpawns)) baseEntity.Invoke(() => baseEntity.Kill(BaseNetworkable.DestroyMode.None), 0.1f);
}
else if (baseEntity is BaseNpc || baseEntity is NPCPlayer) {
if (HasEntityFlag(baseEntity, ZoneFlags.NoNPCSpawns)) baseEntity.Invoke(() => baseEntity.Kill(BaseNetworkable.DestroyMode.None), 0.1f);
}
else if (baseEntity is DroppedItem || baseEntity is WorldItem) {
if (HasEntityFlag(baseEntity, ZoneFlags.NoDrop)) {
(baseEntity as WorldItem).item.Remove(0f);
baseEntity.Invoke(() => baseEntity.Kill(BaseNetworkable.DestroyMode.None), 0.1f);
}
}
else if (baseEntity is DroppedItemContainer) {
if (HasEntityFlag(baseEntity, ZoneFlags.NoDrop)) baseEntity.Invoke(() => baseEntity.Kill(BaseNetworkable.DestroyMode.None), 0.1f);
}
}
private object CanBeWounded(BasePlayer player, HitInfo hitinfo) => HasPlayerFlag(player, ZoneFlags.NoWounded) ? (object)false : null;
private object CanUpdateSign(BasePlayer player, Signage sign) {
if (HasPlayerFlag(player, ZoneFlags.NoSignUpdates)) {
SendMessage(player, Message("noSignUpdates", player.UserIDString));
return false;
}
return null;
}
private object OnOvenToggle(BaseOven oven, BasePlayer player) {
if (HasPlayerFlag(player, ZoneFlags.NoOvenToggle)) {
SendMessage(player, Message("noOvenToggle", player.UserIDString));
return true;
}
return null;
}
private object CanUseVending(BasePlayer player, VendingMachine machine) {
if (HasPlayerFlag(player, ZoneFlags.NoVending)) {
SendMessage(player, Message("noVending", player.UserIDString));
return false;
}
return null;
}
private object CanHideStash(BasePlayer player, StashContainer stash) {
if (HasPlayerFlag(player, ZoneFlags.NoStash)) {
SendMessage(player, Message("noStash", player.UserIDString));
return false;
}
return null;
}
private object CanCraft(ItemCrafter itemCrafter, ItemBlueprint bp, int amount) {
BasePlayer player = itemCrafter.GetComponent<BasePlayer>();
if (player && HasPlayerFlag(player, ZoneFlags.NoCraft)) {
SendMessage(player, Message("noCraft", player.UserIDString));
return false;
}
return null;
}
private void OnDoorOpened(Door door, BasePlayer player) {
if (HasPlayerFlag(player, ZoneFlags.NoDoorAccess)) {
SendMessage(player, Message("noDoor", player.UserIDString));
door.CloseRequest();
}
}
private object OnSprayCreate(SprayCan sprayCan, Vector3 position, Quaternion rotation) {
if (!sprayCan) return null;
BasePlayer player = sprayCan.GetOwnerPlayer();
if (!player) return null;
if (HasPlayerFlag(player, ZoneFlags.NoSprays)) {
SendMessage(player, Message("nosprays", player.UserIDString));
return false;
}
return null;
}
#region Looting Hooks
private object CanLootPlayer(BasePlayer target, BasePlayer looter) => OnLootPlayerInternal(looter, target);
private void OnLootPlayer(BasePlayer looter, BasePlayer target) => OnLootPlayerInternal(looter, target);
private object OnLootPlayerInternal(BasePlayer looter, BasePlayer target) {
if (HasPlayerFlag(looter, ZoneFlags.NoPlayerLoot) || (target != null && HasPlayerFlag(target, ZoneFlags.NoPlayerLoot))) {
if (looter == target && Backpacks != null) {
object hookResult = Backpacks.Call("CanLootPlayer", target, looter);
if (hookResult is bool && (bool)hookResult) return true;
}
SendMessage(looter, Message("noLoot", looter.UserIDString));
NextTick(looter.EndLooting);
return false;
}
return null;
}
private void OnLootEntity(BasePlayer player, BaseEntity entity) {
if (entity is LootableCorpse) OnLootCorpse(entity as LootableCorpse, player);
if (entity is DroppedItemContainer) OnLootContainer(entity as DroppedItemContainer, player);
if (entity is StorageContainer) OnLootInternal(player, ZoneFlags.NoBoxLoot);
}
private object CanLootEntity(BasePlayer player, LootableCorpse corpse) {
if (corpse is NPCPlayerCorpse) {
if (HasPlayerFlag(player, ZoneFlags.NoNPCLoot)) {
SendMessage(player, Message("noLoot", player.UserIDString));
return false;
}
return null;
}
if (corpse.playerSteamID == player.userID && HasPlayerFlag(player, ZoneFlags.LootSelf)) return null;
return CanLootInternal(player, ZoneFlags.NoPlayerLoot);
}
private void OnLootCorpse(LootableCorpse corpse, BasePlayer player) {
if (corpse is NPCPlayerCorpse) {
if (HasPlayerFlag(player, ZoneFlags.NoNPCLoot)) {
SendMessage(player, Message("noLoot", player.UserIDString));
NextTick(player.EndLooting);
}
return;
}
if (corpse.playerSteamID == player.userID && HasPlayerFlag(player, ZoneFlags.LootSelf)) return;
OnLootInternal(player, ZoneFlags.NoPlayerLoot);
}
private void OnLootContainer(DroppedItemContainer container, BasePlayer player) {
if (container.playerSteamID == player.userID && HasPlayerFlag(player, ZoneFlags.LootSelf)) return;
OnLootInternal(player, ZoneFlags.NoPlayerLoot);
}
private object CanLootEntity(BasePlayer player, DroppedItemContainer container) {
if (container.playerSteamID == player.userID && HasPlayerFlag(player, ZoneFlags.LootSelf)) return null;
return CanLootInternal(player, ZoneFlags.NoPlayerLoot);
}
private object CanLootEntity(BasePlayer player, StorageContainer container) => CanLootInternal(player, ZoneFlags.NoBoxLoot);
private object CanLootInternal(BasePlayer player, int flag) {
if (player && HasPlayerFlag(player, flag)) {
SendMessage(player, Message("noLoot", player.UserIDString));
return false;
}
return null;
}
private void OnLootInternal(BasePlayer player, int flag) {
if (player && HasPlayerFlag(player, flag)) {
SendMessage(player, Message("noLoot", player.UserIDString));
NextTick(player.EndLooting);
}
}
#endregion
#region Pickup Hooks
private object CanPickupEntity(BasePlayer player, BaseCombatEntity entity) => CanPickupInternal(player, ZoneFlags.NoEntityPickup);
private object CanPickupLock(BasePlayer player, BaseLock baseLock) => CanPickupInternal(player, ZoneFlags.NoEntityPickup);
private object OnItemPickup(Item item, BasePlayer player) => CanPickupInternal(player, ZoneFlags.NoPickup);
private object CanPickupInternal(BasePlayer player, int flag) {
if (HasPlayerFlag(player, flag)) {
SendMessage(player, Message("noPickup", player.UserIDString));
return false;
}
return null;
}
#endregion
#region Gather Hooks
private object CanLootEntity(ResourceContainer container, BasePlayer player) => OnGatherInternal(player);
private object OnCollectiblePickup(Item item, BasePlayer player) => OnGatherInternal(player);
private object OnGrowableGather(GrowableEntity plant, Item item, BasePlayer player) => OnGatherInternal(player);
private object OnDispenserGather(ResourceDispenser dispenser, BasePlayer player, Item item) => OnGatherInternal(player);
private object OnGatherInternal(BasePlayer player) {
if (player && HasPlayerFlag(player, ZoneFlags.NoGather)) {
SendMessage(player, Message("noGather", player.UserIDString));
return true;
}
return null;
}
#endregion
#region Targeting Hooks
private object OnTurretTarget(AutoTurret turret, BasePlayer player) => OnTargetPlayerInternal(player, ZoneFlags.NoTurretTargeting);
private object CanBradleyApcTarget(BradleyAPC apc, BasePlayer player) {
if (player && HasPlayerFlag(player, ZoneFlags.NoAPCTargeting)) return false;
return null;
}
private object CanHelicopterTarget(PatrolHelicopterAI heli, BasePlayer player) {
if (player && HasPlayerFlag(player, ZoneFlags.NoHeliTargeting)) {
heli.interestZoneOrigin = heli.GetRandomPatrolDestination();
return false;
}
return null;
}
private object CanHelicopterStrafeTarget(PatrolHelicopterAI heli, BasePlayer player) {
if (player && HasPlayerFlag(player, ZoneFlags.NoHeliTargeting)) return false;
return null;
}
private object OnHelicopterTarget(HelicopterTurret turret, BasePlayer player) => OnTargetPlayerInternal(player, ZoneFlags.NoHeliTargeting);
private object OnNpcTarget(BaseCombatEntity entity, BasePlayer player) => OnTargetPlayerInternal(player, ZoneFlags.NoNPCTargeting);
private object OnTargetPlayerInternal(BasePlayer player, int flag) {
if (player && HasPlayerFlag(player, flag)) return true;
return null;
}
#endregion
#region Mounting Hooks
private object CanMountEntity(BasePlayer player, BaseMountable entity) {
if (!player || !entity) return null;
if (!entity.VehicleParent()) return null;
if (HasPlayerFlag(player, ZoneFlags.NoVehicleMounting)) {
SendMessage(player, Message("novehiclemounting", player.UserIDString));
return false;
}
return null;
}
private object CanDismountEntity(BasePlayer player, BaseMountable entity) {
if (!player || !entity) return null;
if (!entity.VehicleParent()) return null;
if (HasPlayerFlag(player, ZoneFlags.NoVehicleDismounting)) {
SendMessage(player, Message("novehicledismounting", player.UserIDString));
return false;
}
return null;
}
#endregion
#region Additional KillSleeper Checks
private void OnPlayerSleep(BasePlayer player) {
if (!player) return;
//player.Invoke(()=> UpdatePlayerZones(player), 1f); // Manually update the zones a player is in.Sleeping players don't trigger OnTriggerEnter or OnTriggerExit
timer.In(2f, () => {
if (!player || !player.IsSleeping()) return;
if (!player.IsConnected) {
if (HasPlayerFlag(player, ZoneFlags.KillSleepers)) {
player.Invoke(() => KillSleepingPlayer(player), 3f);
return;
}
if (HasPlayerFlag(player, ZoneFlags.EjectSleepers)) {
player.Invoke(() => {
if (!player || !player.IsSleeping()) return;
EntityZones entityZones;
if (!zonedPlayers.TryGetValue(player.userID, out entityZones) || entityZones.Count == 0) return;
for (int i = 0; i < entityZones.Count; i++) {
Zone zone = entityZones.Zones.ElementAt(i);
if (!zone) return;
if (HasFlag(zone, ZoneFlags.EjectSleepers)) {
EjectPlayer(player, zone);
}
}
}
, 3f);
}
}
}
);
}
private void OnPlayerSleepEnd(BasePlayer player) {
if (!updateBehaviour) {
Debug.LogError("[ZoneManager] UpdateBehaviour is null.Report this on uMod");
return;
}
updateBehaviour.QueueUpdate(player);
}
private void KillSleepingPlayer(BasePlayer player) {
if (!player || !player.IsSleeping()) return;
if (HasPlayerFlag(player, ZoneFlags.KillSleepers)) {
if (player.IsConnected) OnPlayerSleep(player);
else player.Die();
}
}
private void UpdatePlayerZones(BasePlayer player) {
if (!player) return;
EntityZones entityZones;
if (zonedPlayers.TryGetValue(player.userID, out entityZones)) {
for (int i = entityZones.Count - 1; i >= 0; i--) {
Zone zone = entityZones.Zones.ElementAt(i);
if (!zone || !zone.definition.Enabled) continue;
if (zone.definition.Size != Vector3.zero) {
if (!IsInsideBounds(zone, player.transform.position)) OnPlayerExitZone(player, zone);
}
else {
if (Vector3.Distance(player.transform.position, zone.transform.position) > zone.definition.Radius) OnPlayerExitZone(player, zone);
}
}
}
for (int i = 0; i < zones.Count; i++) {
Zone zone = zones.ElementAt(i).Value;
if (!zone) continue;
if (entityZones != null && entityZones.Zones.Contains(zone)) continue;
if (zone.definition.Size != Vector3.zero) {
if (IsInsideBounds(zone, player.transform.position)) OnPlayerEnterZone(player, zone);
}
else {
if (Vector3.Distance(player.transform.position, zone.transform.position) <= zone.definition.Radius) OnPlayerEnterZone(player, zone);
}
}
if (player.HasPlayerFlag(BasePlayer.PlayerFlags.SafeZone) && !player.InSafeZone()) player.SetPlayerFlag(BasePlayer.PlayerFlags.SafeZone, false);
}
private bool IsInsideBounds(Zone zone, Vector3 worldPos) => zone?.collider?.ClosestPoint(worldPos) == worldPos;
#endregion
#endregion
#region Zone Functions
private void InitializeZones() {
if (zonesInitialized) return;
foreach (Zone.Definition definition in storedData.definitions) CreateZone(definition);
foreach (Zone zone in zones.Values) zone.FindZoneParent();
zonesInitialized = true;
UnsubscribeAll();
UpdateHookSubscriptions();
}
private void CreateZone(Zone.Definition definition) {
Zone zone = new GameObject().AddComponent<Zone>();
zone.InitializeZone(definition);
zones.Add(definition.Id, zone);
}
private static bool ReverseVelocity(BaseVehicle baseVehicle) {
if (baseVehicle is BaseVehicleModule) baseVehicle = (baseVehicle as BaseVehicleModule).Vehicle;
if (baseVehicle && baseVehicle.IsVehicleRoot() && baseVehicle.rigidBody) {
if (baseVehicle.AnyMounted() && baseVehicle is BaseHelicopterVehicle) {
baseVehicle.rigidBody.velocity *= -1f;
Vector3 euler = baseVehicle.transform.eulerAngles;
baseVehicle.transform.rotation = Quaternion.Euler(euler.x, euler.y - 180f, euler.z);
}
else {
Vector3 force = (baseVehicle.rigidBody.velocity.normalized * -1f) * baseVehicle.rigidBody.mass * 4f;
baseVehicle.rigidBody.velocity = Vector3.zero;
baseVehicle.rigidBody.AddForce(force, ForceMode.Impulse);
}
return true;
}
return false;
}
private void EjectPlayer(BasePlayer player, Zone zone) {
if (zone.keepInList.Contains(player.userID) || zone.whitelist.Contains(player.userID)) return;
if (!string.IsNullOrEmpty(zone.definition.Permission)) {
if (HasPermission(player, zone.definition.Permission)) return;
}
if (player.isMounted && ReverseVelocity(player.GetMountedVehicle())) {
SendMessage(player, Message("eject", player.UserIDString));
return;
}
Vector3 position = Vector3.zero;
if (Spawns && !string.IsNullOrEmpty(zone.definition.EjectSpawns)) {
object success = Spawns.Call("GetRandomSpawn", zone.definition.EjectSpawns);
if (success is Vector3) position = (Vector3)success;
}
if (position == Vector3.zero) {
float distance;
if (zone.definition.Size != Vector3.zero) distance = Mathf.Max(zone.definition.Size.x, zone.definition.Size.z);
else distance = zone.definition.Radius;
position = zone.transform.position + (((player.transform.position.XZ3D() - zone.transform.position.XZ3D()).normalized) * (distance + 10f));
RaycastHit rayHit;
if (Physics.Raycast(new Ray(new Vector3(position.x, position.y + 300, position.z), Vector3.down), out rayHit, 500, TARGET_LAYERS, QueryTriggerInteraction.Ignore)) position.y = rayHit.point.y;
else position.y = TerrainMeta.HeightMap.GetHeight(position);
}
player.MovePosition(position);
player.ClientRPCPlayer(null, player, "ForcePositionTo", player.transform.position);
player.SendNetworkUpdateImmediate();
SendMessage(player, Message("eject", player.UserIDString));
}
private void AttractPlayer(BasePlayer player, Zone zone) {
if (player.isMounted && ReverseVelocity(player.GetMountedVehicle())) {
SendMessage(player, Message("attract", player.UserIDString));
return;
}
float distance;
if (zone.definition.Size != Vector3.zero) distance = Mathf.Max(zone.definition.Size.x, zone.definition.Size.z);
else distance = zone.definition.Radius;
Vector3 position = zone.transform.position + (player.transform.position - zone.transform.position).normalized * (distance - 5f);
position.y = TerrainMeta.HeightMap.GetHeight(position);
player.MovePosition(position);
player.ClientRPCPlayer(null, player, "ForcePositionTo", player.transform.position);
player.SendNetworkUpdateImmediate();
SendMessage(player, Message("attract", player.UserIDString));
}
private void ShowZone(BasePlayer player, string zoneId, float time = 30) {
Zone zone = GetZoneByID(zoneId);
if (!zone) return;
if (zone.definition.Size != Vector3.zero) {
Vector3 center = zone.definition.Location;
Quaternion rotation = Quaternion.Euler(zone.definition.Rotation);
Vector3 size = zone.definition.Size / 2;
Vector3 point1 = RotatePointAroundPivot(new Vector3(center.x + size.x, center.y + size.y, center.z + size.z), center, rotation);
Vector3 point2 = RotatePointAroundPivot(new Vector3(center.x + size.x, center.y - size.y, center.z + size.z), center, rotation);
Vector3 point3 = RotatePointAroundPivot(new Vector3(center.x + size.x, center.y + size.y, center.z - size.z), center, rotation);
Vector3 point4 = RotatePointAroundPivot(new Vector3(center.x + size.x, center.y - size.y, center.z - size.z), center, rotation);
Vector3 point5 = RotatePointAroundPivot(new Vector3(center.x - size.x, center.y + size.y, center.z + size.z), center, rotation);
Vector3 point6 = RotatePointAroundPivot(new Vector3(center.x - size.x, center.y - size.y, center.z + size.z), center, rotation);
Vector3 point7 = RotatePointAroundPivot(new Vector3(center.x - size.x, center.y + size.y, center.z - size.z), center, rotation);
Vector3 point8 = RotatePointAroundPivot(new Vector3(center.x - size.x, center.y - size.y, center.z - size.z), center, rotation);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point1, point2);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point1, point3);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point1, point5);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point4, point2);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point4, point3);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point4, point8);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point5, point6);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point5, point7);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point6, point2);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point8, point6);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point8, point7);
player.SendConsoleCommand("ddraw.line", time, Color.blue, point7, point3);
}
else player.SendConsoleCommand("ddraw.sphere", time, Color.blue, zone.definition.Location, zone.definition.Radius);
}
private Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Quaternion rotation) => rotation * (point - pivot) + pivot;
#endregion
#region Component
public class Zone : MonoBehaviour {
public Definition definition;
public ZoneFlags disabledFlags = new ZoneFlags();
public Zone parent;
public List<BasePlayer> players = Pool.GetList<BasePlayer>();
public List<BaseEntity> entities = Pool.GetList<BaseEntity>();
private List<IOEntity> ioEntities = Pool.GetList<IOEntity>();
public List<ulong> keepInList = Pool.GetList<ulong>();
public List<ulong> whitelist = Pool.GetList<ulong>();
private Rigidbody rigidbody;
public Collider collider;
public Bounds colliderBounds;
private ChildSphereTrigger<TriggerRadiation> radiation;
private ChildSphereTrigger<TriggerComfort> comfort;
private ChildSphereTrigger<TriggerTemperature> temperature;
private ChildSphereTrigger<TriggerSafeZone> safeZone;
private readonly Hash<BaseVehicle, float> lastReversedTimes = new Hash<BaseVehicle, float>();
private int creationFrame;
private bool isTogglingLights = false;
private void Awake() {
gameObject.layer = (int)Layer.Reserved1;
gameObject.name = "ZoneManager";
enabled = false;
creationFrame = Time.frameCount;
}
private void OnDestroy() {
EmptyZone();
Pool.FreeList(ref players);
Pool.FreeList(ref entities);
Pool.FreeList(ref ioEntities);
Pool.FreeList(ref keepInList);
Pool.FreeList(ref whitelist);
}
private void EmptyZone() {
RemovePlayersFromTriggers();
keepInList.Clear();
ioEntities.Clear();
for (int i = players.Count - 1; i >= 0; i--) Instance?.OnPlayerExitZone(players[i], this);
for (int i = entities.Count - 1; i >= 0; i--) Instance?.OnEntityExitZone(entities[i], this);
}
#region Zone Initialization
public void InitializeZone(Definition definition) {
this.definition = definition;
transform.position = definition.Location;
transform.rotation = Quaternion.Euler(definition.Rotation);
if (definition.Enabled) {
RegisterPermission();
InitializeCollider();
InitializeAutoLights();
InitializeRadiation();
InitializeSafeZone();
InitializeComfort();
InitializeTemperature();
RemovePlayersFromTriggers();
AddPlayersToTriggers();
OnZoneFlagsChanged();
}
else {
InvokeHandler.CancelInvoke(this, CheckAlwaysLights);
InvokeHandler.CancelInvoke(this, CheckLights);
if (isLightsOn) ServerMgr.Instance.StartCoroutine(ToggleLights(false));
EmptyZone();
if (collider != null) DestroyImmediate(collider);
if (rigidbody != null) DestroyImmediate(rigidbody);
}
enabled = definition.Enabled;
}
public void FindZoneParent() {
if (string.IsNullOrEmpty(definition.ParentID)) return;
if (Instance == null) {
Debug.LogError($"[ZoneManager] Zone attempted to find parent zone, but plugin instance is null...");
return;
}
Instance.zones.TryGetValue(definition.ParentID, out parent);
}
public void Reset() {
InvokeHandler.CancelInvoke(this, CheckAlwaysLights);
InvokeHandler.CancelInvoke(this, CheckLights);
if (isLightsOn) ServerMgr.Instance.StartCoroutine(ToggleLights(false));
EmptyZone();
InitializeZone(definition);
}
public void OnZoneFlagsChanged() {
if (HasFlag(ZoneFlags.PoweredSwitches)) {
if (!InvokeHandler.IsInvoking(this, IOTick)) InvokeHandler.InvokeRandomized(this, IOTick, 0f, 1f, 0.1f);
}
else InvokeHandler.CancelInvoke(this, IOTick);
}
private void RegisterPermission() {
if (Instance == null) {
Debug.LogError($"[ZoneManager] Zone attempted to register permission, but plugin instance is null...");
return;
}
if (!string.IsNullOrEmpty(definition.Permission) && !Instance.permission.PermissionExists(definition.Permission)) Instance.permission.RegisterPermission(definition.Permission, Instance);
}
private void InitializeCollider() {
if (collider != null) DestroyImmediate(collider);
if (rigidbody != null) DestroyImmediate(rigidbody);
rigidbody = gameObject.AddComponent<Rigidbody>();
rigidbody.useGravity = false;
rigidbody.isKinematic = true;
rigidbody.detectCollisions = true;
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
SphereCollider sphereCollider = gameObject.GetComponent<SphereCollider>();
BoxCollider boxCollider = gameObject.GetComponent<BoxCollider>();
if (definition.Size != Vector3.zero) {
if (sphereCollider != null) Destroy(sphereCollider);
if (!boxCollider) {
boxCollider = gameObject.AddComponent<BoxCollider>();
boxCollider.isTrigger = true;
}
boxCollider.size = definition.Size;
colliderBounds = boxCollider.bounds;
collider = boxCollider;
}
else {
if (boxCollider != null) Destroy(boxCollider);
if (!sphereCollider) {
sphereCollider = gameObject.AddComponent<SphereCollider>();
sphereCollider.isTrigger = true;
}
sphereCollider.radius = definition.Radius;
colliderBounds = sphereCollider.bounds;
collider = sphereCollider;
}
}
#endregion
#region Triggers
private void InitializeRadiation() {
if (definition.Radiation > 0) {
if (radiation == null) radiation = new ChildSphereTrigger<TriggerRadiation>(gameObject, "Radiation");
radiation.Trigger.RadiationAmountOverride = definition.Radiation;
radiation.Collider.radius = collider is SphereCollider ? definition.Radius : Mathf.Min(definition.Size.x, definition.Size.y, definition.Size.z) * 0.5f;
radiation.Trigger.enabled = this.enabled;
}
else radiation?.Destroy();
}
private void InitializeComfort() {
if (definition.Comfort > 0) {
if (comfort == null) comfort = new ChildSphereTrigger<TriggerComfort>(gameObject, "Comfort");
comfort.Trigger.baseComfort = definition.Comfort;
comfort.Trigger.triggerSize = comfort.Collider.radius = collider is SphereCollider ? definition.Radius : Mathf.Min(definition.Size.x, definition.Size.y, definition.Size.z) * 0.5f;
comfort.Trigger.enabled = this.enabled;
}
else comfort?.Destroy();
}
private void InitializeTemperature() {
if (definition.Temperature != 0) {
if (temperature == null) temperature = new ChildSphereTrigger<TriggerTemperature>(gameObject, "Temperature");
temperature.Trigger.Temperature = definition.Temperature;
temperature.Trigger.triggerSize = temperature.Collider.radius = collider is SphereCollider ? definition.Radius : Mathf.Min(definition.Size.x, definition.Size.y, definition.Size.z) * 0.5f;
temperature.Trigger.enabled = this.enabled;
}
else temperature?.Destroy();
}
private void InitializeSafeZone() {
if (defini
// ... [Code preview truncated due to length. Full source in attached file] ...