Fixed tests.

src/Arch.Tests/WorldTest.cs

@@ -280,7 +280,7 @@ public void TrimExcess()
         var archetype = world.Archetypes[0];
         That(world.Size, Is.EqualTo(1));
         That(world.Capacity, Is.EqualTo(archetype.EntitiesPerChunk));
-        That(archetype.ChunkCount, Is.EqualTo(1));
+        That(archetype.ChunkCount, Is.EqualTo(0));
         That(archetype.ChunkCapacity, Is.EqualTo(1));
 
         // Recycled ids must be trimmed too so that the newest created entity is not out of bounds!

src/Arch/Core/Archetype.cs

@@ -480,18 +480,19 @@ public void AddAll(Span<Entity> entities, int amount)
         EnsureEntityCapacity(EntityCount + amount);
 
         var created = 0;
-        for(var index = ChunkCount; index < ChunkCapacity && created < amount; index++)
+        for(var index = Count; index < ChunkCapacity && created < amount; index++)
         {
             ref var chunk = ref GetChunk(index);
             var fillAmount = Math.Min(chunk.Buffer, amount - created);
 
             Chunk.Copy(ref entities, created, ref chunk, chunk.Count, fillAmount);
             chunk.Count += fillAmount;
 
-            Count = chunk.IsFull ? ChunkCount + 1 : ChunkCount;
+            Count = chunk.IsFull ? Count + 1 : Count;
             created += fillAmount;
         }
 
+        Count--;
         EntityCount += amount;
     }
 
@@ -747,6 +748,7 @@ internal void EnsureEntityCapacity(int newCapacity)
     /// </summary>
     internal void TrimExcess()
     {
+        Chunks.Count = Count; // By setting the Count we will assure that unnecessary chunks are trimmed.
         Chunks.TrimExcess();
     }
 }

src/Arch/Core/Chunk.cs

@@ -24,11 +24,11 @@ public Chunks(int capacity = 1)
 
     public Array<Chunk> Items { get; set; }
     public int Count { get; set; }
-    public int Capacity { get; set; }
+    public int Capacity { get; private set; }
 
     public void Add(in Chunk chunk)
     {
-        Debug.Assert(Count+1 <= Capacity, "Capacity exceeded.");
+        Debug.Assert(Count + 1 <= Capacity, "Capacity exceeded.");
         Items[Count++] = chunk;
     }
 

src/Arch/Core/World.cs

@@ -384,7 +384,7 @@ public void TrimExcess()
             }
 
             archetype.TrimExcess();
-            Capacity += archetype.ChunkCount * archetype.EntitiesPerChunk; // Since always one chunk always exists.
+            Capacity += archetype.EntityCapacity;
         }
 
         // Traverse recycled ids and remove all that are higher than the current capacity.