add block and world accessor extensions (wip #9)

devpikachu · devpikachu · commit 92ea9983b98f · 2025-10-28T12:37:19.000+02:00
diff --git a/Common.Mod.Common/Config/IConfigSystem.cs b/Common.Mod.Common/Config/IConfigSystem.cs
@@ -1,7 +1,9 @@
+using JetBrains.Annotations;
 using Vintagestory.API.Server;
 
 namespace Common.Mod.Common.Config;
 
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public interface IConfigSystem
 {
     #region Event delegates
diff --git a/Common.Mod.Common/Core/LogEntry.cs b/Common.Mod.Common/Core/LogEntry.cs
@@ -2,7 +2,7 @@
 
 namespace Common.Mod.Common.Core;
 
-[UsedImplicitly(ImplicitUseKindFlags.Access, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public record LogEntry
 {
     public DateTime Timestamp { get; init; }
diff --git a/Common.Mod.Generator/Specs/ConfigEntrySpec.cs b/Common.Mod.Generator/Specs/ConfigEntrySpec.cs
@@ -2,7 +2,7 @@
 
 namespace Common.Mod.Generator.Specs;
 
-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public record ConfigEntrySpec
 {
     public string Name { get; set; } = null!;
diff --git a/Common.Mod.Generator/Specs/ConfigEnumSpec.cs b/Common.Mod.Generator/Specs/ConfigEnumSpec.cs
@@ -3,7 +3,7 @@
 
 namespace Common.Mod.Generator.Specs;
 
-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public record ConfigEnumSpec
 {
     public string EnumName { get; set; } = null!;
diff --git a/Common.Mod.Generator/Specs/ConfigSpec.cs b/Common.Mod.Generator/Specs/ConfigSpec.cs
@@ -3,7 +3,7 @@
 
 namespace Common.Mod.Generator.Specs;
 
-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public record ConfigSpec
 {
     public string ClassName { get; set; } = null!;
diff --git a/Common.Mod.Generator/Specs/RootConfigSpec.cs b/Common.Mod.Generator/Specs/RootConfigSpec.cs
@@ -2,7 +2,7 @@
 
 namespace Common.Mod.Generator.Specs;
 
-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public record RootConfigSpec : ConfigSpec
 {
     public string Version { get; set; } = null!;
diff --git a/Common.Mod.Generator/Specs/RootConfigTypeSpec.cs b/Common.Mod.Generator/Specs/RootConfigTypeSpec.cs
@@ -2,7 +2,7 @@
 
 namespace Common.Mod.Generator.Specs;
 
-[UsedImplicitly(ImplicitUseKindFlags.Access, ImplicitUseTargetFlags.Members)]
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
 public enum RootConfigTypeSpec
 {
     Common,
diff --git a/Common.Mod/Blocks/MultiblockBlock.cs b/Common.Mod/Blocks/MultiblockBlock.cs
@@ -22,7 +22,7 @@ public override Cuboidf[] GetParticleCollisionBoxes(IBlockAccessor blockAccessor
         );
     }
 
-    // This is copy-pasted from the `BlockMultiblock` class where it is private
+    // This is more or less copy-pasted from the `BlockMultiblock` class where it is private
     private static T Handle<T, TK>(
         IBlockAccessor blockAccessor,
         int x,
@@ -35,24 +35,13 @@ BlockCallDelegateBlock<T> onOtherwise
         where TK : class
     {
         var block = blockAccessor.GetBlock((new Vec3i(x, y, z)).ToBlockPos());
-        var blockInf = block as TK;
-
-        if (blockInf == null)
-        {
-            blockInf = block.GetBehavior(typeof(TK), true) as TK;
-        }
+        var blockInf = block as TK ?? block.GetBehavior(typeof(TK), true) as TK;
 
         if (blockInf != null)
         {
             return onImplementsInterface(blockInf);
         }
 
-        // This is to prevent endless recursion in situations where blocks become incorrectly arranged
-        if (block is BlockMultiblock)
-        {
-            return onIsMultiblock(block);
-        }
-
-        return onOtherwise(block);
+        return block is BlockMultiblock ? onIsMultiblock(block) : onOtherwise(block);
     }
 }
diff --git a/Common.Mod/Common.Mod.csproj b/Common.Mod/Common.Mod.csproj
@@ -21,6 +21,10 @@
       <HintPath>../vendor/VintagestoryAPI.dll</HintPath>
       <Private>false</Private>
     </Reference>
+    <Reference Include="VintagestoryLib">
+      <HintPath>../vendor/VintagestoryLib.dll</HintPath>
+      <Private>false</Private>
+    </Reference>
     <Reference Include="VSEssentials">
       <HintPath>../vendor/VSEssentials.dll</HintPath>
       <Private>false</Private>
diff --git a/Common.Mod/Core/FileSystem.cs b/Common.Mod/Core/FileSystem.cs
@@ -1,6 +1,5 @@
 using Common.Mod.Common.Core;
 using Vintagestory.API.Common;
-using Vintagestory.API.Config;
 
 namespace Common.Mod.Core;
 
diff --git a/Common.Mod/Extensions/BlockAccessorExtensions.cs b/Common.Mod/Extensions/BlockAccessorExtensions.cs
@@ -0,0 +1,45 @@
+using JetBrains.Annotations;
+using Vintagestory.API.Common;
+using Vintagestory.API.MathTools;
+using Vintagestory.Common;
+
+namespace Common.Mod.Extensions;
+
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
+public static class BlockAccessorExtensions
+{
+    public delegate void ChunkMissingHandler(int x, int y, int z);
+
+    public static ChunkData?[] LoadChunksToCache(this IBlockAccessor blockAccessor, Vec3i minPos, Vec3i maxPos, ChunkMissingHandler? onChunkMissing = null)
+    {
+        var countX = maxPos.X - minPos.X + 1;
+        var countY = maxPos.Y - minPos.Y + 1;
+        var countZ = maxPos.Z - minPos.Z + 1;
+        var chunks = new ChunkData?[countX * countY * countZ];
+
+        for (var y = minPos.Y; y <= maxPos.Y; y++)
+        {
+            var indexY = (y - minPos.Y) * countZ - minPos.Z;
+            for (var z = minPos.Z; z <= maxPos.Z; z++)
+            {
+                var indexBase = (indexY + z) * countX - minPos.X;
+                for (var x = minPos.X; x <= maxPos.X; x++)
+                {
+                    var chunk = blockAccessor.GetChunk(x, y, z);
+
+                    if (chunk is null)
+                    {
+                        chunks[indexBase + x] = null;
+                        onChunkMissing?.Invoke(x, y, z);
+                        continue;
+                    }
+
+                    chunk.Unpack();
+                    chunks[indexBase + x] = chunk.Data as ChunkData;
+                }
+            }
+        }
+
+        return chunks;
+    }
+}
diff --git a/Common.Mod/Extensions/WorldAccessorExtensions.cs b/Common.Mod/Extensions/WorldAccessorExtensions.cs
@@ -0,0 +1,179 @@
+using System.Diagnostics.CodeAnalysis;
+using JetBrains.Annotations;
+using Vintagestory.API.Common;
+using Vintagestory.API.Config;
+using Vintagestory.API.MathTools;
+
+namespace Common.Mod.Extensions;
+
+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]
+[SuppressMessage("ReSharper", "MoveLocalFunctionAfterJumpStatement")]
+public static class WorldAccessorExtensions
+{
+    public delegate void WalkBlocksHandler(Block block, int x, int y, int z);
+
+    public static void WalkBlocksCuboid(this IWorldAccessor worldAccessor, BlockPos minPos, BlockPos maxPos, WalkBlocksHandler onBlock)
+    {
+        worldAccessor.BlockAccessor.WalkBlocks(minPos, maxPos, (block, x, y, z) => onBlock(block, x, y, z), centerOrder: false);
+    }
+
+    public static void WalkBlocksCube(this IWorldAccessor worldAccessor, BlockPos centerPos, int halfSize, WalkBlocksHandler onBlock)
+    {
+        var minPos = centerPos.SubCopy(halfSize, halfSize, halfSize);
+        var maxPos = centerPos.AddCopy(halfSize, halfSize, halfSize);
+        worldAccessor.WalkBlocksCuboid(minPos, maxPos, onBlock);
+    }
+
+    public static void WalkBlocksCylinder(
+        this IWorldAccessor worldAccessor,
+        BlockPos centerPos,
+        int radius,
+        int minYPos,
+        int maxYPos,
+        WalkBlocksHandler onBlock
+    )
+    {
+        var minPos = centerPos.SubCopy(radius, 0, radius);
+        minPos.Y = minYPos;
+        var maxPos = centerPos.AddCopy(radius, 0, radius);
+        maxPos.Y = maxYPos;
+
+        bool Predicate(int x, int y, int z) => IsInCircle(centerPos.ToVec3i(), radius, x, z);
+        worldAccessor.WalkBlocks(minPos, maxPos, Predicate, onBlock);
+    }
+
+    public static void WalkBlocksCylinder(
+        this IWorldAccessor worldAccessor,
+        BlockPos centerPos,
+        int radius,
+        int halfHeight,
+        WalkBlocksHandler onBlock
+    )
+    {
+        var minYPos = centerPos.Y - halfHeight;
+        var maxYPos = centerPos.Y + halfHeight;
+        worldAccessor.WalkBlocksCylinder(centerPos, radius, minYPos, maxYPos, onBlock);
+    }
+
+    public static void WalkBlocksSphere(
+        this IWorldAccessor worldAccessor,
+        BlockPos centerPos,
+        int radius,
+        WalkBlocksHandler onBlock
+    )
+    {
+        var minPos = centerPos.SubCopy(radius, radius, radius);
+        var maxPos = centerPos.AddCopy(radius, radius, radius);
+
+        bool Predicate(int x, int y, int z) => IsInSphere(centerPos.ToVec3i(), radius, x, y, z);
+        worldAccessor.WalkBlocks(minPos, maxPos, Predicate, onBlock);
+    }
+
+    private static void WalkBlocks(
+        this IWorldAccessor worldAccessor,
+        BlockPos minPos,
+        BlockPos maxPos,
+        System.Func<int, int, int, bool> predicate,
+        WalkBlocksHandler onBlock
+    )
+    {
+        var blockAccessor = worldAccessor.BlockAccessor;
+        var mapSize = blockAccessor.MapSize!;
+
+        var minXPos = GameMath.Clamp(Math.Min(minPos.X, maxPos.X), 0, mapSize.X);
+        var maxXPos = GameMath.Clamp(Math.Max(minPos.X, maxPos.X), 0, mapSize.X);
+        var minYPos = GameMath.Clamp(Math.Min(minPos.Y, maxPos.Y), 0, mapSize.Y);
+        var maxYPos = GameMath.Clamp(Math.Max(minPos.Y, maxPos.Y), 0, mapSize.Y);
+        var minZPos = GameMath.Clamp(Math.Min(minPos.Z, maxPos.Z), 0, mapSize.Z);
+        var maxZPos = GameMath.Clamp(Math.Max(minPos.Z, maxPos.Z), 0, mapSize.Z);
+
+        var minChunkXPos = minXPos / GlobalConstants.ChunkSize;
+        var maxChunkXPos = maxXPos / GlobalConstants.ChunkSize;
+        var minChunkYPos = minYPos / GlobalConstants.ChunkSize;
+        var maxChunkYPos = maxYPos / GlobalConstants.ChunkSize;
+        var minChunkZPos = minZPos / GlobalConstants.ChunkSize;
+        var maxChunkZPos = maxZPos / GlobalConstants.ChunkSize;
+
+        var dimensionYOffset = minPos.dimension * GlobalConstants.DimensionSizeInChunks;
+
+        var chunks = blockAccessor.LoadChunksToCache(
+            new Vec3i(minChunkXPos, minChunkYPos + dimensionYOffset, minChunkZPos),
+            new Vec3i(maxChunkXPos, maxChunkYPos + dimensionYOffset, maxChunkZPos)
+        );
+        var chunkCountX = maxChunkXPos - minChunkXPos + 1;
+        var chunkCountZ = maxChunkZPos - minChunkZPos + 1;
+
+        for (var y = minYPos; y <= maxYPos; y++)
+        {
+            var chunkIndexY = (y / GlobalConstants.ChunkSize - minChunkYPos) * chunkCountZ - minChunkZPos;
+            for (var z = minZPos; z <= maxZPos; z++)
+            {
+                var chunkIndexBase = (chunkIndexY + z / GlobalConstants.ChunkSize) * chunkCountX - minChunkXPos;
+                var blockIndexBase = (y % GlobalConstants.ChunkSize * GlobalConstants.ChunkSize + z % GlobalConstants.ChunkSize) * GlobalConstants.ChunkSize;
+                for (var x = minXPos; x <= maxXPos; x++)
+                {
+                    if (!predicate.Invoke(x, y, z))
+                    {
+                        continue;
+                    }
+
+                    var chunk = chunks[chunkIndexBase + x / GlobalConstants.ChunkSize];
+
+                    if (chunk is null)
+                    {
+                        continue;
+                    }
+
+                    var blockIndex = blockIndexBase + x % GlobalConstants.ChunkSize;
+                    var blockId = chunk.GetFluid(blockIndex);
+
+                    if (blockId != 0)
+                    {
+                        onBlock(worldAccessor.Blocks[blockId], x, y, z);
+                    }
+
+                    blockId = chunk.GetSolidBlock(blockIndex);
+                    onBlock(worldAccessor.Blocks[blockId], x, y, z);
+                }
+            }
+        }
+    }
+
+    // https://stackoverflow.com/a/7227057
+    private static bool IsInCircle(Vec3i center, int radius, int x, int z)
+    {
+        var dX = Math.Abs(x - center.X);
+        var dZ = Math.Abs(z - center.Z);
+
+        if (dX + dZ <= radius)
+        {
+            return true;
+        }
+
+        if (dX > radius || dZ > radius)
+        {
+            return false;
+        }
+
+        return Math.Pow(dX, 2) + Math.Pow(dX, 2) <= Math.Pow(radius, 2);
+    }
+
+    private static bool IsInSphere(Vec3i center, int radius, int x, int y, int z)
+    {
+        var dX = Math.Abs(x - center.X);
+        var dY = Math.Abs(y - center.Y);
+        var dZ = Math.Abs(z - center.Z);
+
+        if (dX + dY + dZ <= radius)
+        {
+            return true;
+        }
+
+        if (dX > radius || dY > radius || dZ > radius)
+        {
+            return false;
+        }
+
+        return Math.Pow(dX, 2) + Math.Pow(dY, 2) + Math.Pow(dX, 2) <= Math.Pow(radius, 2);
+    }
+}
diff --git a/Common.Mod/System.cs b/Common.Mod/System.cs
@@ -31,7 +31,7 @@ public abstract class System<TSystem> : ModSystem, ISystem
 
     private const string ConfigLibModId = "configlib";
 
-    [UsedImplicitly(ImplicitUseKindFlags.Access)]
+    [UsedImplicitly]
     public static TSystem? Instance { get; private set; }
 
     [UsedImplicitly] public readonly IContainer Container = new Container();
diff --git a/bootstrap.sh b/bootstrap.sh
@@ -23,6 +23,7 @@ vsFiles=(
     "Lib/protobuf-net.dll"
     "Mods/VSEssentials.dll"
     "VintagestoryAPI.dll"
+    "VintagestoryLib.dll"
 )
 for vsFile in "${vsFiles[@]}"; do
     baseVsFile=$(basename "$vsFile")

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,9 @@`
	`1`	`+using JetBrains.Annotations;`
`1`	`2`	`using Vintagestory.API.Server;`
`2`	`3`
`3`	`4`	`namespace Common.Mod.Common.Config;`
`4`	`5`
	`6`	`+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]`
`5`	`7`	`public interface IConfigSystem`
`6`	`8`	`{`
`7`	`9`	`#region Event delegates`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace Common.Mod.Common.Core;`
`4`	`4`
`5`		`-[UsedImplicitly(ImplicitUseKindFlags.Access, ImplicitUseTargetFlags.Members)]`
	`5`	`+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]`
`6`	`6`	`public record LogEntry`
`7`	`7`	`{`
`8`	`8`	`public DateTime Timestamp { get; init; }`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`namespace Common.Mod.Generator.Specs;`
`4`	`4`
`5`		`-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]`
	`5`	`+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]`
`6`	`6`	`public record ConfigEntrySpec`
`7`	`7`	`{`
`8`	`8`	`public string Name { get; set; } = null!;`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`namespace Common.Mod.Generator.Specs;`
`5`	`5`
`6`		`-[UsedImplicitly(ImplicitUseKindFlags.Assign, ImplicitUseTargetFlags.Members)]`
	`6`	`+[UsedImplicitly(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Members)]`
`7`	`7`	`public record ConfigEnumSpec`
`8`	`8`	`{`
`9`	`9`	`public string EnumName { get; set; } = null!;`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public override Cuboidf[] GetParticleCollisionBoxes(IBlockAccessor blockAccessor`
`22`	`22`	`);`
`23`	`23`	`}`
`24`	`24`
`25`		- // This is copy-pasted from the `BlockMultiblock` class where it is private
	`25`	+ // This is more or less copy-pasted from the `BlockMultiblock` class where it is private
`26`	`26`	`private static T Handle<T, TK>(`
`27`	`27`	`IBlockAccessor blockAccessor,`
`28`	`28`	`int x,`
`@@ -35,24 +35,13 @@ BlockCallDelegateBlock<T> onOtherwise`
`35`	`35`	`where TK : class`
`36`	`36`	`{`
`37`	`37`	`var block = blockAccessor.GetBlock((new Vec3i(x, y, z)).ToBlockPos());`
`38`		`- var blockInf = block as TK;`
`39`		`-`
`40`		`- if (blockInf == null)`
`41`		`- {`
`42`		`- blockInf = block.GetBehavior(typeof(TK), true) as TK;`
`43`		`- }`
	`38`	`+ var blockInf = block as TK ?? block.GetBehavior(typeof(TK), true) as TK;`
`44`	`39`
`45`	`40`	`if (blockInf != null)`
`46`	`41`	`{`
`47`	`42`	`return onImplementsInterface(blockInf);`
`48`	`43`	`}`
`49`	`44`
`50`		`- // This is to prevent endless recursion in situations where blocks become incorrectly arranged`
`51`		`- if (block is BlockMultiblock)`
`52`		`- {`
`53`		`- return onIsMultiblock(block);`
`54`		`- }`
`55`		`-`
`56`		`- return onOtherwise(block);`
	`45`	`+ return block is BlockMultiblock ? onIsMultiblock(block) : onOtherwise(block);`
`57`	`46`	`}`
`58`	`47`	`}`