task: increase code coverage

Author: mrdav30

src/GridForge/Grids/Managers/GridDirectionUtility.cs

@@ -15,11 +15,13 @@ public static class GridDirectionUtility
     /// <returns>The corresponding <see cref="SpatialDirection"/>, or <see cref="SpatialDirection.None"/> if invalid.</returns>
     public static SpatialDirection GetNeighborDirectionFromOffset((int x, int y, int z) gridOffset)
     {
-        Debug.Assert(gridOffset.x >= -1 && gridOffset.x <= 1, "Invalid x offset.");
-        Debug.Assert(gridOffset.y >= -1 && gridOffset.y <= 1, "Invalid y offset.");
-        Debug.Assert(gridOffset.z >= -1 && gridOffset.z <= 1, "Invalid z offset.");
+        if(IsValidOffset(gridOffset) == false)
+        {
+            GridForgeLogger.DebugChannel.Info($"Invalid grid offset: {gridOffset}. Offsets must be in the range [-1, 1] for each axis.");
+            return SpatialDirection.None;
+        }
 
-        if (gridOffset == (0, 0, 0))
+        if (gridOffset == (0, 0, 0)) // The center voxel does not correspond to any direction.
             return SpatialDirection.None;
 
         for (int i = 0; i < SpatialAwareness.DirectionOffsets.Length; i++)
@@ -30,4 +32,11 @@ public static SpatialDirection GetNeighborDirectionFromOffset((int x, int y, int
 
         return SpatialDirection.None;
     }
+
+    private static bool IsValidOffset((int x, int y, int z) offset)
+    {
+        return offset.x >= -1 && offset.x <= 1 &&
+               offset.y >= -1 && offset.y <= 1 &&
+               offset.z >= -1 && offset.z <= 1;
+    }
 }

src/GridForge/Utility/GridTracer.cs

@@ -258,6 +258,41 @@ private static IEnumerable<GridVoxelSet> TraceLineIterator(
         SwiftDictionary<VoxelGrid, SwiftList<Voxel>> gridVoxelMapping = new();
         SwiftHashSet<Voxel> voxelRedundancyCheck = SwiftHashSetPool<Voxel>.Shared.Rent();
 
+        try
+        {
+            AddTraceLineVoxelsToMapping(
+                world,
+                start,
+                end,
+                padding,
+                gridVoxelMapping,
+                voxelRedundancyCheck);
+
+            AddTraceLineEndVoxel(
+                world,
+                end,
+                includeEnd,
+                gridVoxelMapping,
+                voxelRedundancyCheck);
+
+            foreach (KeyValuePair<VoxelGrid, SwiftList<Voxel>> kvp in gridVoxelMapping)
+                yield return new GridVoxelSet(kvp.Key, kvp.Value);
+        }
+        finally
+        {
+            ReleaseTraceLineMapping(gridVoxelMapping);
+            SwiftHashSetPool<Voxel>.Shared.Release(voxelRedundancyCheck);
+        }
+    }
+
+    private static void AddTraceLineVoxelsToMapping(
+        GridWorld world,
+        Vector3d start,
+        Vector3d end,
+        Fixed64? padding,
+        SwiftDictionary<VoxelGrid, SwiftList<Voxel>> gridVoxelMapping,
+        SwiftHashSet<Voxel> voxelRedundancyCheck)
+    {
         (Vector3d snappedMin, Vector3d snappedMax) =
             world.SnapBoundsToVoxelSize(start, end, padding);
 
@@ -273,9 +308,7 @@ private static IEnumerable<GridVoxelSet> TraceLineIterator(
 
         Vector3d diff = traceEnd - traceStart;
         Vector3d delta = Vector3d.Abs(diff);
-
         Fixed64 steps = FixedMath.Ceiling(FixedMath.Max(FixedMath.Max(delta.x, delta.y), delta.z));
-
         Fixed64 stepX = diff.x / (steps + Fixed64.One);
         Fixed64 stepY = diff.y / (steps + Fixed64.One);
         Fixed64 stepZ = diff.z / (steps + Fixed64.One);
@@ -285,49 +318,103 @@ private static IEnumerable<GridVoxelSet> TraceLineIterator(
             if (!world.SpatialGridHash.TryGetValue(cellIndex, out SwiftHashSet<ushort> gridList))
                 continue;
 
-            foreach (ushort gridIndex in gridList)
-            {
-                if (!world.ActiveGrids.IsAllocated(gridIndex))
-                    continue;
-
-                VoxelGrid currentGrid = world.ActiveGrids[gridIndex];
-                if (gridVoxelMapping.ContainsKey(currentGrid))
-                    continue;
+            AddTraceLineVoxelsForCell(
+                world,
+                gridList,
+                traceStart,
+                steps,
+                stepX,
+                stepY,
+                stepZ,
+                gridVoxelMapping,
+                voxelRedundancyCheck);
+        }
+    }
 
-                SwiftList<Voxel> voxelList = SwiftListPool<Voxel>.Shared.Rent();
-                gridVoxelMapping.Add(currentGrid, voxelList);
+    private static void AddTraceLineVoxelsForCell(
+        GridWorld world,
+        SwiftHashSet<ushort> gridList,
+        Vector3d traceStart,
+        Fixed64 steps,
+        Fixed64 stepX,
+        Fixed64 stepY,
+        Fixed64 stepZ,
+        SwiftDictionary<VoxelGrid, SwiftList<Voxel>> gridVoxelMapping,
+        SwiftHashSet<Voxel> voxelRedundancyCheck)
+    {
+        foreach (ushort gridIndex in gridList)
+        {
+            if (!world.ActiveGrids.IsAllocated(gridIndex))
+                continue;
 
-                for (Fixed64 i = Fixed64.Zero; i <= steps; i += Fixed64.One)
-                {
-                    Vector3d tracePos = world.FloorToVoxelSize(
-                        new Vector3d(
-                            traceStart.x + stepX * i,
-                            traceStart.y + stepY * i,
-                            traceStart.z + stepZ * i));
+            VoxelGrid currentGrid = world.ActiveGrids[gridIndex];
+            if (gridVoxelMapping.ContainsKey(currentGrid))
+                continue;
 
-                    if (!currentGrid.TryGetVoxel(tracePos, out Voxel? voxel) || voxelRedundancyCheck.Add(voxel!) != true)
-                        continue;
+            SwiftList<Voxel> voxelList = SwiftListPool<Voxel>.Shared.Rent();
+            gridVoxelMapping.Add(currentGrid, voxelList);
 
-                    voxelList.Add(voxel!);
-                }
-            }
+            AddTraceLineGridVoxels(
+                world,
+                currentGrid,
+                traceStart,
+                steps,
+                stepX,
+                stepY,
+                stepZ,
+                voxelList,
+                voxelRedundancyCheck);
         }
+    }
 
-        if (includeEnd
-            && world.TryGetGridAndVoxel(end, out VoxelGrid? endGrid, out Voxel? endVoxel)
-            && gridVoxelMapping.TryGetValue(endGrid!, out SwiftList<Voxel> endVoxelList)
-            && voxelRedundancyCheck.Add(endVoxel!))
+    private static void AddTraceLineGridVoxels(
+        GridWorld world,
+        VoxelGrid currentGrid,
+        Vector3d traceStart,
+        Fixed64 steps,
+        Fixed64 stepX,
+        Fixed64 stepY,
+        Fixed64 stepZ,
+        SwiftList<Voxel> voxelList,
+        SwiftHashSet<Voxel> voxelRedundancyCheck)
+    {
+        for (Fixed64 i = Fixed64.Zero; i <= steps; i += Fixed64.One)
         {
-            endVoxelList.Add(endVoxel!);
+            Vector3d tracePos = world.FloorToVoxelSize(
+                new Vector3d(
+                    traceStart.x + stepX * i,
+                    traceStart.y + stepY * i,
+                    traceStart.z + stepZ * i));
+
+            if (!currentGrid.TryGetVoxel(tracePos, out Voxel? voxel) || voxelRedundancyCheck.Add(voxel!) != true)
+                continue;
+
+            voxelList.Add(voxel!);
         }
+    }
 
-        foreach (KeyValuePair<VoxelGrid, SwiftList<Voxel>> kvp in gridVoxelMapping)
+    private static void AddTraceLineEndVoxel(
+        GridWorld world,
+        Vector3d end,
+        bool includeEnd,
+        SwiftDictionary<VoxelGrid, SwiftList<Voxel>> gridVoxelMapping,
+        SwiftHashSet<Voxel> voxelRedundancyCheck)
+    {
+        if (!includeEnd
+            || !world.TryGetGridAndVoxel(end, out VoxelGrid? endGrid, out Voxel? endVoxel)
+            || !gridVoxelMapping.TryGetValue(endGrid!, out SwiftList<Voxel> endVoxelList)
+            || !voxelRedundancyCheck.Add(endVoxel!))
         {
-            yield return new GridVoxelSet(kvp.Key, kvp.Value);
-            SwiftListPool<Voxel>.Shared.Release(kvp.Value);
+            return;
         }
 
-        SwiftHashSetPool<Voxel>.Shared.Release(voxelRedundancyCheck);
+        endVoxelList.Add(endVoxel!);
+    }
+
+    private static void ReleaseTraceLineMapping(SwiftDictionary<VoxelGrid, SwiftList<Voxel>> gridVoxelMapping)
+    {
+        foreach (KeyValuePair<VoxelGrid, SwiftList<Voxel>> kvp in gridVoxelMapping)
+            SwiftListPool<Voxel>.Shared.Release(kvp.Value);
     }
 
     private static IEnumerable<GridVoxelSet> GetCoveredVoxelsIterator(

tests/GridForge.Benchmarks/GridForge.Benchmarks.csproj

@@ -16,11 +16,11 @@
     <ProjectReference Include="..\..\src\GridForge\GridForge.csproj" />
     <PackageReference Include="BenchmarkDotNet" Version="0.15.8" />
     <PackageReference Include="FixedMathSharp" Version="3.0.1" />
-    <PackageReference Include="SwiftCollections" Version="4.0.3" />
+    <PackageReference Include="SwiftCollections" Version="4.0.4" />
     <PackageReference Include="System.Text.Json" Version="10.0.7" />
     <!-- The Test SDK is required only for the VSTest Adapter to work -->
   </ItemGroup>
   <ItemGroup>
     <None Remove=".gitignore" />
   </ItemGroup>
-</Project>
+</Project>

tests/GridForge.Tests/GridForge.Tests.csproj

@@ -24,7 +24,7 @@
 		</PackageReference>
 		<PackageReference Include="FixedMathSharp" Version="3.0.1" />
 		<PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.5.1" />
-		<PackageReference Include="SwiftCollections" Version="4.0.3" />
+		<PackageReference Include="SwiftCollections" Version="4.0.4" />
 		<PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -38,4 +38,4 @@
 	<ItemGroup>
 		<None Remove=".gitignore" />
 	</ItemGroup>
-</Project>
+</Project>