Add support for brush sizes to smudge placement cursor action

Author: Rampastring

src/TSMapEditor/Mutations/Classes/PlaceSmudgeMutation.cs

@@ -1,54 +1,99 @@
-using TSMapEditor.GameMath;
+using System;
+using System.Collections.Generic;
+using TSMapEditor.GameMath;
 using TSMapEditor.Models;
 using TSMapEditor.UI;
 
 namespace TSMapEditor.Mutations.Classes
 {
+    public struct CachedSmudge
+    {
+        public Point2D CellCoords;
+        public SmudgeType SmudgeType;
+
+        public CachedSmudge(Point2D cellCoords, SmudgeType smudgeType)
+        {
+            CellCoords = cellCoords;
+            SmudgeType = smudgeType;
+        }
+    }
+
     /// <summary>
     /// A mutation that places a smudge on the map.
     /// </summary>
     public class PlaceSmudgeMutation : Mutation
     {
-        public PlaceSmudgeMutation(IMutationTarget mutationTarget, SmudgeType smudgeType, Point2D cellCoords) : base(mutationTarget)
+        public PlaceSmudgeMutation(IMutationTarget mutationTarget, SmudgeType smudgeType, Point2D cellCoords, BrushSize brushSize) : base(mutationTarget)
         {
             this.smudgeType = smudgeType;
             this.cellCoords = cellCoords;
+            this.brushSize = brushSize ?? throw new ArgumentNullException(nameof(brushSize));
         }
 
-        private Smudge oldSmudge;
+        private List<CachedSmudge> oldSmudges = new List<CachedSmudge>(1);
         private SmudgeType smudgeType;
         private Point2D cellCoords;
+        private BrushSize brushSize;
 
         public override string GetDisplayString()
         {
-            return string.Format(Translate(this, "DisplayString", 
-                "Place smudge '{0}' at {1}"),
-                    smudgeType.GetEditorDisplayName(), cellCoords);
+            if (smudgeType == null)
+            {
+                return string.Format(Translate(this, "DisplayStringErase",
+                    "Erase smudges at {0} with brush size of {1}"),
+                    cellCoords, brushSize);
+            }
+            else
+            {
+                return string.Format(Translate(this, "DisplayString",
+                    "Place smudge '{0}' at {1} with brush size of {2}"),
+                    smudgeType.GetEditorDisplayName(), cellCoords, brushSize);
+            }
         }
 
         public override void Perform()
         {
-            var cell = MutationTarget.Map.GetTile(cellCoords);
-            if (cell.Smudge != null)
-                oldSmudge = cell.Smudge;
+            oldSmudges.Clear();
 
-            if (smudgeType != null)
-                cell.Smudge = new Smudge() { SmudgeType = smudgeType, Position = cellCoords };
-            else
-                cell.Smudge = null; // delete an existing smudge if smudge type is null
+            brushSize.DoForBrushSize(offset =>
+            {
+                var cell = MutationTarget.Map.GetTile(cellCoords + offset);
+
+                if (cell == null)
+                    return;
 
-            MutationTarget.AddRefreshPoint(cellCoords, 1);
+                if ((smudgeType == null && cell.Smudge != null) || 
+                    (smudgeType != null && (cell.Smudge == null || cell.Smudge.SmudgeType != smudgeType)))
+                {
+                    oldSmudges.Add(new CachedSmudge(cell.CoordsToPoint(), cell.Smudge == null ? null : cell.Smudge.SmudgeType));
+                }
+                else
+                {
+                    return;
+                }
+
+                if (smudgeType != null)
+                    cell.Smudge = new Smudge() { SmudgeType = smudgeType, Position = cell.CoordsToPoint() };
+                else
+                    cell.Smudge = null; // delete an existing smudge if smudge type is null
+            });
+
+            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/BrushSize.cs

@@ -13,12 +13,20 @@ public BrushSize(int width, int height)
 
         public int Width { get; }
         public int Height { get; }
+        public int Max => Math.Max(Width, Height);
+
+        public Point2D CenterWithinBrush(Point2D point) => new Point2D(point.X - (Width / 2), point.Y - (Height / 2));
 
         public void DoForBrushSize(Action<Point2D> action)
         {
             DoForArea(0, 0, Height, Width, action);
         }
 
+        public bool CheckForBrushSize(Func<Point2D, bool> checker)
+        {
+            return CheckForAnyInArea(0, 0, Height, Width, checker);
+        }
+
         public void DoForBrushSizeAndSurroundings(Action<Point2D> action)
         {
             DoForArea(-1, -1, Height + 1, Width + 1, action);
@@ -35,6 +43,20 @@ private void DoForArea(int initY, int initX, int height, int width, Action<Point
             }
         }
 
+        private bool CheckForAnyInArea(int initY, int initX, int height, int width, Func<Point2D, bool> checker)
+        {
+            for (int y = initY; y < height; y++)
+            {
+                for (int x = initX; x < width; x++)
+                {
+                    if (checker(new Point2D(x, y)))
+                        return true;
+                }
+            }
+
+            return false;
+        }
+
         public override string ToString()
         {
             return Width + "x" + Height;

src/TSMapEditor/UI/CursorActions/PlaceSmudgeCursorAction.cs

@@ -1,4 +1,5 @@
-using TSMapEditor.GameMath;
+using System.Collections.Generic;
+using TSMapEditor.GameMath;
 using TSMapEditor.Models;
 using TSMapEditor.Mutations.Classes;
 
@@ -8,7 +9,6 @@ public class PlaceSmudgeCursorAction : CursorAction
     {
         public PlaceSmudgeCursorAction(ICursorActionTarget cursorActionTarget) : base(cursorActionTarget)
         {
-            previewSmudge = new Smudge();
         }
 
         public override string GetName() => Translate("Name", "Place Smudge");
@@ -22,60 +22,93 @@ public SmudgeType SmudgeType
                 if (value != _smudgeType)
                 {
                     _smudgeType = value;
-                    previewSmudge.SmudgeType = value;
-                } 
+                }
             }
         }
 
-        private Smudge cachedSmudge;
-        private Smudge previewSmudge;
+        private List<Smudge> previewSmudges = new List<Smudge>();
+        private List<Smudge> existingSmudges = new List<Smudge>();
 
         public override void PreMapDraw(Point2D cellCoords)
         {
             base.PreMapDraw(cellCoords);
-        
-            var cell = CursorActionTarget.Map.GetTile(cellCoords);
-            if (cell == null)
-                return;
-        
-            previewSmudge.Position = cellCoords;
-            cachedSmudge = cell.Smudge;
-            if (SmudgeType != null)
-                cell.Smudge = previewSmudge;
-            else
-                cell.Smudge = null;
-        
-            CursorActionTarget.AddRefreshPoint(cellCoords, 1);
+
+            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;
+
+                if (previewSmudges.Count <= i)
+                {
+                    previewSmudges.Add(new Smudge());
+                }
+
+                previewSmudges[i].Position = centeredBrushSizeCellCoords + offset;
+                previewSmudges[i].SmudgeType = SmudgeType;
+                existingSmudges.Add(cell.Smudge);
+
+                if (SmudgeType != null)
+                    cell.Smudge = previewSmudges[i];
+                else
+                    cell.Smudge = null;
+
+                i++;
+            });
+
+            CursorActionTarget.AddRefreshPoint(centeredBrushSizeCellCoords, CursorActionTarget.BrushSize.Max);
         }
 
         public override void PostMapDraw(Point2D cellCoords)
         {
             base.PostMapDraw(cellCoords);
-        
-            var cell = CursorActionTarget.Map.GetTile(cellCoords);
-            if (cell == null)
-                return;
-        
-            cell.Smudge = cachedSmudge;
-            CursorActionTarget.AddRefreshPoint(cellCoords, 1);
+
+            Point2D centeredBrushSizeCellCoords = CursorActionTarget.BrushSize.CenterWithinBrush(cellCoords);
+
+            int i = 0;
+            CursorActionTarget.BrushSize.DoForBrushSize(offset =>
+            {
+                var cell = CursorActionTarget.Map.GetTile(centeredBrushSizeCellCoords + offset);
+                if (cell == null)
+                    return;
+
+                cell.Smudge = existingSmudges[i];
+                i++;
+            });
+
+            CursorActionTarget.AddRefreshPoint(centeredBrushSizeCellCoords, CursorActionTarget.BrushSize.Max);
         }
 
         public override void LeftClick(Point2D cellCoords)
         {
-            var cell = CursorActionTarget.Map.GetTile(cellCoords);
-            if (cell == null)
-                return;
+            Point2D centeredBrushSizeCellCoords = CursorActionTarget.BrushSize.CenterWithinBrush(cellCoords);
 
-            if (cell.Smudge != null && cell.Smudge.SmudgeType == SmudgeType)
+            if (!CursorActionTarget.BrushSize.CheckForBrushSize(offset =>
+            {
+                var cell = CursorActionTarget.Map.GetTile(centeredBrushSizeCellCoords + offset);
+                if (cell == null)
+                    return false;
+
+                if (cell.Smudge != null && cell.Smudge.SmudgeType == SmudgeType)
+                {
+                    // it's pointless to replace a smudge with another smudge of the same type
+                    return false;
+                }
+
+                if (cell.Smudge == null && SmudgeType == null)
+                    return false; // we're in deletion mode when SmudgeType == null, skip if there's nothing to delete
+
+                return true;
+            }))
             {
-                // it's pointless to replace a smudge with another smudge of the same type
                 return;
             }
 
-            if (cell.Smudge == null && SmudgeType == null)
-                return; // we're in deletion mode when SmudgeType == null, skip if there's nothing to delete
-
-            CursorActionTarget.MutationManager.PerformMutation(new PlaceSmudgeMutation(CursorActionTarget.MutationTarget, SmudgeType, cellCoords));
+            CursorActionTarget.MutationManager.PerformMutation(new PlaceSmudgeMutation(CursorActionTarget.MutationTarget, SmudgeType, centeredBrushSizeCellCoords, CursorActionTarget.BrushSize));
         }
 
         public override void LeftDown(Point2D cellCoords) => LeftClick(cellCoords);