improved overwrite

fixed fall speed
improved naming

Scenes/SettingsController.cs

@@ -1,4 +1,3 @@
-using System.Reflection;
 using Godot;
 
 public partial class SettingsController : VBoxContainer
@@ -18,7 +17,7 @@ public partial class SettingsController : VBoxContainer
 		slSize.Value = main.BrushSize;
 
 		slRain.ValueChanged += OnRainValueChanged;
-		slRain.Value = main.RainAmount;
+		slRain.Value = main.rainAmount;
 	}
 
 	private void OnSizeValueChanged(double value) {

Scenes/main.tscn

@@ -7,8 +7,8 @@
 
 [node name="Main" type="Node2D"]
 script = ExtResource("1_k1i8e")
-BrushSize = 2
-RainAmount = 1.0
+DebugMode = true
+BrushSize = 4
 
 [node name="CanvasLayer" type="CanvasLayer" parent="."]
 
@@ -84,6 +84,6 @@ custom_minimum_size = Vector2(150, 0)
 layout_mode = 2
 size_flags_horizontal = 8
 size_flags_vertical = 1
-max_value = 5.0
+max_value = 10.0
 step = 0.01
 value = 1.0

Scripts/Chunk.cs

@@ -13,7 +13,6 @@ public class Chunk {
     public Chunk NeighborS = null;
     public Chunk NeighborW = null;
 
-    private readonly Image image;
     private readonly int sizeX;
     private readonly int sizeY;
     private readonly HashSet<Element> activeElements;
@@ -33,9 +32,6 @@ public class Chunk {
         }
 
         activeElements = new HashSet<Element>(sizeX * sizeY);
-
-        image = Image.CreateEmpty(sizeX, sizeY, false, Image.Format.Rgb8);
-        image.Fill(Colors.Black);
     }
 
     public void Update() {
@@ -54,14 +50,14 @@ public class Chunk {
         if (toAddElements.Count > 0) {
             foreach (Element addElement in toAddElements) {
                 activeElements.Add(addElement);
-                addElement.SetDebugColor(Colors.Green);
+                addElement.SetDebugColor(addElement.Color * 1.5f);
             }
             toAddElements.Clear();
         }
     }
 
     public void SetElementActive(Element e, bool active) {
-        if (e.GetType() == typeof(Element) && active) return;
+        if (e.GetType() == typeof(Element)) return;
 
         if (active) AddToChunk(e);
         else RemoveFromChunk(e);
@@ -73,15 +69,16 @@ public class Chunk {
             return;
         }
 
+        // check if not empty and overwrite not allowed:
+        if (!Elements[x,y].IsEmpty() && !Main.Instance.AllowOverwrite)
+            return;
+        else if (!Elements[x,y].IsEmpty()) {
+            Elements[x, y].Chunk.RemoveFromChunk(Elements[x, y]);
+        }
+
         Type type = typeof(T);
         object o = Activator.CreateInstance(type, x, y, this);
 
-        // check if not empty:
-        if (Elements[x,y].GetType() != typeof(Element)) {
-            return;
-        }
-
-        Elements[x, y].Chunk.RemoveFromChunk(Elements[x, y]);
         Elements[x, y] = o as Element;
         Elements[x, y].Active = true;
     }
@@ -90,10 +87,6 @@ public class Chunk {
         return activeElements.Count;
     }
 
-    public void Swap(Element what, Vector2I pos) {
-        Swap(what, Get(pos));
-    }
-
     public Element Get(Vector2I pos) {
         Element e = null;
 
@@ -129,6 +122,10 @@ public class Chunk {
         return Get(pos)?.GetType() == typeof(Element);
     }
 
+    public void Swap(Element what, Vector2I pos) {
+        Swap(what, Get(pos));
+    }
+
     private void Swap(Element what, Element swapTo) {
         if (what == null || swapTo == null) {
             GD.PrintErr("Trying to swap null");
@@ -138,6 +135,9 @@ public class Chunk {
         if (what.Chunk != swapTo.Chunk) {
             what.Chunk.RemoveFromChunk(what);
             swapTo.Chunk.AddToChunk(what);
+
+            swapTo.Chunk.RemoveFromChunk(swapTo);
+            what.Chunk.AddToChunk(swapTo);
         }
 
         Element temp = new Element(what);
@@ -152,8 +152,13 @@ public class Chunk {
 
         what.Active = true;
         what.Moved();
+        if (what.IsEmpty())
+            what.ActivateNeighbors();
+
         swapTo.Active = true;
         swapTo.Moved();
+        if (swapTo.IsEmpty())
+            swapTo.ActivateNeighbors();
     }
 
     public override string ToString() {

Scripts/Elements/Element.cs

@@ -2,49 +2,55 @@
 
 namespace FOU.Scripts.Elements;
 
-public class Element {
+public class Element{
 
     public Chunk Chunk;
     public Vector2I Position;
+    public int Density;
 
-    protected int Density;
     protected int DiffuseSpeed = 10;
     protected Color color = Colors.Black;
     protected const int MAX_DIFFUSE_SPEED = 100;
     protected const int STEPS_UNTIL_INACTIVE = 500;
 
-    protected const float MAX_COLOR_VARIANCE = 0.1f;
     protected static readonly Vector2I VERTICAL_OPPOSITE = new Vector2I(-1, 1);
-    protected int lastMove = 0;
+    private const float MAX_COLOR_VARIANCE = 0.1f;
 
     private bool active = false;
-    private bool wasMovedThisTick = false;
+    private bool markedForUpdate = true;
     private int lastUpdate = -1;
+    private int lastMove = 0;
     private Color originalColor;
 
     public Element(Element e) {
         Position = e.Position;
         Chunk = e.Chunk;
-        lastMove = Engine.GetFramesDrawn();
+        Active = e.active;
+        lastMove = e.lastMove;
+        lastUpdate = e.lastUpdate;
+        Chunk.SetElementActive(this, Active);
     }
 
-    public Element(int x, int y, Chunk chunk) {
+    public Element(int x, int y, Chunk chunk, bool active = true) {
         Position.X = x;
         Position.Y = y;
         Chunk = chunk;
         lastMove = Engine.GetFramesDrawn();
-        Active = false;
-        wasMovedThisTick = true;
+        Chunk.SetElementActive(this, Active);
     }
 
     public bool Active {
         get => active;
         set {
             if (active == value) return;
-
             active = value;
             Chunk.SetElementActive(this, value);
-            Moved();
+
+            if (active) {
+                Moved();
+            } else {
+                ResetColor();
+            }
         }
     }
 
@@ -58,9 +64,13 @@ public class Element {
     public virtual bool Update() {
         if (!Active) return false;
 
-        if (lastUpdate == Engine.GetFramesDrawn()) return false; // already updated this frame
-        lastUpdate = Engine.GetFramesDrawn();
+        int frame = Engine.GetFramesDrawn();
+        if (lastMove + STEPS_UNTIL_INACTIVE < frame)
+            Active = false;
+        if (lastUpdate == frame)
+            return false; // already updated this frame
 
+        lastUpdate = frame;
         return true;
     }
 
@@ -68,24 +78,7 @@ public class Element {
         return $"{GetType()} {Position}[{Chunk.Index}] {active}";
     }
 
-    protected virtual void Tick() {
-        Vector2I randomDirection = RandomDirectionDown();
-        wasMovedThisTick = false;
-
-        if (Chunk.IsEmpty(Position + Vector2I.Down))
-            Chunk.Swap(this, Position + Vector2I.Down);
-
-        else if (Chunk.IsEmpty(Position + randomDirection))
-            Chunk.Swap(this, Position + randomDirection);
-
-        else if (Chunk.IsEmpty(Position + randomDirection * VERTICAL_OPPOSITE))
-            Chunk.Swap(this, Position + randomDirection * VERTICAL_OPPOSITE);
-
-        if (GD.Randi() % MAX_DIFFUSE_SPEED > DiffuseSpeed) return; // ascend slower
-
-        if (Chunk.Get(Position + randomDirection)?.Density < Density)
-            Chunk.Swap(this, Position + Vector2I.Down);
-    }
+    protected virtual void Tick() { }
 
     protected Vector2I RandomDirectionDown() {
         int randomDirection = GD.Randi() % 2 != 0 ? 1 : -1;
@@ -94,6 +87,13 @@ public class Element {
             + (GD.Randi() % 2 != 0 ? Vector2I.Zero : Vector2I.Right * randomDirection);
     }
 
+    /// <returns>-1, 0 or 1</returns>
+    protected Vector2I RandomDirection() {
+        int randomDirection = GD.Randi() % 2 != 0 ? 1 : -1;
+
+        return (GD.Randi() % 2 != 0 ? Vector2I.Zero : Vector2I.Right * randomDirection);
+    }
+
     protected Color AddColorVariance(Color baseColor) {
         Color c = baseColor;
         c.R += (GD.Randf() - 1) * MAX_COLOR_VARIANCE;
@@ -106,21 +106,48 @@ public class Element {
 
     public void ResetColor() {
         color = originalColor;
+        MarkForUpdate();
     }
 
     public void SetDebugColor(Color color) {
         if (!Main.Instance.DebugMode) return;
 
         this.color = color;
-        wasMovedThisTick = true;
     }
 
     public void Moved() {
         lastMove = Engine.GetFramesDrawn();
-        wasMovedThisTick = true;
+        MarkForUpdate();
     }
 
-    public bool WasMoved() {
-        return wasMovedThisTick;
+    public bool IsMarkedForUpdate() {
+        return markedForUpdate;
+    }
+
+    public void MarkForUpdate(bool mark = true) {
+        markedForUpdate = true;
+    }
+
+    public bool IsEmpty() {
+        return GetType() == typeof(Element);
+    }
+
+    public virtual void ActivateNeighbors() {
+
+        Element n = Chunk.Get(Position + Vector2I.Up);
+        if (n != null && !n.IsEmpty())
+            n.Active = true;
+        //
+        // Element e = Chunk.Get(Position + Vector2I.Right);
+        // if (e != null && !e.IsEmpty())
+        //     e.Active = true;
+        //
+        // Element s = Chunk.Get(Position + Vector2I.Down);
+        // if (null != s && !s.IsEmpty())
+        //     s.Active = true;
+        //
+        // Element w = Chunk.Get(Position + Vector2I.Left);
+        // if (null != w && !w.IsEmpty())
+        //     w.Active = true;
     }
 }

Scripts/Elements/Liquid.cs

@@ -5,18 +5,19 @@ namespace FOU.Scripts.Elements;
 public abstract class Liquid : Element {
     public const int MAX_VERTICAL_SPREAD = 3;
 
-    protected Liquid(int x, int y, ref Chunk chunk) : base(x, y, chunk) { }
+    protected Liquid(int x, int y, ref Chunk chunk) : base(x, y, chunk) {
+        MarkForUpdate();
+    }
 
     public override bool Update() {
         if (!base.Update()) return false;
-        if (lastMove + STEPS_UNTIL_INACTIVE < Engine.GetFramesDrawn()) Active = false;
 
         Tick();
 
         return true; // not necessarily end, subclasses could do some more things
     }
 
-    protected override void Tick() {
+    protected virtual void Tick() {
         Vector2I randomDirection = RandomDirectionDown();
         if (randomDirection.Y != 0)
             randomDirection *= Vector2I.Left * (int)(GD.Randi() % MAX_VERTICAL_SPREAD);
@@ -25,9 +26,34 @@ public abstract class Liquid : Element {
             Chunk.Swap(this, Position + Vector2I.Down);
 
         else if (Chunk.IsEmpty(Position + randomDirection))
-            Chunk.Swap(this, Position + Vector2I.Right * randomDirection);
+            Chunk.Swap(this, Position + randomDirection);
+        else if (Chunk.IsEmpty(Position + randomDirection * VERTICAL_OPPOSITE))
+            Chunk.Swap(this, Position + randomDirection * VERTICAL_OPPOSITE);
 
-        else if (Chunk.IsEmpty(Position + randomDirection))
-            Chunk.Swap(this, Position + Vector2I.Right * randomDirection * VERTICAL_OPPOSITE);
+        else if (Chunk.IsEmpty(Position + 1 * randomDirection))
+            Chunk.Swap(this, Position + 1 * randomDirection);
+        else if (Chunk.IsEmpty(Position - 1 * randomDirection * VERTICAL_OPPOSITE))
+            Chunk.Swap(this, Position - 1 * randomDirection * VERTICAL_OPPOSITE);
+
+        else if (Chunk.IsEmpty(Position + 2 * randomDirection))
+            Chunk.Swap(this, Position + 2 * randomDirection);
+        else if (Chunk.IsEmpty(Position - 2 * randomDirection * VERTICAL_OPPOSITE))
+            Chunk.Swap(this, Position - 2 * randomDirection * VERTICAL_OPPOSITE);
+    }
+
+    public override void ActivateNeighbors() {
+
+        Element n = Chunk.Get(Position + Vector2I.Up);
+        if (n != null && !n.IsEmpty())
+            n.Active = true;
+
+        // only activate liquids left or right
+        Element e = Chunk.Get(Position + Vector2I.Right);
+        if (e != null && e.GetType() == typeof(Liquid))
+            e.Active = true;
+
+        Element s = Chunk.Get(Position + Vector2I.Down);
+        if (null != s && s.GetType() == typeof(Liquid))
+            s.Active = true;
     }
 }

Scripts/Elements/Solid.cs

@@ -3,14 +3,40 @@
 namespace FOU.Scripts.Elements;
 
 public abstract class Solid : Element {
-    protected Solid(int x, int y, ref Chunk chunk) : base(x, y, chunk) { }
+    protected Solid(int x, int y, ref Chunk chunk) : base(x, y, chunk) {
+        MarkForUpdate();
+    }
 
     public override bool Update() {
         if (!base.Update()) return false;
-        if (lastMove + STEPS_UNTIL_INACTIVE < Engine.GetFramesDrawn()) Active = false;
 
         Tick();
 
         return true; // not necessarily end, subclasses could do some more things
     }
+
+    protected virtual void Tick() {
+        Vector2I randomDirection = RandomDirectionDown();
+
+        // fall speed reduction:
+        if (GD.Randi() % MAX_DIFFUSE_SPEED > DiffuseSpeed) return; // descend slower
+
+        if (Chunk.IsEmpty(Position + Vector2I.Down))
+            Chunk.Swap(this, Position + Vector2I.Down);
+
+        else if (Chunk.IsEmpty(Position + Vector2I.Down + randomDirection))
+            Chunk.Swap(this, Position + Vector2I.Down + randomDirection);
+
+        else if (Chunk.IsEmpty(Position + Vector2I.Down + randomDirection * VERTICAL_OPPOSITE))
+            Chunk.Swap(this, Position + Vector2I.Down + randomDirection * VERTICAL_OPPOSITE);
+
+        // density check
+        if (Chunk.Get(Position + Vector2I.Down)?.Density < Density)
+            Chunk.Swap(this, Position + Vector2I.Down);
+        else if (Chunk.Get(Position + Vector2I.Down + randomDirection)?.Density < Density)
+            Chunk.Swap(this, Position + Vector2I.Down + randomDirection);
+        else if (Chunk.Get(Position + Vector2I.Down + randomDirection * VERTICAL_OPPOSITE)?.Density < Density)
+            Chunk.Swap(this, Position + Vector2I.Down + randomDirection * VERTICAL_OPPOSITE);
+    }
+
 }

Scripts/Level.cs

@@ -30,7 +30,7 @@ public class Level {
 
         GD.Print($"Generating level ({sizeX}:{sizeY}) with {chunksPerX*chunksPerY} chunks ({chunkResX} * {chunkResY})");
 
-        image = Image.Create(sizeX, sizeY, false, Image.Format.Rgb8);
+        image = Image.CreateEmpty(sizeX, sizeY, false, Image.Format.Rgb8);
 
         chunks = new Chunk[chunksPerX, chunksPerY];
         int index = 0;
@@ -84,8 +84,11 @@ public class Level {
         int rainDrops = (int)Math.Round(rainAmount);
 
         for (int i = 0; i <= rainDrops; i++) {
-            if (GD.Randf() < rainAmount)
-                WritePixel<Water>((int)(GD.Randi() % (chunkResX * chunksPerX)), 0, 1);
+            if (GD.Randf() < rainAmount) {
+                int d = (int)(GD.Randi() % (chunkResX * chunksPerX));
+                if (GetElement(d, 0).IsEmpty())
+                    WritePixel<Water>(d, 0, 1);
+            }
         }
     }
 
@@ -113,28 +116,26 @@ public class Level {
                     iteratorX = chunkResX + startPtX + iteratorX;
                     ptX = startPtX + iteratorX;
 
-                // right of chunk
-                } else if (startPtX + iteratorX >= chunkResX) {
-                    chunkX++;
-                    ptX = startPtX + iteratorX - chunkResX;
                 } else {
                     ptX = startPtX + iteratorX;
                 }
-
+                if (startPtX + iteratorX >= chunkResX) {
+                    chunkX++;
+                    ptX = startPtX + iteratorX - chunkResX;
+                }
                 int chunkY = y/chunkResY;
 
                 // above chunk
                 if (startPtY + iteratorY < 0) {
                     chunkY--;
                     ptY = chunkResY + (startPtY + iteratorY);
-
-                // left of chunk
-                } else if (startPtY + iteratorY >= chunkResY) {
-                    chunkY++;
-                    ptY = iteratorY % chunkResY;
                 } else {
                     ptY = startPtY + iteratorY;
                 }
+                if (startPtY + iteratorY >= chunkResY) {
+                    chunkY++;
+                    ptY = startPtY + iteratorY - chunkResY;
+                }
 
                 // ignore everything outside
                 if (chunkX < 0) continue;
@@ -147,6 +148,13 @@ public class Level {
         }
     }
 
+    public Element GetElement(int x, int y) {
+        if (x < 0 || x > chunkResX * chunkResX) return null;
+        if (y < 0 || y > chunkResY * chunkResY) return null;
+
+        return chunks[x / chunkResX, y / chunkResY].Elements[x % chunkResX, y % chunkResY];
+    }
+
     public Image DrawLevel() {
         // chunk
         for (int cx = 0; cx < chunksPerX; cx++) {
@@ -157,8 +165,10 @@ public class Level {
                     for (int y = 0; y < chunkResY; y++) {
                         // TODO: multithreading here! use Chunk.DrawLevel() and stitch images together
 
-                        if (chunks[cx, cy].Elements[x, y].WasMoved())
-                            image.SetPixel(cx*chunkResX + x, cy*chunkResY + y, chunks[cx, cy].Elements[x, y].Color);
+                        if (chunks[cx, cy].Elements[x, y].IsMarkedForUpdate()) {
+                            image.SetPixel(cx * chunkResX + x, cy * chunkResY + y, chunks[cx, cy].Elements[x, y].Color);
+                            chunks[cx, cy].Elements[x, y].MarkForUpdate(false);
+                        }
                     }
                 }
             }

Scripts/Main.cs

@@ -4,18 +4,26 @@ using Godot;
 
 public partial class Main : Node2D {
 	[Export] public bool DebugMode = false;
+	[Export] public bool AllowOverwrite = true;
 
 	[Export] public int BrushSize = 5;
 	[Export] public float TextureResolution = 0.5f;
 	[Export] public int ChunksPerAxis = 2;
-	[Export] public float RainAmount = 0;
+	[Export] public float rainAmount = 0;
 
 	public static Main Instance;
 	public Level Level;
 
 	private TextureRect mLevelDrawer;
 	private bool enableRain;
-	private float rainAmount;
+
+	public float RainAmount {
+		get => rainAmount;
+		set {
+			rainAmount = value;
+			Level?.SetRainAmount(rainAmount);
+		}
+	}
 
 	public override void _Ready() {
 		Level = new Level(this, (int)(GetViewportRect().Size.X * TextureResolution),
@@ -28,10 +36,10 @@ public partial class Main : Node2D {
 
 	public override void _PhysicsProcess(double delta) {
 		base._PhysicsProcess(delta);
-		Level.Update();
 	}
 
 	public override void _Process(double delta) {
+		Level.Update();
 		mLevelDrawer.Texture?.Dispose();
 		mLevelDrawer.Texture = ImageTexture.CreateFromImage(Level.DrawLevel());
 	}