Add MaxBuildingsPerLocation feature, which allows restricting players from building inside the loot locations in the area where zombies can walk and spawn

Author: RestoreMonarchy

BuildingRestrictions/BuildingRestrictions.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net48</TargetFramework>
 	  <LangVersion>latest</LangVersion>
 	  <RootNamespace>RestoreMonarchy.BuildingRestrictions</RootNamespace>
-    <Version>1.1.1</Version>
+    <Version>1.2.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

BuildingRestrictions/BuildingRestrictionsConfiguration.cs

@@ -24,6 +24,10 @@ public class BuildingRestrictionsConfiguration : IRocketPluginConfiguration
         public bool EnableMaxStructureHeight { get; set; } = false;
         public float MaxStructureHeight { get; set; } = 100;
 
+        public bool EnableMaxBuildingsPerLocation { get; set; } = false;
+        public float MaxBuildingsPerLocationHeight { get; set; } = 100;
+        public int MaxBuildingsPerLocation { get; set; } = 10;
+
         [XmlArrayItem("Barricade")]
         public BuildingRestriction[] Barricades { get; set; } = [];
         [XmlArrayItem("Structure")]
@@ -49,6 +53,10 @@ public void LoadDefaults()
             EnableMaxStructureHeight = false;
             MaxStructureHeight = 100;
 
+            EnableMaxBuildingsPerLocation = false;
+            MaxBuildingsPerLocationHeight = 100;
+            MaxBuildingsPerLocation = 10;
+
             Barricades =
             [
                 new("sentries", 0, EBuild.SENTRY.ToString(), null, 5),

BuildingRestrictions/BuildingRestrictionsPlugin.cs

@@ -13,7 +13,10 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Drawing.Text;
 using System.Linq;
+using UnityEngine;
+using Logger = Rocket.Core.Logging.Logger;
 
 namespace RestoreMonarchy.BuildingRestrictions
 {
@@ -78,7 +81,10 @@ protected override void Unload()
             { "PlayerNotFound", "Player [[b]]{0}[[/b]] not found." },
             { "BuildingStatsOtherNoPermission", "You don't have permission to check other player building stats." },
             { "MaxBarricadeHeightRestriction", "You can't build [[b]]{0}[[/b]] because it's higher than max [[b]]{1}m[[/b]] height above the ground." },
-            { "MaxStructureHeightRestriction", "You can't build [[b]]{0}[[/b]] because it's higher than max [[b]]{1}m[[/b]] height above the ground." }
+            { "MaxStructureHeightRestriction", "You can't build [[b]]{0}[[/b]] because it's higher than max [[b]]{1}m[[/b]] height above the ground." },
+            { "BuildingsInLocationRestriction", "You can't build [[b]]{0}[[/b]] here because you have reached the limit of max [[b]]{1}[[/b]] buildings in this location." },
+            { "BuildingsInLocationRestrictionNone", "You can't build in this location." },
+            { "BuildingsInLocationRestrictionInfo", "You have built [[b]]{0}/{1}[[/b]] buildings in this location." }
         };
 
         private void OnLevelLoaded(int level)
@@ -100,8 +106,11 @@ private void OnLevelLoaded(int level)
                     {
                         ItemId = drop.asset.id,
                         Build = drop.asset.build,
-                        Transform = drop.model
+                        Transform = drop.model,
+                        IsInBound = TryGetBoundsWithHeight(drop.model.position, out byte boundIndex),
+                        BoundIndex = boundIndex
                     };
+
                     BarricadeData data = drop.GetServersideData();
                     Database.AddPlayerBarricade(data.owner, playerBarricade);
                 }
@@ -119,8 +128,11 @@ private void OnLevelLoaded(int level)
                     {
                         ItemId = drop.asset.id,
                         Construct = drop.asset.construct,
-                        Transform = drop.model
+                        Transform = drop.model,
+                        IsInBound = TryGetBoundsWithHeight(drop.model.position, out byte boundIndex),
+                        BoundIndex = boundIndex
                     };
+
                     StructureData data = drop.GetServersideData();
                     Database.AddPlayerStructure(data.owner, playerStructure);
                 }
@@ -158,7 +170,7 @@ public decimal GetPlayerBuildingsMultiplier(IRocketPlayer player)
             return multiplier;
         }
 
-        private void OnDeployBarricadeRequested(Barricade barricade, ItemBarricadeAsset asset, UnityEngine.Transform hit, ref UnityEngine.Vector3 point, ref float angle_x, ref float angle_y, ref float angle_z, ref ulong owner, ref ulong group, ref bool shouldAllow)
+        private void OnDeployBarricadeRequested(Barricade barricade, ItemBarricadeAsset asset, Transform hit, ref Vector3 point, ref float angle_x, ref float angle_y, ref float angle_z, ref ulong owner, ref ulong group, ref bool shouldAllow)
         {
             if (!shouldAllow)
             {
@@ -219,6 +231,34 @@ private void OnDeployBarricadeRequested(Barricade barricade, ItemBarricadeAsset
                 }
             }
 
+            System.Action action = null;
+            if (Configuration.Instance.EnableMaxBuildingsPerLocation && TryGetBoundsWithHeight(point, out byte boundIndex) 
+                && asset.build != EBuild.BEACON && asset.build != EBuild.VEHICLE && asset.build != EBuild.CHARGE && asset.build != EBuild.SAFEZONE)
+            {
+                if (Configuration.Instance.MaxBuildingsPerLocation == 0)
+                {
+                    SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestrictionNone");
+                    shouldAllow = false;
+                    return;
+                }
+
+                int barricadesCount = playerBuildings?.Barricades.Count(x => x.IsInBound && x.BoundIndex == boundIndex) ?? 0;
+                int structuresCount = playerBuildings?.Structures.Count(x => x.IsInBound && x.BoundIndex == boundIndex) ?? 0;
+                int buildingsCount = barricadesCount + structuresCount;
+
+                int maxBuildings = (int)(Configuration.Instance.MaxBuildingsPerLocation * multiplier);
+                if (maxBuildings <= buildingsCount)
+                {
+                    SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestriction", itemName, maxBuildings);
+                    shouldAllow = false;
+                    return;
+                }
+                else
+                {
+                    action = () => SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestrictionInfo", buildingsCount + 1, maxBuildings);
+                }
+            }
+
             if (Configuration.Instance.Barricades != null && Configuration.Instance.Barricades.Any())
             {
                 int itemIdCount = playerBuildings?.Barricades.Count(x => x.ItemId == barricade.asset.id) ?? 0;
@@ -256,6 +296,11 @@ private void OnDeployBarricadeRequested(Barricade barricade, ItemBarricadeAsset
                     return;
                 }
             }
+
+            if (action != null)
+            {
+                action();
+            }
         }
 
         private void OnDeployStructureRequested(Structure structure, ItemStructureAsset asset, ref UnityEngine.Vector3 point, ref float angle_x, ref float angle_y, ref float angle_z, ref ulong owner, ref ulong group, ref bool shouldAllow)
@@ -319,6 +364,33 @@ private void OnDeployStructureRequested(Structure structure, ItemStructureAsset
                 }
             }
 
+            System.Action action = null;
+            if (Configuration.Instance.EnableMaxBuildingsPerLocation && TryGetBoundsWithHeight(point, out byte boundIndex))
+            {
+                if (Configuration.Instance.MaxBuildingsPerLocation == 0)
+                {
+                    SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestrictionNone");
+                    shouldAllow = false;
+                    return;
+                }
+
+                int barricadesCount = playerBuildings?.Barricades.Count(x => x.IsInBound && x.BoundIndex == boundIndex) ?? 0;
+                int structuresCount = playerBuildings?.Structures.Count(x => x.IsInBound && x.BoundIndex == boundIndex) ?? 0;
+                int buildingsCount = barricadesCount + structuresCount;
+
+                int maxBuildings = (int)(Configuration.Instance.MaxBuildingsPerLocation * multiplier);
+                if (maxBuildings <= buildingsCount)
+                {
+                    SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestriction", itemName, maxBuildings);
+                    shouldAllow = false;
+                    return;
+                }
+                else
+                {
+                    action = () => SendMessageToPlayer(unturnedPlayer, "BuildingsInLocationRestrictionInfo", buildingsCount + 1, maxBuildings);
+                }
+            }
+
             if (Configuration.Instance.Structures != null && Configuration.Instance.Structures.Any())
             {
                 int itemIdCount = playerBuildings?.Structures.Count(x => x.ItemId == structure.asset.id) ?? 0;
@@ -356,6 +428,11 @@ private void OnDeployStructureRequested(Structure structure, ItemStructureAsset
                     return;
                 }
             }
+
+            if (action != null)
+            {
+                action();
+            }
         }
 
         private void OnBarricadeSpawned(BarricadeRegion region, BarricadeDrop drop)
@@ -365,7 +442,9 @@ private void OnBarricadeSpawned(BarricadeRegion region, BarricadeDrop drop)
             {
                 ItemId = drop.asset.id,
                 Build = drop.asset.build,
-                Transform = drop.model
+                Transform = drop.model,
+                IsInBound = TryGetBoundsWithHeight(drop.model.position, out byte boundIndex),
+                BoundIndex = boundIndex
             };
             Database.AddPlayerBarricade(barricadeData.owner, playerBarricade);
         }
@@ -377,11 +456,36 @@ private void OnStructureSpawned(StructureRegion region, StructureDrop drop)
             {
                 ItemId = drop.asset.id,
                 Construct = drop.asset.construct,
-                Transform = drop.model
+                Transform = drop.model,
+                IsInBound = TryGetBoundsWithHeight(drop.model.position, out byte boundIndex),
+                BoundIndex = boundIndex
             };
             Database.AddPlayerStructure(structureData.owner, playerStructure);
         }
 
+        public bool TryGetBoundsWithHeight(Vector3 position, out byte boundIndex)
+        {
+            if (LevelNavigation.tryGetBounds(position, out boundIndex))
+            {
+                Bounds bound = LevelNavigation.bounds[boundIndex];
+                if (IsInBoundsHeight(bound, position))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private bool IsInBoundsHeight(Bounds bound, Vector3 position)
+        {
+            float goundLevel = LevelGround.getHeight(position);
+            float buildingY = position.y;
+            float buildingHeight = buildingY - goundLevel;
+
+            return buildingHeight <= Configuration.Instance.MaxBuildingsPerLocationHeight;
+        }
+
         internal void SendMessageToPlayer(IRocketPlayer player, string translationKey, params object[] placeholder)
         {
             if (player == null)

BuildingRestrictions/Models/PlayerBarricade.cs

@@ -8,5 +8,7 @@ public class PlayerBarricade
         public ushort ItemId { get; set; }
         public EBuild Build { get; set; }
         public Transform Transform { get; set; }
+        public bool IsInBound { get; set; }
+        public byte BoundIndex { get; set; }
     }
 }

BuildingRestrictions/Models/PlayerStructure.cs

@@ -8,5 +8,7 @@ public class PlayerStructure
         public ushort ItemId { get; set; }
         public EConstruct Construct { get; set; }
         public Transform Transform { get; set; }
+        public bool IsInBound { get; set; }
+        public byte BoundIndex { get; set; }
     }
 }

README.md

@@ -11,18 +11,32 @@ Set the limits for the number of buildings the player can build.
 <Permission Cooldown="0">buildingstats.other</Permission>
 ```
 
-## List of Barricade Build types
+## Barricade Build types
+```
 FORTIFICATION, BARRICADE, DOOR, GATE, BED, LADDER, STORAGE, FARM, TORCH, CAMPFIRE, SPIKE, WIRE, GENERATOR, SPOT, SAFEZONE, FREEFORM, SIGN, VEHICLE, CLAIM, BEACON, STORAGE_WALL, BARREL_RAIN, OIL, CAGE, SHUTTER, TANK, CHARGE, SENTRY, SENTRY_FREEFORM, OVEN, LIBRARY, OXYGENATOR, GLASS, NOTE, HATCH, MANNEQUIN, STEREO, SIGN_WALL, CLOCK, BARRICADE_WALL
+```
+
+## Structure Construct types
+```
+FLOOR, WALL, RAMPART, ROOF, PILLAR, POST, FLOOR_POLY, ROOF_POLY
+```
+
+## Location restrictions
+Location is considered a rectangle where the zombies can spawn and walk. It is the equalivent of navigations in Unturned map editor.
+```xml
+<EnableMaxBuildingsPerLocation>false</EnableMaxBuildingsPerLocation>
+<MaxBuildingsPerLocationHeight>100</MaxBuildingsPerLocationHeight>
+<MaxBuildingsPerLocation>10</MaxBuildingsPerLocation>
+```
+The `MaxBuildingsPerLocationHeight` is the height above the ground where the building is considered to be in the location. 
+
+If you want to completely disable building in the locations, set `MaxBuildingPerLocation` to `0`.
 
-## List of Structure Construct types
-- FLOOR
-- WALL
-- RAMPART
-- ROOF
-- PILLAR
-- POST
-- FLOOR_POLY
-- ROOF_POLY
+The following barricades are not considered for the location restrictions:
+- Safezone Radiators
+- Horde Beacons
+- Charges
+- Vehicles (which can be built)
 
 ## Configuration
 ```xml
@@ -41,6 +55,9 @@ FORTIFICATION, BARRICADE, DOOR, GATE, BED, LADDER, STORAGE, FARM, TORCH, CAMPFIR
   <MaxBarricadeHeight>100</MaxBarricadeHeight>
   <EnableMaxStructureHeight>false</EnableMaxStructureHeight>
   <MaxStructureHeight>100</MaxStructureHeight>
+  <EnableMaxBuildingsPerLocation>false</EnableMaxBuildingsPerLocation>
+  <MaxBuildingsPerLocationHeight>100</MaxBuildingsPerLocationHeight>
+  <MaxBuildingsPerLocation>10</MaxBuildingsPerLocation>
   <Barricades>
     <Barricade Name="sentries" Build="SENTRY" Max="5" />
     <Barricade Name="stereos" Build="STEREO" Max="1" />