Added chunked map that's not faster

DeveMazeGeneratorCore.ConsoleApp/Program.cs

@@ -263,15 +263,15 @@ public static void TestWithSave()
             int size = 128;
             var fastestElapsed = TimeSpan.MaxValue;
 
-            var alg = new AlgorithmBacktrack2Deluxe2WithBorder_AsByte();
+            var alg = new AlgorithmBacktrack2Deluxe2_AsByte();
 
             Console.WriteLine($"Generating maze using {alg.GetType().Name}...");
 
             int seed = 1337;
 
             var w = Stopwatch.StartNew();
 
-            var innerMapFactory = new InnerMapFactory<BitArreintjeFastInnerMap>();
+            var innerMapFactory = new InnerMapFactory<BitArreintjeFastChunkedInnerMap>();
             var randomFactory = new RandomFactory<XorShiftRandom>();
 
             var actionThing = new NoAction();

DeveMazeGeneratorCore/Factories/InnerMapFactory.cs

@@ -12,6 +12,7 @@ public T Create(int desiredWidth, int desiredHeight)
         {
             var typeSwitcher = new TypeSwitch<InnerMap>()
               .Case(() => new BitArreintjeFastInnerMap(desiredWidth, desiredHeight))
+              .Case(() => new BitArreintjeFastChunkedInnerMap(desiredWidth, desiredHeight))
               .Case(() => new BitArreintjeFastHilbertInnerMap(desiredWidth, desiredHeight))
               .Case(() => new BoolInnerMap(desiredWidth, desiredHeight));
 

DeveMazeGeneratorCore/InnerMaps/BitArreintjeFastChunkedInnerMap.cs

@@ -0,0 +1,79 @@
+using DeveMazeGeneratorCore.InnerMaps.InnerStuff;
+using System.Runtime.CompilerServices;
+
+namespace DeveMazeGeneratorCore.InnerMaps
+{
+    public class BitArreintjeFastChunkedInnerMap : InnerMap
+    {
+        private BitArreintjeFastInnerMapArray[] _innerData;
+
+        public const int ChunkSize = 8;
+        private int _chunksPerRow;
+
+        public BitArreintjeFastChunkedInnerMap(int width, int height)
+            : base(width, height)
+        {
+            _chunksPerRow = width / ChunkSize;
+            var chunkCount = _chunksPerRow * (height / ChunkSize);
+
+            _innerData = new BitArreintjeFastInnerMapArray[chunkCount];
+            for (int i = 0; i < chunkCount; i++)
+            {
+                _innerData[i] = new BitArreintjeFastInnerMapArray(ChunkSize * ChunkSize);
+            }
+        }
+
+        public override void FillMap(bool state)
+        {
+            for (int i = 0; i < _innerData.Length; i++)
+            {
+                _innerData[i].FillMap(state);
+            }
+        }
+
+        public override InnerMap Clone()
+        {
+            var innerMapTarget = new BitArreintjeFastChunkedInnerMap(Width, Height);
+            for (int i = 0; i < _innerData.Length; i++)
+            {
+                innerMapTarget._innerData[i] = _innerData[i].Clone();
+            }
+            return innerMapTarget;
+        }
+
+        public override bool this[int x, int y]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                int chunkX = x / ChunkSize;
+                int chunkY = y / ChunkSize;
+
+                var chunkNumber = chunkY * _chunksPerRow + chunkX;
+
+                int localX = x % ChunkSize;
+                int localY = y % ChunkSize;
+
+                var positionInChunk = localY * ChunkSize + localX;
+
+
+                return _innerData[chunkNumber][positionInChunk];
+            }
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            set
+            {
+                int chunkX = x / ChunkSize;
+                int chunkY = y / ChunkSize;
+
+                var chunkNumber = chunkY * _chunksPerRow + chunkX;
+
+                int localX = x % ChunkSize;
+                int localY = y % ChunkSize;
+
+                var positionInChunk = localY * ChunkSize + localX;
+
+                _innerData[chunkNumber][positionInChunk] = value;
+            }
+        }
+    }
+}