1.2.0.0-beta

OnTriggerStay instead of OnTriggerEnter.
HashSets instead of Lists.
Location of entered colliders every N seconds.
Configurable delay for routines.

Author: pmswe

Config.cs

@@ -7,6 +7,7 @@
 public partial class Config : IRocketPluginConfiguration
 {
     public bool DebugInformation = true;
+    public float DefaultLocateDelay = 1.5f, DefaultUpdateDelay = 0.2f;
     public List<Zone> Zones = new();
     public void LoadDefaults()
     {

Controllers/CustomZoneController.cs

@@ -19,19 +19,18 @@ public void SetNodes(IEnumerable<Vector3> nodes)
     protected readonly List<Vector3> nodes = new();
     public IReadOnlyCollection<Vector3> Nodes => nodes;
 
-    private readonly List<Collider> colliders = new();
+    private readonly HashSet<Collider> colliders = new();
 
     protected new bool SetEnterState(Collider other, bool state)
     {
-        if (state != colliders.Contains(other))
-        {
-            if (state) colliders.Add(other);
-            else colliders.Remove(other);
-        }
+        var inside = colliders.Contains(other);
+        if (state == inside) return true;
+        if (state) colliders.Add(other);
+        else colliders.Remove(other);
         state = IsPositionInside(other);
         return base.SetEnterState(other, state);
     }
-    protected override void OnTriggerEnter(Collider other) => SetEnterState(other, true);
+    protected override void OnTriggerStay(Collider other) => SetEnterState(other, true);
     protected override void OnTriggerExit(Collider other) => SetEnterState(other, false);
 
     public override bool IsInside(Vector3 point)

Controllers/ZoneController.cs

@@ -1,4 +1,6 @@
-namespace SZones;
+using UnityEngine;
+
+namespace SZones;
 
 public abstract partial class ZoneController : UnityBehaviour
 {
@@ -18,16 +20,16 @@ internal void Initialize(Zone zone)
     }
 
     #region Entered State
-    protected readonly List<Collider> enteredColliders = new();
+    protected readonly HashSet<Collider> enteredColliders = new();
     public virtual IReadOnlyCollection<Collider> EnteredColliders => enteredColliders;
-    public virtual IReadOnlyCollection<GameObject> EnteredObjects => enteredColliders.Select(x => x.gameObject).ToList();
+    public virtual IReadOnlyCollection<GameObject> EnteredObjects => enteredColliders.Select(x => x?.gameObject).Where(x => x).ToList();
     protected virtual bool SetEnterState(Collider other, bool state)
     {
-        if (!other) return state;
-        var @object = other.gameObject;
-
         var entered = enteredColliders.Contains(other);
         if (state == entered) return state;
+        if (!other) return state;
+
+        var @object = other.gameObject;
 
         bool Set<T>(Func<T, bool, bool> func) => state = func(@object.GetComponent<T>(), state);
         Set<Player>(SetEnterState);
@@ -51,10 +53,10 @@ protected virtual bool UpdateEnterState(Collider other)
         return SetEnterState(other, state);
     }
     protected virtual bool UpdateEnterState(UnityComponent component) => UpdateEnterState(component?.GetComponent<Collider>());
-    protected virtual void OnTriggerEnter(Collider other) => SetEnterState(other, true);
+    protected virtual void OnTriggerStay(Collider other) => SetEnterState(other, true);
     protected virtual void OnTriggerExit(Collider other) => SetEnterState(other, false);
 
-    protected readonly List<CSteamID> enteredPlayers = new();
+    protected readonly HashSet<CSteamID> enteredPlayers = new();
     public virtual IReadOnlyCollection<CSteamID> EnteredPlayers => enteredPlayers;
 
     protected bool SetEnterState(SPlayer target, bool state) => SetEnterState(target?.player, state);
@@ -71,7 +73,7 @@ protected bool TrySetEnterState(CSteamID id, bool state)
         if (IsInside(id) == state) return false;
 
         if (state) enteredPlayers.Add(id);
-        else enteredPlayers.RemoveAll(x => x == id);
+        else enteredPlayers.Remove(id);
 
         return true;
     }
@@ -107,16 +109,18 @@ protected void InvokeEventsSafe<T>(T value, bool state, StateUpdateHandler<T> en
         catch { }
     }
 
-    protected virtual float UpdateCollidersDelay { get; } = 0.2f;
-    protected void UpdateStates(IList<Collider> colliders)
+    protected virtual float UpdateCollidersDelay { get; } = conf.DefaultUpdateDelay;
+    protected virtual float LocateCollidersDelay { get; } = conf.DefaultLocateDelay;
+    protected void UpdateStates(ICollection<Collider> colliders)
     {
         List<UnityComponent> other = new();
         for (int i = 0; i < colliders.Count; i++)
         {
             var collider = colliders.ElementAt(i);
             if (!collider)
             {
-                colliders.RemoveAt(i--);
+                colliders.Remove(collider);
+                --i;
                 continue;
             }
 
@@ -136,18 +140,14 @@ protected void UpdateStates(IList<Collider> colliders)
         foreach (var component in other.Distinct())
             UpdateEnterState(component);
     }
-    protected void UpdateStates(IList<CSteamID> playersIds)
+    protected void UpdateStates(ICollection<CSteamID> playersIds)
     {
         var ids = playersIds.ToList();
         foreach(var id in ids)
         {
             var player = PlayerTool.getPlayer(id);
-            if (!player) goto notEntered;
-            if (!(IsPositionInside(player) || IsPositionInside(player.GetComponent<Collider>()))) goto notEntered;
-
-            continue;
-            notEntered:
-            TrySetEnterState(id, false);
+            if (!player) TrySetEnterState(id, false);
+            else UpdateEnterState(player);
         }
     }
     protected virtual void UpdateStates()
@@ -163,6 +163,29 @@ protected virtual IEnumerator UpdateEnteredCollidersRoutine()
             UpdateStates();
         }
     }
+    protected virtual IEnumerator LocateEnteredCollidersRoutine()
+    {
+        while (true)
+        {
+            yield return new WaitForSeconds(LocateCollidersDelay);
+            LocateEnteredColliders();
+        }
+    }
+    protected virtual void LocateEnteredColliders()
+    {
+        if (Provider.clients is null) return;
+        if (VehicleManager.vehicles is null) return;
+
+        var colliders =
+            Provider.clients.Select(x => x?.model?.GetComponent<Collider>())
+            .Concat(VehicleManager.vehicles.Select(x => x?.GetComponent<Collider>()))
+            .ToArray();
+        foreach(var collider in colliders)
+        {
+            if (!collider) continue;
+            UpdateEnterState(collider);
+        }
+    }
     #endregion
 
     #region Entities
@@ -222,6 +245,7 @@ public virtual void Dispose()
     protected virtual void Awake()
     {
         StartCoroutine(UpdateEnteredCollidersRoutine());
+        StartCoroutine(LocateEnteredCollidersRoutine());
     }
     #endregion
 }

README.md

@@ -0,0 +1,4 @@
+# SZones
+
+### Smart zone system based on Unity collision for Unturned plugins.
+Warning! Repository still in beta, most of builds is not fully tested, and may contain bugs, please report about them in the issues.

SZones.csproj

@@ -5,7 +5,7 @@
 		<TargetFrameworks>net472</TargetFrameworks>
 		<AssemblyName>SZones</AssemblyName>
 		<RootNamespace>SZones</RootNamespace>
-		<Version>1.1.4.2</Version>
+		<Version>1.2.0.0-beta</Version>
 		<NoWarn>$(NoWarn);CS0436</NoWarn>
 		<RunPostBuildEvent>Always</RunPostBuildEvent>
 		<Nullable>annotations</Nullable>

Utilities/Utils.cs

@@ -50,6 +50,8 @@
 global using Storage = SDG.Unturned.InteractableStorage;
 global using InventoryPage = SDG.Unturned.Items;
 global using static SZones.Utils;
+using System.Net;
+using System.Drawing;
 
 namespace SZones;
 
@@ -145,30 +147,54 @@ public static List<Animal> GetAnimals(Func<Vector3, bool> isInside)
         return result;
     }
 
+
     public static List<RegionCoordinate> GetRegions(this Bounds bounds)
     {
         List<RegionCoordinate> result = new();
         var center = bounds.center;
         var extents = bounds.extents;
         Vector3 startPoint = new(center.x - extents.x, center.y, center.z - extents.z);
         Vector3 endPoint = new(center.x + extents.x, center.y, center.z + extents.z);
-        getUnsafeCoordinates(startPoint, out var x1, out var y1);
-        getUnsafeCoordinates(endPoint, out var x2, out var y2);
-        if (x1 >= Regions.WORLD_SIZE || y1 >= Regions.WORLD_SIZE || x2 < 0 || y2 < 0)
+        Vector2Int 
+            startRegion = GetRegionCoordinates(startPoint), 
+            endRegion = GetRegionCoordinates(endPoint);
+
+        if (startRegion.x >= Regions.WORLD_SIZE || startRegion.y >= Regions.WORLD_SIZE || endRegion.x < 0 || endRegion.y < 0)
             return result;
-        x1 = Mathf.Max(x1, 0);
-        x2 = Mathf.Max(x2, 0);
-        y1 = Mathf.Min(y1, Regions.WORLD_SIZE - 1);
-        y2 = Mathf.Min(y2, Regions.WORLD_SIZE - 1);
-        for (byte x = (byte)x1; x <= x2; x++)
-            for (byte y = (byte)y1; y <= y2; y++)
+
+        startRegion.x = Mathf.Max(startRegion.x, 0);
+        endRegion.x = Mathf.Max(endRegion.x, 0);
+        startRegion.y = Mathf.Min(startRegion.y, Regions.WORLD_SIZE - 1);
+        endRegion.y = Mathf.Min(endRegion.y, Regions.WORLD_SIZE - 1);
+        for (byte x = (byte)startPoint.x; x <= endPoint.x; x++)
+            for (byte y = (byte)startPoint.y; y <= endPoint.y; y++)
                 result.Add(new(x, y));
         return result;
     }
+    public static bool IsInsideAnyRegion(this Vector3 position, IEnumerable<RegionCoordinate> regions) =>
+        regions.Any(x =>
+        {
+            var start = GetRegionStart(x.ToVec2Int());
+            var end = GetRegionStart(x.x + 1, x.y + 1);
+            return position.x <= end.x && position.y <= end.y &&
+                position.x >= start.x && position.y >= end.y;
+        });
 
-    private static void getUnsafeCoordinates(Vector3 point, out int x, out int y)
+    public static void GetRegionCoordinates(this Vector3 point, out int x, out int y)
+    {
+        x = Mathf.FloorToInt((point.x + RegionConstant) / Regions.REGION_SIZE);
+        y = Mathf.FloorToInt((point.z + RegionConstant) / Regions.REGION_SIZE);
+    }
+    public static Vector2Int GetRegionCoordinates(this Vector3 point)
     {
-        x = Mathf.FloorToInt((point.x + 4096f) / Regions.REGION_SIZE);
-        y = Mathf.FloorToInt((point.z + 4096f) / Regions.REGION_SIZE);
+        GetRegionCoordinates(point, out var x, out var y);
+        return new(x, y);
     }
+    public static Vector3 GetRegionStart(int x, int y) => new(
+        x * Regions.REGION_SIZE - RegionConstant,
+        y * Regions.REGION_SIZE - RegionConstant
+    );
+    public static Vector3 GetRegionStart(Vector2Int coordinate) => GetRegionStart(coordinate.x, coordinate.y);
+    public static Vector2Int ToVec2Int(this RegionCoordinate coordinate) => new(coordinate.x, coordinate.y);
+    public const float RegionConstant = 4096f;
 }