Add support for brush sizes to smudge collection placement cursor action

Author: Rampastring

src/TSMapEditor/Mutations/Classes/PlaceSmudgeCollectionMutation.cs

@@ -1,4 +1,6 @@
-using TSMapEditor.GameMath;
+using System;
+using System.Collections.Generic;
+using TSMapEditor.GameMath;
 using TSMapEditor.Models;
 using TSMapEditor.UI;
 
@@ -9,43 +11,70 @@ namespace TSMapEditor.Mutations.Classes
     /// </summary>
     class PlaceSmudgeCollectionMutation : Mutation
     {
-        public PlaceSmudgeCollectionMutation(IMutationTarget mutationTarget, SmudgeCollection smudgeCollection, Point2D cellCoords) : base(mutationTarget)
+        public PlaceSmudgeCollectionMutation(IMutationTarget mutationTarget, SmudgeCollection smudgeCollection, Point2D cellCoords, BrushSize brushSize) : base(mutationTarget)
         {
             this.smudgeCollection = smudgeCollection;
             this.cellCoords = cellCoords;
+            this.brushSize = brushSize ?? throw new ArgumentNullException(nameof(brushSize));
         }
 
-        private Smudge oldSmudge;
-        private readonly SmudgeCollection smudgeCollection;
-        private readonly Point2D cellCoords;
+        private List<CachedSmudge> oldSmudges = new List<CachedSmudge>(1);
+        private List<CachedSmudge> placedSmudges = new List<CachedSmudge>();
+        private SmudgeCollection smudgeCollection;
+        private Point2D cellCoords;
+        private BrushSize brushSize;
 
         public override string GetDisplayString()
         {
-            return string.Format(Translate(this, "DisplayString", "Place smudge collection {0} at {1}"),
-                smudgeCollection.Name, cellCoords);
+            return string.Format(Translate(this, "DisplayString", "Place smudge collection {0} at {1} with brush size of {2}"),
+                smudgeCollection.Name, cellCoords, brushSize);
         }
 
         public override void Perform()
         {
-            var cell = MutationTarget.Map.GetTile(cellCoords);
-            if (cell.Smudge != null)
-                oldSmudge = cell.Smudge;
+            oldSmudges.Clear();
 
-            var collectionEntry = smudgeCollection.Entries[MutationTarget.Randomizer.GetRandomNumber(0, smudgeCollection.Entries.Length - 1)];
-            cell.Smudge = new Smudge() { SmudgeType = collectionEntry.SmudgeType, Position = cellCoords };
+            bool placeNew = placedSmudges.Count == 0;
+            int i = 0;
 
-            MutationTarget.AddRefreshPoint(cellCoords, 1);
+            brushSize.DoForBrushSize(offset =>
+            {
+                var cell = MutationTarget.Map.GetTile(cellCoords + offset);
+
+                if (cell == null)
+                    return;
+
+                oldSmudges.Add(new CachedSmudge(cell.CoordsToPoint(), cell.Smudge == null ? null : cell.Smudge.SmudgeType));
+
+                if (placeNew)
+                {
+                    var collectionEntry = smudgeCollection.Entries[MutationTarget.Randomizer.GetRandomNumber(0, smudgeCollection.Entries.Length - 1)];
+                    cell.Smudge = new Smudge() { SmudgeType = collectionEntry.SmudgeType, Position = cell.CoordsToPoint() };
+                    placedSmudges.Add(new CachedSmudge(cell.CoordsToPoint(), cell.Smudge.SmudgeType));
+                }
+                else
+                {
+                    cell.Smudge = new Smudge() { SmudgeType = placedSmudges[i].SmudgeType, Position = placedSmudges[i].CellCoords };
+                    i++;
+                }
+            });
+
+            MutationTarget.AddRefreshPoint(cellCoords, brushSize.Max);
         }
 
         public override void Undo()
         {
-            var cell = MutationTarget.Map.GetTile(cellCoords);
+            foreach (var oldSmudge in oldSmudges)
+            {
+                var cell = Map.GetTile(oldSmudge.CellCoords);
+
+                if (oldSmudge.SmudgeType == null)
+                    cell.Smudge = null;
+                else
+                    cell.Smudge = new Smudge() { SmudgeType = oldSmudge.SmudgeType, Position = oldSmudge.CellCoords };
+            }
 
-            // if oldSmudge is null, then this has the same effect as cell.Smudge = null
-            // otherwise the smudge is replaced with the old smudge
-            // iow. we don't need to handle the null case separately
-            cell.Smudge = oldSmudge;
-            MutationTarget.AddRefreshPoint(cellCoords, 1);
+            MutationTarget.AddRefreshPoint(cellCoords, brushSize.Max);
         }
     }
 }

src/TSMapEditor/UI/CursorActions/PlaceSmudgeCollectionCursorAction.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using TSMapEditor.GameMath;
 using TSMapEditor.Models;
 using TSMapEditor.Mutations.Classes;
@@ -13,9 +14,6 @@ public PlaceSmudgeCollectionCursorAction(ICursorActionTarget cursorActionTarget)
 
         public override string GetName() => Translate("Name", "Place Smudge Collection");
 
-        private Smudge oldSmudge;
-        private Smudge smudge;
-
         private SmudgeCollection _smudgeCollection;
         public SmudgeCollection SmudgeCollection
         {
@@ -28,44 +26,71 @@ public SmudgeCollection SmudgeCollection
                 }
 
                 _smudgeCollection = value;
-                smudge = new Smudge { SmudgeType = _smudgeCollection.Entries[0].SmudgeType };
             }
         }
 
+        private List<Smudge> previewSmudges = new List<Smudge>();
+        private List<Smudge> existingSmudges = new List<Smudge>();
+
         public override void PreMapDraw(Point2D cellCoords)
         {
-            var cell = CursorActionTarget.Map.GetTile(cellCoords);
+            Point2D centeredBrushSizeCellCoords = CursorActionTarget.BrushSize.CenterWithinBrush(cellCoords);
+            existingSmudges.Clear();
+
+            int i = 0;
+            CursorActionTarget.BrushSize.DoForBrushSize(offset =>
+            {
+                var cell = CursorActionTarget.Map.GetTile(centeredBrushSizeCellCoords + offset);
+                if (cell == null)
+                    return;
 
-            // "Randomize" the smudge image, it makes it clearer that we're placing down one from a collection.
-            // If we used actual RNG here we'd need to avoid doing it every frame to avoid a constantly
-            // changing smudge even when the cursor is still. Using cell numbers gives the intended
-            // effect without pointless flickering.
-            int cellnum = cellCoords.X + cellCoords.Y;
-            int smudgeNumber = cellnum % SmudgeCollection.Entries.Length;
-            smudge.SmudgeType = SmudgeCollection.Entries[smudgeNumber].SmudgeType;
+                if (previewSmudges.Count <= i)
+                {
+                    previewSmudges.Add(new Smudge());
+                }
 
-            oldSmudge = cell.Smudge;
+                // "Randomize" the smudge image, it makes it clearer that we're placing down one from a collection.
+                // If we used actual RNG here we'd need to avoid doing it every frame to avoid a constantly
+                // changing smudge even when the cursor is still. Using cell numbers gives the intended
+                // effect without pointless flickering.
+                int cellnum = cell.X + cell.Y;
+                int smudgeNumber = cellnum % SmudgeCollection.Entries.Length;
+                previewSmudges[i].SmudgeType = SmudgeCollection.Entries[smudgeNumber].SmudgeType;
+                previewSmudges[i].Position = cell.CoordsToPoint();
+                existingSmudges.Add(cell.Smudge);
 
-            smudge.Position = cell.CoordsToPoint();
-            cell.Smudge = smudge;
+                cell.Smudge = previewSmudges[i];
 
-            CursorActionTarget.AddRefreshPoint(cellCoords);
+                i++;
+            });
+
+            CursorActionTarget.AddRefreshPoint(centeredBrushSizeCellCoords, MutationTarget.BrushSize.Max);
         }
 
         public override void PostMapDraw(Point2D cellCoords)
         {
-            var cell = CursorActionTarget.Map.GetTile(cellCoords);
-            if (cell.Smudge == smudge)
+            base.PostMapDraw(cellCoords);
+
+            Point2D centeredBrushSizeCellCoords = CursorActionTarget.BrushSize.CenterWithinBrush(cellCoords);
+
+            int i = 0;
+            CursorActionTarget.BrushSize.DoForBrushSize(offset =>
             {
-                cell.Smudge = oldSmudge;
-            }
+                var cell = CursorActionTarget.Map.GetTile(centeredBrushSizeCellCoords + offset);
+                if (cell == null)
+                    return;
+
+                cell.Smudge = existingSmudges[i];
+                i++;
+            });
 
-            CursorActionTarget.AddRefreshPoint(cellCoords);
+            CursorActionTarget.AddRefreshPoint(centeredBrushSizeCellCoords, CursorActionTarget.BrushSize.Max);
         }
 
         public override void LeftDown(Point2D cellCoords)
         {
-            var mutation = new PlaceSmudgeCollectionMutation(CursorActionTarget.MutationTarget, SmudgeCollection, cellCoords);
+            Point2D centeredBrushSizeCellCoords = CursorActionTarget.BrushSize.CenterWithinBrush(cellCoords);
+            var mutation = new PlaceSmudgeCollectionMutation(CursorActionTarget.MutationTarget, SmudgeCollection, centeredBrushSizeCellCoords, MutationTarget.BrushSize);
             CursorActionTarget.MutationManager.PerformMutation(mutation);
         }