adjusted debug mode

fixed trying to draw out of bounds

Scenes/PerfDetails.cs

@@ -3,13 +3,10 @@ using Godot;
 
 public partial class PerfDetails : Label
 {
-	[Export]
-	public bool ShowDetails = true;
-
 	public override void _Process(double delta)
 	{
 		Text = "";
-		if (!ShowDetails) return;
+		if (!Main.Instance.DebugMode) return;
 
 		int activeElements = 0;
 		foreach (Chunk c in Main.Instance.Level.GetChunks())

Scenes/main.tscn

@@ -7,7 +7,6 @@
 
 [node name="Main" type="Node2D"]
 script = ExtResource("1_k1i8e")
-DebugVisualization = true
 BrushSize = 2
 RainAmount = 1.0
 

Scripts/Elements/Element.cs

@@ -18,6 +18,7 @@ public class Element {
     protected int lastMove = 0;
 
     private bool active = false;
+    private bool wasMovedThisTick = false;
     private int lastUpdate = -1;
     private Color originalColor;
 
@@ -33,6 +34,7 @@ public class Element {
         Chunk = chunk;
         lastMove = Engine.GetFramesDrawn();
         Active = false;
+        wasMovedThisTick = true;
     }
 
     public bool Active {
@@ -42,7 +44,7 @@ public class Element {
 
             active = value;
             Chunk.SetElementActive(this, value);
-            // SetDebugColor(value, new Color(0.2f, 0.2f, 0.2f));
+            Moved();
         }
     }
 
@@ -68,6 +70,7 @@ public class Element {
 
     protected virtual void Tick() {
         Vector2I randomDirection = RandomDirectionDown();
+        wasMovedThisTick = false;
 
         if (Chunk.IsEmpty(Position + Vector2I.Down))
             Chunk.Swap(this, Position + Vector2I.Down);
@@ -106,12 +109,18 @@ public class Element {
     }
 
     public void SetDebugColor(Color color) {
-        if (!Main.Instance.DebugVisualization) return;
+        if (!Main.Instance.DebugMode) return;
 
         this.color = color;
+        wasMovedThisTick = true;
     }
 
     public void Moved() {
         lastMove = Engine.GetFramesDrawn();
+        wasMovedThisTick = true;
+    }
+
+    public bool WasMoved() {
+        return wasMovedThisTick;
     }
 }

Scripts/Level.cs

@@ -69,7 +69,7 @@ public class Level {
         GD.Print("benchmark");
         for (int x = 0; x < chunksPerX; x++) {
             for (int y = 0; y < chunksPerY; y++) {
-                WritePixel<Dirt>(x * chunkResX/2, y * chunkResY/2, 100);
+                WritePixel<Dirt>((x * chunkResX) + chunkResX/2, (y * chunkResY) + chunkResY/2, 100);
             }
         }
     }
@@ -92,64 +92,73 @@ public class Level {
     public void WritePixel<T>(int x, int y, int size) {
         int halfsize = size/2;
 
+        int startPtX = x % chunkResX;
+        int startPtY = y % chunkResY;
+
         for (int i = -halfsize; i <= halfsize; i++) {
-            for (int j = 0; j < 1; j++) {
-            // for (int j = -halfsize; j <= halfsize; j++) {
+            for (int j = -halfsize; j <= halfsize; j++) {
+
                 // calculate in-chunk coordinates
-                int inChunkX = x % chunkResX;
-                int inChunkY = y % chunkResY;
-                int brushX = i;
-                int brushY = j;
+                int iteratorX = i;
+                int iteratorY = j;
+                int ptX = startPtX;
+                int ptY = startPtY;
 
                 // calculate chunk to write to
                 int chunkX = x/chunkResX;
-                if (inChunkX + i < 0) {
-                    chunkX--;
-                    //           320               -22
-                    brushX = chunkResX + inChunkX + i;
-                    inChunkX = chunkResX - inChunkX;
-                } else if (inChunkX + i >= chunkResX) {
-                    chunkX++;
-                    inChunkX = 0;
-                    brushX = i % chunkResX;
-                }
-                inChunkX += brushX;
 
-                if (chunkX < 0 || chunkX >= chunksPerX) {
-                    GD.PrintErr($"Trying to write out of bounds: {x}:{y}");
-                    return;
+                // left of chunk
+                if (startPtX + iteratorX < 0) {
+                    chunkX--;
+                    iteratorX = chunkResX + startPtX + iteratorX;
+                    ptX = startPtX + iteratorX;
+
+                // right of chunk
+                } else if (startPtX + iteratorX >= chunkResX) {
+                    chunkX++;
+                    ptX = startPtX + iteratorX - chunkResX;
+                } else {
+                    ptX = startPtX + iteratorX;
                 }
 
                 int chunkY = y/chunkResY;
-                if (inChunkY + j < 0) {
+
+                // above chunk
+                if (startPtY + iteratorY < 0) {
                     chunkY--;
-                    brushY = chunkResY - (inChunkY + j);
-                    inChunkY = chunkResY - inChunkY;
-                } else if (inChunkY + j >= chunkResY) {
+                    ptY = chunkResY + (startPtY + iteratorY);
+
+                // left of chunk
+                } else if (startPtY + iteratorY >= chunkResY) {
                     chunkY++;
-                    inChunkY = 0;
-                    brushY = j % chunkResY;
-                }
-                inChunkY += brushY;
-
-                if (chunkY < 0 || chunkY >= chunksPerY) {
-                    GD.PrintErr($"Trying to write out of bounds: {x}:{y}");
-                    return;
+                    ptY = iteratorY % chunkResY;
+                } else {
+                    ptY = startPtY + iteratorY;
                 }
 
-                chunks[chunkX, chunkY].WritePixel<T>(inChunkX, inChunkY);
+                // ignore everything outside
+                if (chunkX < 0) continue;
+                if (chunkX >= chunksPerX) continue;
+                if (chunkY < 0) continue;
+                if (chunkY >= chunksPerY) continue;
+
+                chunks[chunkX, chunkY].WritePixel<T>(ptX, ptY);
             }
         }
     }
 
     public Image DrawLevel() {
+        // chunk
         for (int cx = 0; cx < chunksPerX; cx++) {
             for (int cy = 0; cy < chunksPerY; cy++) {
 
+                // pixel in chunk
                 for (int x = 0; x < chunkResX; x++) {
                     for (int y = 0; y < chunkResY; y++) {
                         // TODO: multithreading here! use Chunk.DrawLevel() and stitch images together
-                        image.SetPixel(cx*chunkResX + x, cy*chunkResY + y, chunks[cx,cy].Elements[x, y].Color);
+
+                        if (chunks[cx, cy].Elements[x, y].WasMoved())
+                            image.SetPixel(cx*chunkResX + x, cy*chunkResY + y, chunks[cx, cy].Elements[x, y].Color);
                     }
                 }
             }

Scripts/Main.cs

@@ -3,7 +3,7 @@ using FOU.Scripts.Elements;
 using Godot;
 
 public partial class Main : Node2D {
-	[Export] public bool DebugVisualization = false;
+	[Export] public bool DebugMode = false;
 
 	[Export] public int BrushSize = 5;
 	[Export] public float TextureResolution = 0.5f;
@@ -32,6 +32,7 @@ public partial class Main : Node2D {
 	}
 
 	public override void _Process(double delta) {
+		mLevelDrawer.Texture?.Dispose();
 		mLevelDrawer.Texture = ImageTexture.CreateFromImage(Level.DrawLevel());
 	}