Implement line-based terrain painting by holding Shift when placing tiles

Author: Rampastring

src/TSMapEditor/Config/Translations/en/Translation_en.ini

@@ -205,6 +205,19 @@ SubCell.Right=Right
 SubCell.Left=Left
 SubCell.Bottom=Bottom
 
+; *************************************************
+;                 Visual Direction
+; *************************************************
+
+Direction.NE=Northeast
+Direction.E=East
+Direction.SE=Southeast
+Direction.S=South
+Direction.SW=Southwest
+Direction.W=West
+Direction.NW=Northwest
+Direction.N=North
+
 ; *************************************************
 ;                 Keyboard Commands
 ; *************************************************
@@ -236,6 +249,7 @@ KeyboardCommands.RotateUnit=Rotate Unit
 KeyboardCommands.RotateObjectOneStep=Rotate Object One Step
 KeyboardCommands.PlaceTerrainBelowCursor=Place Terrain Below Cursor
 KeyboardCommands.FillTerrain=Fill Terrain (1x1 tiles only)
+KeyboardCommands.PlaceTerrainLine=Place Terrain Line
 KeyboardCommands.CloneObject=Clone Object (Modifier)
 KeyboardCommands.OverlapObjects=Overlap Objects (Modifier)
 KeyboardCommands.ViewMegamap=View Megamap
@@ -1429,6 +1443,52 @@ ToggleIceGrowthCursorAction.DisableName=Disable Ice Growth
 
 UnitPlacementAction.Name=Place Vehicle
 
+; *************************************************
+;                    Mutations
+; *************************************************
+
+ChangeAttachedTagMutation.DisplayString=Change attached tag of '{0}' at {1} to '{2}'
+ChangeTechnoOwnerMutation.DisplayString=Change owner of {0} at {1} to {2}
+CloneObjectMutation.DisplayString=Clone {0} to {1}
+DeleteObjectMutation.DisplayString=Delete {0} objects at {1} with a brush size of {2}
+DeleteTubeMutation.DisplayString=Delete tunnel tube of length {0} at {1}
+DrawCliffMutation.DisplayString=Draw Connected Tiles of type {0}
+FillTerrainAreaMutation.DisplayString=Flood-fill terrain tiles at {0} with tile from set '{1}'
+FlattenGroundMutation.DisplayString=Flatten ground at {0} to a level of {1} with a brush size of {2}
+FSLowerGroundMutation.DisplayString=Lower ground at {0} with a brush size of {1} using non-steep ramps
+FSRaiseGroundMutation.DisplayString=Raise ground at {0} with a brush size of {1} using non-steep ramps
+LowerCellsMutation.DisplayString=Lower cell height at {0} with a brush size of {1}
+LowerGroundMutation.DisplayString=Lower ground at {0} with a brush size of {1} using steep ramps
+MoveObjectMutation.DisplayString=Move {0} from {1} to {2}
+PasteTerrainMutation.DisplayString=Paste copied terrain of size {0}x{1} at {2}
+PlaceAircraftMutation.DisplayString=Place '{0}' at {1}
+PlaceBridgeMutation.DisplayString=Place bridge '{0}' of direction {1} from {2} to {3}
+PlaceBuildingMutation.DisplayString=Place '{0}' at {1}
+PlaceCellTagMutation.DisplayString=Place CellTag for '{0}' at {1}
+PlaceConnectedOverlayMutation.DisplayString=Place connected overlay '{0}' at {1} with a brush size of {2}
+PlaceInfantryMutation.DisplayString=Place '{0}' at {1}
+PlaceOverlayCollectionMutation.DisplayString=Place overlay collection {0} at {1} with a brush size of {2}
+PlaceOverlayMutation.DisplayStringPlace=Place overlay '{0}' at {1} with a brush size of {2}
+PlaceOverlayMutation.DisplayStringErase=Erase overlay at {0} with a brush size of {1}
+PlaceSmudgeCollectionMutation.DisplayString=Place smudge collection {0} at {1} with brush size of {2}
+PlaceSmudgeMutation.DisplayString=Place smudge '{0}' at {1} with brush size of {2}
+PlaceSmudgeMutation.DisplayStringErase=Erase smudges at {0} with brush size of {1}
+PlaceTerrainLineMutation.DisplayString=Place Terrain Line from {0} towards {1} with distance of {2}
+PlaceTerrainObjectCollectionMutation.DisplayString=Place terrain object collection '{0}' at {1}
+PlaceTerrainObjectMutation.DisplayString=Place terrain object '{0}' at {1}
+PlaceTerrainTileMutation.DisplayString=Place terrain tile of TileSet {0} at {1} with a brush size of {2}
+PlaceTubeMutation.DisplayString=Place tunnel tube of length {0} at {1}
+PlaceVehicleMutation.DisplayString=Place '{0}' at {1}
+PlaceVeinholeMonsterMutation.DisplayString=Lower ground at {0} with a brush size of {1} using non-steep ramps
+PlaceWaypointMutation.DisplayString=Place waypoint {0} at {1}
+RaiseCellsMutation.DisplayString=Raise cell height at {0} with a brush size of {1}
+RaiseGroundMutation.DisplayString=Raise ground at {0} with a brush size of {1} using steep ramps
+SetFollowerMutation.DisplayString=Set follower of vehicle {0} at {1} to {2} at {3}
+SetIceGrowthMutation.DisplayString={0} ice growth at {1} with a brush size of {2}
+SetIceGrowthMutation.Enable=Enable
+SetIceGrowthMutation.Disable=Disable
+TerrainGenerationMutation.DisplayString=Generate Terrain over {0} cells
+
 ; *************************************************
 ; *************************************************
 ;             WAE Configuration Elements

src/TSMapEditor/Constants.cs

@@ -4,7 +4,7 @@ namespace TSMapEditor
 {
     public static class Constants
     {
-        public const string ReleaseVersion = "1.7.11";
+        public const string ReleaseVersion = "1.7.12";
 
         public static int CellSizeX = 48;
         public static int CellSizeY = 24;

src/TSMapEditor/GameMath/Point2D.cs

@@ -132,6 +132,8 @@ public int DistanceTo(Point2D other)
 
         public Point2D ScaleBy(float scale) => new Point2D((int)(X * scale), (int)(Y * scale));
 
+        public Point2D ScaleBy(int scale) => new Point2D(X * scale, Y * scale);
+
         public byte[] GetData()
         {
             byte[] buffer = new byte[sizeof(int) * 2];

src/TSMapEditor/Helpers.cs

@@ -229,6 +229,49 @@ public static string WaypointNumberToAlphabeticalString(int waypointNumber)
 
         public static Point2D VisualDirectionToPoint(Direction direction) => visualDirectionToPointTable[(int)direction];
 
+        private static string[] directionToNameTable = new string[]
+        {
+            "Northeast", "East", "Southeast", "South", "Southwest", "West", "Northwest", "North"
+        };
+
+        public static string DirectionToName(Direction direction) => directionToNameTable[(int)direction];
+
+        public static Direction DirectionFromPoints(Point2D p1, Point2D p2)
+        {
+            if (p1 == p2)
+                throw new ArgumentException("Cannot get direction from two identical points.");
+
+            int xDiff = p2.X - p1.X;
+            int yDiff = p2.Y - p1.Y;
+
+            if (xDiff == 0 || Math.Abs(yDiff) > Math.Abs(xDiff * 2))
+            {
+                if (yDiff > 0)
+                    return Direction.SW;
+
+                return Direction.NE;
+            }
+
+            if (yDiff == 0 || Math.Abs(xDiff) > Math.Abs(yDiff * 2))
+            {
+                if (xDiff > 0)
+                    return Direction.SE;
+
+                return Direction.NW;
+            }
+
+            if (xDiff > 0 && yDiff > 0)
+                return Direction.S;
+
+            if (xDiff > 0 && yDiff < 0)
+                return Direction.E;
+
+            if (xDiff < 0 && yDiff > 0)
+                return Direction.W;
+
+            return Direction.N;
+        }
+
         public static List<Direction> GetDirectionsInMask(byte mask)
         {
             List<Direction> directions = new List<Direction>();

src/TSMapEditor/Mutations/Classes/OriginalTerrainData.cs

@@ -0,0 +1,178 @@
+using System;
+using System.Collections.Generic;
+using TSMapEditor.GameMath;
+using TSMapEditor.Models;
+using TSMapEditor.Rendering;
+using TSMapEditor.UI;
+
+namespace TSMapEditor.Mutations.Classes
+{
+    public class PlaceTerrainLineMutation : Mutation
+    {
+        public PlaceTerrainLineMutation(IMutationTarget mutationTarget, MapTile source, Direction direction, int length, TileImage tile) : base(mutationTarget)
+        {
+            sourceTile = source;
+            this.direction = direction;
+            this.length = length;
+            this.tile = tile;
+        }
+
+        private readonly MapTile sourceTile;
+        private readonly Direction direction;
+        private readonly int length;
+        private readonly TileImage tile;
+        private List<OriginalCellTerrainData> undoData = new List<OriginalCellTerrainData>();
+
+        public override string GetDisplayString()
+        {
+            string directionString = Translate("Direction." + direction, Helpers.DirectionToName(direction));
+            return string.Format(Translate(this, "DisplayString", "Place Terrain Line from {0} towards {1} with distance of {2}"), sourceTile.CoordsToPoint(), direction, length);
+        }
+
+        int GetSouthernmostSubTileOffset()
+        {
+            int maxY = 1;
+
+            for (int i = 0; i < tile.TMPImages.Length; i++)
+            {
+                var image = tile.TMPImages[i];
+
+                if (image == null)
+                    continue;
+
+                int cx = i % tile.Width;
+                int cy = i / tile.Height;
+
+                int southOffset = (cx + cy) / 2;
+                if (southOffset > maxY)
+                    maxY = southOffset;
+            }
+
+            return maxY;
+        }
+
+        int GetEasternmostSubTileOffset()
+        {
+            int maxEast = 1;
+
+            for (int i = 0; i < tile.TMPImages.Length; i++)
+            {
+                var image = tile.TMPImages[i];
+
+                if (image == null)
+                    continue;
+
+                int cx = i % tile.Width;
+                int cy = i / tile.Height;
+
+                int eastOffset = cx - cy;
+
+                if (eastOffset > maxEast)
+                    maxEast = eastOffset;
+            }
+
+            return maxEast;
+        }
+
+        int GetWesternmostSubTileOffset()
+        {
+            int maxWest = 1;
+
+            for (int i = 0; i < tile.TMPImages.Length; i++)
+            {
+                var image = tile.TMPImages[i];
+
+                if (image == null)
+                    continue;
+
+                int cx = i % tile.Width;
+                int cy = i / tile.Height;
+
+                int westOffset = cy - cx;
+
+                if (westOffset > maxWest)
+                    maxWest = westOffset;
+            }
+
+            return maxWest;
+        }
+
+        public override void Perform()
+        {
+            int processedLength = 0;
+            while (processedLength <= length)
+            {
+                Point2D coords = sourceTile.CoordsToPoint() + Helpers.VisualDirectionToPoint(direction).ScaleBy(processedLength);
+
+                PlaceTile(coords);
+
+                switch (direction)
+                {
+                    case Direction.NE:
+                    case Direction.SW:
+                        processedLength += tile.Height;
+                        break;
+                    case Direction.NW:
+                    case Direction.SE:
+                        processedLength += tile.Width;
+                        break;
+                    case Direction.N:
+                    case Direction.S:
+                        processedLength += GetSouthernmostSubTileOffset();
+                        break;
+                    case Direction.E:
+                        processedLength += GetEasternmostSubTileOffset();
+                        break;
+                    case Direction.W:
+                        processedLength += GetWesternmostSubTileOffset();
+                        break;
+                }
+            }
+
+            MutationTarget.InvalidateMap();
+        }
+
+        private void PlaceTile(Point2D coords)
+        {
+            var originalData = new List<OriginalCellTerrainData>();
+
+            // Process cells within tile foundation
+            for (int i = 0; i < tile.TMPImages.Length; i++)
+            {
+                MGTMPImage image = tile.TMPImages[i];
+
+                if (image == null)
+                    continue;
+
+                int cx = coords.X + i % tile.Width;
+                int cy = coords.Y + i / tile.Width;
+
+                Point2D cellCoords = new Point2D(cx, cy);
+                var cell = Map.GetTile(cellCoords);
+                if (cell == null)
+                    continue;
+
+                undoData.Add(new OriginalCellTerrainData(cellCoords, cell.TileIndex, cell.SubTileIndex, cell.Level));
+                cell.ChangeTileIndex(tile.TileID, (byte)i);
+            }
+        }
+
+        public override void Undo()
+        {
+            for (int i = 0; i < undoData.Count; i++)
+            {
+                OriginalCellTerrainData originalTerrainData = undoData[i];
+
+                var mapCell = MutationTarget.Map.GetTile(originalTerrainData.CellCoords);
+                if (mapCell != null)
+                {
+                    mapCell.ChangeTileIndex(originalTerrainData.TileIndex, originalTerrainData.SubTileIndex);
+                    mapCell.Level = originalTerrainData.HeightLevel;
+                    RefreshCellLighting(mapCell);
+                }
+            }
+
+            MutationTarget.InvalidateMap();
+        }
+    }
+}

src/TSMapEditor/Mutations/Classes/PlaceTerrainLineMutation.cs

@@ -25,7 +25,7 @@ public PlaceTerrainTileMutation(IMutationTarget mutationTarget, Point2D targetCe
         private readonly int heightOffset;
         private readonly BrushSize brushSize;
 
-        private List<OriginalTerrainData> undoData;
+        private List<OriginalCellTerrainData> undoData;
 
         private static readonly Point2D[] surroundingTiles = new Point2D[] { new Point2D(-1, 0), new Point2D(1, 0), new Point2D(0, -1), new Point2D(0, 1) };
 
@@ -53,14 +53,14 @@ private void AddUndoDataForTile(Point2D brushOffset)
                 if (mapTile != null && (!MutationTarget.OnlyPaintOnClearGround || mapTile.IsClearGround()) &&
                     !undoData.Exists(otd => otd.CellCoords.X == cx && otd.CellCoords.Y == cy))
                 {
-                    undoData.Add(new OriginalTerrainData(mapTile.TileIndex, mapTile.SubTileIndex, mapTile.Level, mapTile.CoordsToPoint()));
+                    undoData.Add(new OriginalCellTerrainData(mapTile.CoordsToPoint(), mapTile.TileIndex, mapTile.SubTileIndex, mapTile.Level));
                 }
             }
         }
 
         public override void Perform()
         {
-            undoData = new List<OriginalTerrainData>(tile.TMPImages.Length * brushSize.Width * brushSize.Height);
+            undoData = new List<OriginalCellTerrainData>(tile.TMPImages.Length * brushSize.Width * brushSize.Height);
 
             int totalWidth = tile.Width * brushSize.Width;
             int totalHeight = tile.Height * brushSize.Height;
@@ -164,13 +164,13 @@ public override void Undo()
         {
             for (int i = 0; i < undoData.Count; i++)
             {
-                OriginalTerrainData originalTerrainData = undoData[i];
+                OriginalCellTerrainData originalTerrainData = undoData[i];
 
                 var mapCell = MutationTarget.Map.GetTile(originalTerrainData.CellCoords);
                 if (mapCell != null)
                 {
                     mapCell.ChangeTileIndex(originalTerrainData.TileIndex, originalTerrainData.SubTileIndex);
-                    mapCell.Level = originalTerrainData.Level;
+                    mapCell.Level = originalTerrainData.HeightLevel;
                     RefreshCellLighting(mapCell);
                 }
             }