Tidy up project structure. Some updates

.vscode/launch.json

@@ -0,0 +1,25 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": ".NET Core Launch (console)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            "program": "${workspaceFolder}/GraalGmapGenerator/bin/Debug/netcoreapp3.1/GraalGmapGenerator.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}/GraalGmapGenerator",
+            "console": "externalTerminal",
+            "stopAtEntry": false
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach",
+            "processId": "${command:pickProcess}"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,42 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/GraalGmapGenerator/GraalGmapGenerator.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/GraalGmapGenerator/GraalGmapGenerator.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "${workspaceFolder}/GraalGmapGenerator/GraalGmapGenerator.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

GraalGmapGenerator/Generators/GmapContentGenerator.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using GraalGmapGenerator.Models;
+using GraalGmapGenerator.Options;
+
+namespace GraalGmapGenerator.Generators
+{
+    public class GmapContentGenerator
+    {
+        readonly GmapContentGeneratorOptions _options;
+
+        public GmapContentGenerator(GmapContentGeneratorOptions options)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        /// <summary>
+        /// Returns the gmap file contents
+        /// </summary>
+        /// <returns></returns>
+        public GmapContent Generate(Gmap gmap)
+        {
+            var stringBuilder = new StringBuilder();
+            (string Content, IEnumerable<Level> Levels) data = GenerateLevelNamesList(gmap);
+
+            stringBuilder.AppendLine("GRMAP001");
+            stringBuilder.AppendLine($"WIDTH {gmap.Width}");
+            stringBuilder.AppendLine($"HEIGHT {gmap.Height}");
+
+            if (gmap.NoAutomapping)
+                stringBuilder.AppendLine("NOAUTOMAPPING");
+
+            if (gmap.LoadFullMap)
+                stringBuilder.AppendLine("LOADFULLMAP");
+
+            stringBuilder.AppendLine("LEVELNAMES");
+            stringBuilder.AppendLine(data.Content);
+            stringBuilder.Append("LEVELNAMESEND");
+
+            string content = stringBuilder.ToString();
+
+            return new GmapContent(content, data.Levels);
+        }
+
+        private (string content, IEnumerable<Level> levelNames) GenerateLevelNamesList(Gmap gmap)
+        {
+            // TODO: Split this method up - it's doing too much. But I want to be able to generate
+            // the level names and also create a new instance of Level for each level within a single
+            // loop, rather than having a loop for each.
+
+            var stringBuilder = new StringBuilder();
+            var levels = new List<Level>();
+            int gmapArea = gmap.Width * gmap.Height;
+
+            for (int i = 0; i < gmapArea; i++)
+            {
+                var level = new Level(gmap, i, _options.LevelType);
+                levels.Add(level);
+
+                // Start a new line once the current line has hit the width of the gmap
+                if (i > 0 && i % gmap.Width == 0)
+                    stringBuilder.AppendLine();
+
+                stringBuilder.Append($"\"{level.FileName}\"");
+
+                // Only append a comma if its NOT the end of the row
+                if (i % gmap.Width < gmap.Width - 1)
+                {
+                    stringBuilder.Append(',');
+                }
+            }
+
+            return (stringBuilder.ToString(), levels);
+        }
+    }
+}

GraalGmapGenerator/Generators/LevelContentGenerator.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using GraalGmapGenerator.Models;
+using GraalGmapGenerator.Options;
+
+namespace GraalGmapGenerator.Generators
+{
+    public class LevelContentGenerator
+    {
+        private string _templateContent;
+        private LevelContentGeneratorOptions _options;
+
+        public LevelContentGenerator(LevelContentGeneratorOptions options)
+        {
+            _options = options;
+            _templateContent = GetTemplateFileContent(options.TemplateFilePath);
+        }
+
+        public string GenerateLevelContent(Gmap gmap, Level level)
+        {
+            var stringBuilder = new StringBuilder();
+
+            stringBuilder.AppendLine(_templateContent);
+
+            if (_options.AddLevelLinks)
+            {
+                IEnumerable<LevelLink> links = GetLevelLinks(gmap, level);
+                foreach (LevelLink link in links)
+                {
+                    stringBuilder.AppendLine(link.ToString());
+                }
+            }
+
+            return stringBuilder.ToString();
+        }
+
+        private IEnumerable<LevelLink> GetLevelLinks(Gmap gmap, Level level)
+        {
+            // Level is not on the first row
+            if (level.Index > gmap.Width)
+            {
+                int linkLevelIndex = level.Index - gmap.Width;
+                string levelFileName = Level.GetFileName(gmap.Name, linkLevelIndex, level.LevelType);
+
+                yield return new LevelLink(
+                    levelFileName, 0, 0, Level.Width, 1, "playerx", "61"
+                );
+            }
+
+            // If level is not the left-most on its row
+            if (level.Index % gmap.Width > 1)
+            {
+                int linkLevelIndex = level.Index - 1;
+                string levelFileName = Level.GetFileName(gmap.Name, linkLevelIndex, level.LevelType);
+
+                yield return new LevelLink(
+                    levelFileName, 0, 0, 1, Level.Height, "63", "playery"
+                );
+            }
+
+            // If level is not on the bottom row
+            if (level.Index < gmap.Width * gmap.Height - gmap.Width - 1)
+            {
+                int linkLevelIndex = level.Index + gmap.Width;
+                string levelFileName = Level.GetFileName(gmap.Name, linkLevelIndex, level.LevelType);
+
+                yield return new LevelLink(
+                    levelFileName, 0, Level.Height - 1, Level.Width, 1, "playerx", "3"
+                );
+            }
+
+            // If level is not the right-most on its row
+            if (level.Index % gmap.Width > 0)
+            {
+                int linkLevelIndex = level.Index - 1;
+                string levelFileName = Level.GetFileName(gmap.Name, linkLevelIndex, level.LevelType);
+
+                yield return new LevelLink(
+                    levelFileName, 0, 0, 1, Level.Height, "63", "playery"
+                );
+            }
+        }
+
+        private string GetTemplateFileContent(string templateFilePath)
+        {
+            if (!File.Exists(templateFilePath))
+            {
+                throw new FileNotFoundException($"Template file not found", templateFilePath);
+            }
+
+            return File.ReadAllText(templateFilePath);
+        }
+    }
+}

GraalGmapGenerator/GmapBuilder.cs

@@ -1,4 +1,6 @@
-namespace GraalGmapGenerator
+using GraalGmapGenerator.Models;
+
+namespace GraalGmapGenerator
 {
     public class GmapBuilder
     {
@@ -7,6 +9,7 @@
         private int _height;
         private bool _noAutomapping;
         private bool _loadFullMap;
+        private bool _addLevelLinks;
 
         public GmapBuilder SetName(string name)
         {
@@ -34,12 +37,21 @@
             return this;
         }
 
-        /// <summary>
+        public GmapBuilder AddLevelLinks(bool value)
-        /// Builds the gmap
+        {
-        /// </summary>
+            _addLevelLinks = value;
+            return this;
+        }
+        
         public Gmap Build()
         {
-            return new Gmap(_name, _width, _height, _noAutomapping, _loadFullMap);
+            return new Gmap(
+                _name,
+                _width,
+                _height,
+                _noAutomapping,
+                _loadFullMap,
+                _addLevelLinks);
         }
     }
 }

GraalGmapGenerator/GmapContentGenerator.cs

@@ -1,91 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using GraalGmapGenerator.Enums;
-
-namespace GraalGmapGenerator
-{
-    public class GmapContentGenerator
-    {
-        readonly LevelType _levelType;
-
-        public GmapContentGenerator(LevelType levelType)
-        {
-            _levelType = levelType;
-        }
-
-        /// <summary>
-        /// Returns the gmap file contents
-        /// </summary>
-        /// <returns></returns>
-        public string Generate(Gmap gmap)
-        {
-            var stringBuilder = new StringBuilder();
-
-            stringBuilder.AppendLine("GRMAP001");
-            stringBuilder.AppendLine($"WIDTH {gmap.Width}");
-            stringBuilder.AppendLine($"HEIGHT {gmap.Height}");
-
-            if (gmap.NoAutomapping)
-                stringBuilder.AppendLine("NOAUTOMAPPING");
-
-            if (gmap.LoadFullMap)
-                stringBuilder.AppendLine("LOADFULLMAP");
-
-            stringBuilder.AppendLine("LEVELNAMES");
-
-            var levelNames = GetLevelNames(gmap).ToList();
-            for (var i = 0; i < levelNames.Count; i++)
-            {
-                // Start a new line once the current line has hit the width of the gmap
-                if (i > 0 && i % gmap.Width == 0)
-                    stringBuilder.AppendLine();
-
-                var levelName = GetLevelName(i, gmap.Name, _levelType);
-                stringBuilder.Append($"\"{levelName}\"");
-
-                // Only append a comma if its NOT the end of the row
-                if (i % gmap.Width < (gmap.Width - 1))
-                {
-                    stringBuilder.Append(',');
-                }
-            }
-
-            stringBuilder.AppendLine();
-            stringBuilder.Append("LEVELNAMESEND");
-
-            return stringBuilder.ToString();
-        }
-
-        public IEnumerable<string> GetLevelNames(Gmap gmap)
-        {
-            var levelNames = new List<string>();
-
-            for (var i = 0; i < (gmap.Width * gmap.Height); i++)
-            {
-                levelNames.Add(GetLevelName(i, gmap.Name, _levelType));
-            }
-
-            return levelNames;
-        }
-
-        private string GetLevelName(int index, string name, LevelType levelType)
-        {
-            string extension;
-
-            switch (levelType)
-            {
-                default:
-                case LevelType.Nw:
-                    extension = ".nw"; 
-                break;
-
-                case LevelType.Graal:
-                    extension = ".graal"; 
-                    break;
-            }
-
-            return $"{name}_{index}{extension}";
-        }
-    }
-}

GraalGmapGenerator/GmapPropertyValidators.cs

@@ -0,0 +1,39 @@
+using System;
+using System.IO;
+using System.Linq;
+
+namespace GraalGmapGenerator
+{
+    public static class GmapPropertyValidators
+    {
+        public static bool IsValidDimension(string input)
+        {
+            return int.TryParse(input, out int dimension) && dimension > 0;
+        }
+
+        public static bool IsValidYesNoInput(string input)
+        {
+            var inputLowered = input.ToLower();
+            if (inputLowered == "yes" || inputLowered == "y")
+                return true;
+            if (inputLowered == "no" || inputLowered == "n")
+                return true;
+            return false;
+        }
+
+        public static bool IsValidDirectory(string input)
+        {
+            char[] inputChars = input.ToCharArray();
+            char[] fsInvalidPathChars = Path.GetInvalidPathChars();
+            foreach (char inputChar in inputChars)
+            {
+                if (fsInvalidPathChars.Contains(inputChar))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}

GraalGmapGenerator/GmapWriter.cs

@@ -0,0 +1,45 @@
+using System.IO;
+using GraalGmapGenerator.Enums;
+using GraalGmapGenerator.Generators;
+using GraalGmapGenerator.Models;
+
+namespace GraalGmapGenerator
+{
+    public static class GmapWriter
+    {
+        private const string DefaultTemplateFilePath = "template.nw";
+
+        public static void Write(string destinationPath, Gmap gmap)
+        {
+            if (!Directory.Exists(destinationPath))
+            {
+                Directory.CreateDirectory(destinationPath);
+            }
+
+            var gmapContentGen = new GmapContentGenerator(new Options.GmapContentGeneratorOptions
+            {
+                LevelType = LevelType.Nw
+            });
+            
+            GmapContent gmapContent = gmapContentGen.Generate(gmap);
+
+            var levelContentGen = new LevelContentGenerator(new Options.LevelContentGeneratorOptions
+            {
+                AddLevelLinks = gmap.AddLevelLinks,
+                TemplateFilePath = DefaultTemplateFilePath
+            });
+
+            foreach (Level level in gmapContent.Levels)
+            {
+                File.Copy(DefaultTemplateFilePath, $"{destinationPath}/{level.FileName}");
+
+                string filePath = $"{destinationPath}/{level.FileName}";
+                string fileContent = levelContentGen.GenerateLevelContent(gmap, level);
+
+                File.WriteAllText(filePath, fileContent);
+            }
+
+            File.AppendAllText($"{destinationPath}/{gmap.Name}.gmap", gmapContent.Content);
+        }
+    }
+}

GraalGmapGenerator/GraalGmapGenerator.csproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

GraalGmapGenerator/Helpers.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace GraalGmapGenerator
+{
+    public static class Helpers
+    {
+        public static bool YesNoToBool(string input)
+        {
+            string inputLowered = input.ToLower();
+            if (input == "y" || input == "yes")
+                return true;
+            if (input == "n" || input == "no")
+                return false;
+            throw new ArgumentException("Invalid input given.", nameof(input));
+        }
+    }
+}

GraalGmapGenerator/Models/Gmap.cs

@@ -1,29 +1,33 @@
-namespace GraalGmapGenerator
+namespace GraalGmapGenerator.Models
 {
     public class Gmap
     {
-        public string Name { get; set; }
+        public string Name { get; }
 
-        public int Width { get; set; }
+        public int Width { get; }
 
         public int Height { get; set; }
 
-        public bool NoAutomapping { get; set; }
+        public bool NoAutomapping { get; }
 
-        public bool LoadFullMap { get; set; }
+        public bool LoadFullMap { get; }
+
+        public bool AddLevelLinks { get; }
 
         public Gmap(
             string name,
             int width,
             int height,
             bool noAutomapping = false,
-            bool loadFullMap = false)
+            bool loadFullMap = false,
+            bool addLevelLinks = false)
         {
             Name = name;
             Width = width;
             Height = height;
             NoAutomapping = noAutomapping;
             LoadFullMap = loadFullMap;
+            AddLevelLinks = addLevelLinks;
         }
     }
 }

GraalGmapGenerator/Models/GmapContent.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace GraalGmapGenerator.Models
+{
+    public class GmapContent
+    {
+        public string Content { get; }
+        public IEnumerable<Level> Levels { get; }
+
+        public GmapContent(string content, IEnumerable<Level> levels)
+        {
+            Content = content;
+            Levels = levels;
+        }
+    }
+}

GraalGmapGenerator/Models/Level.cs

@@ -0,0 +1,42 @@
+using System;
+using GraalGmapGenerator.Enums;
+
+namespace GraalGmapGenerator.Models
+{
+    public class Level
+    {
+        public const int Width = 64;
+        public const int Height = 64;
+
+        public string FileName { get; }
+        public int Index { get; }
+        public LevelType LevelType { get; }
+
+        public Level(Gmap gmap, int index, LevelType levelType)
+        {
+            FileName = GetFileName(gmap.Name, index, levelType);
+            Index = index;
+            LevelType = levelType;
+        }
+
+        private static string GetFileExtensionForLevelType(LevelType levelType)
+        {
+            switch (levelType)
+            {
+                default:
+                    throw new NotImplementedException($"{levelType} has not been implemented.");
+
+                case LevelType.Nw:
+                    return ".nw";
+
+                case LevelType.Graal:
+                    return ".graal";
+            }
+        }
+
+        public static string GetFileName(string gmapName, int index, LevelType levelType)
+        {
+            return $"{gmapName}_{index}{GetFileExtensionForLevelType(levelType)}";
+        }
+    }
+}

GraalGmapGenerator/Models/LevelLink.cs

@@ -0,0 +1,36 @@
+namespace GraalGmapGenerator.Models
+{
+    public class LevelLink
+    {
+        public string LevelFileName { get; }
+        public int X { get; }
+        public int Y { get; }
+        public int Width { get; }
+        public int Height { get; }
+        public string DestinationX { get; }
+        public string DestinationY { get; }
+
+        public LevelLink(
+            string levelFileName,
+            int x,
+            int y,
+            int width,
+            int height,
+            string destinationX,
+            string destinationY)
+        {
+            LevelFileName = levelFileName;
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+            DestinationX = destinationX;
+            DestinationY = destinationY;
+        }
+
+        public override string ToString()
+        {
+            return $"LINK {LevelFileName} {X} {Y} {Width} {Height} {DestinationX} {DestinationY}";
+        }
+    }
+}

GraalGmapGenerator/Options/GmapContentGeneratorOptions.cs

@@ -0,0 +1,9 @@
+using GraalGmapGenerator.Enums;
+
+namespace GraalGmapGenerator.Options
+{
+    public class GmapContentGeneratorOptions
+    {
+        public LevelType LevelType { get; set; }
+    }
+}

GraalGmapGenerator/Options/LevelContentGeneratorOptions.cs

@@ -0,0 +1,8 @@
+namespace GraalGmapGenerator.Options
+{
+    public class LevelContentGeneratorOptions
+    {
+        public string TemplateFilePath { get; set; }
+        public bool AddLevelLinks { get; set; }
+    }
+}

GraalGmapGenerator/Program.cs

@@ -1,93 +1,168 @@
-using GraalGmapGenerator.Enums;
+using System;
-using System;
 using System.IO;
 
 namespace GraalGmapGenerator
 {
     class Program
     {
-        const string TemplateFile = "template.nw";
+        private const string ValidationMessageYesNo = "Please provide a valid \"y\" or \"n\" value!";
 
         static void Main(string[] args)
         {
+            Console.WriteLine(
+                "Welcome to the GMAP generator. You can use this tool to easily generate a GMAP file " +
+                "\nwith the accompanying level files. Simply provide values for settings below, hitting enter " +
+                "\nto move to the next setting."
+            );
+            Console.WriteLine();
+            Console.WriteLine(
+                "If you run into any problems, drop me an email at me@aaronjy.me and I " +
+                "\nwill endeavour to respond as soon as possible. " +
+                "\nThanks for using my software! - Aaron Yarborough"
+            );
+            Console.WriteLine("------------------------");
+
             var mapBuilder = new GmapBuilder();
 
             Console.WriteLine("Gmap name...");
-            mapBuilder.SetName(Console.ReadLine());
+            string gmapName = Console.ReadLine();
+            mapBuilder.SetName(gmapName);
 
             Console.WriteLine("Gmap width (in levels, for example: 8)...");
-            // need to handle errors
+            int width = int.Parse(
-            int width;
+                GetInput(
-            do
+                    inputFunc: () => Console.ReadLine(),
-            {
+                    validator: (input) => 
-                var isValid = int.TryParse(Console.ReadLine(), out width) && width > 0;
+                    {
-                if (!isValid)
+                        if (!GmapPropertyValidators.IsValidDimension(input))
-                {
+                        {
-                    Console.WriteLine("Please enter a valid gmap width!");
+                            Console.WriteLine("Please enter a valid gmap width!");
-                }
+                            return false;
-            } while (width <= 0);
+                        }
+
+                        return true;
+                    }
+                )
+            );
 
             Console.WriteLine("Gmap height (in levels, for example: 5)...");
-            int height;
+            int height = int.Parse(
-            do
+                GetInput(
-            {
+                    inputFunc: () => Console.ReadLine(),
-                var isValid = int.TryParse(Console.ReadLine(), out height) && height > 0;
+                    validator: (input) => 
-                if (!isValid)
+                    {
-                {
+                        if (!GmapPropertyValidators.IsValidDimension(input))
-                    Console.WriteLine("Please enter a valid gmap height!");
+                        {
-                }
+                            Console.WriteLine("Please enter a valid gmap height!");
-            } while (height <= 0);
+                            return false;
+                        }
+
+                        return true;
+                    }
+                )
+            );
 
             mapBuilder.SetDimensions(width, height);
 
             Console.WriteLine("Load full map? (y/n)...");
-            if (Console.ReadLine() == "y")
+            Console.WriteLine("INFO: Loads all map parts into memory on startup.");
-            {
+
-                mapBuilder.LoadFullMap(true);
+            string loadFullMapStr = GetInput(
-            }
+                inputFunc: () => Console.ReadLine(),
+                validator: (input) => 
+                {
+                    if (!GmapPropertyValidators.IsValidYesNoInput(input))
+                    {
+                        Console.WriteLine(ValidationMessageYesNo);
+                        return false;
+                    }
+
+                    return true;
+                }
+            );
+
+            mapBuilder.LoadFullMap(Helpers.YesNoToBool(loadFullMapStr));
 
             Console.WriteLine("No automapping? (y/n)...");
-            if (Console.ReadLine() == "y")
+            Console.WriteLine("INFO: Disables the assembly of automagical screenshots into a map that is drawn over the MAPIMG image.");
+            
+            string noAutoMappingStr = GetInput(
+                inputFunc: () => Console.ReadLine(),
+                validator: (input) => 
+                {
+                    if (!GmapPropertyValidators.IsValidYesNoInput(input))
+                    {
+                        Console.WriteLine(ValidationMessageYesNo);
+                        return false;
+                    }
+
+                    return true;
+                }
+            );
+
+            mapBuilder.NoAutomapping(Helpers.YesNoToBool(noAutoMappingStr));
+
+            Console.WriteLine("Add level links? (y/n)...");
+            Console.WriteLine("INFO: If \"y\" is selected, level links will be automatically added between GMAP levels.");
+
+            string addLevelLinksStr = GetInput(
+                () => Console.ReadLine(),
+                validator: (input) =>
+                {
+                    if (!GmapPropertyValidators.IsValidYesNoInput(input))
+                    {
+                        Console.WriteLine(ValidationMessageYesNo);
+                        return false;
+                    }
+
+                    return true;
+                }
+            );
+
+            mapBuilder.AddLevelLinks(Helpers.YesNoToBool(addLevelLinksStr));
+
+            Console.WriteLine("Save directory...");
+            Console.WriteLine($"INFO: If you do not wish to provide a save directory, you can leave this setting blank (hit ENTER) and the GMAP will be created under \"gmaps/\" in the application directory ({AppDomain.CurrentDomain.BaseDirectory}/gmaps/{gmapName}/)");
+
+            string saveDirectory = GetInput(
+                () => Console.ReadLine(),
+                (input) =>
+                {
+                    if (input != "" && !GmapPropertyValidators.IsValidDirectory(input))
+                    {
+                        Console.WriteLine("Please provide a valid directory path.");
+                        return false;
+                    }
+
+                    return true;
+                }
+            );
+
+            if (saveDirectory == "")
             {
-                mapBuilder.NoAutomapping(true);
+                saveDirectory = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "gmaps", gmapName);
             }
 
             Console.WriteLine("Generating gmap...");
             var gmap = mapBuilder.Build();
 
             Console.WriteLine("Saving gmap...");
-            SaveGmap(gmap);
+            GmapWriter.Write(saveDirectory, gmap);
 
             Console.WriteLine("Done!");
             Console.ReadLine();
         }
 
-        static void SaveGmap(Gmap gmap)
+        private static string GetInput(Func<string> inputFunc, Func<string, bool> validator)
         {
-            const string OutputDirRoot = "gmaps";
+            do
-            var outputDir = $"{OutputDirRoot}/{gmap.Name}";
-
-            // Create output directory if it doesn't exist
-            if (!Directory.Exists(OutputDirRoot))
             {
-                Directory.CreateDirectory(OutputDirRoot);
+                string inputResolved = inputFunc();
-            }
+                if (validator(inputResolved))
-
+                {
-            // Create gmap output directory
+                    return inputResolved;
-            Directory.CreateDirectory(outputDir);
+                }
-
+            } while (true);
-            var gmapContentGen = new GmapContentGenerator(LevelType.Nw);
-
-            // Create a new level file for each level
-            var levelNames = gmapContentGen.GetLevelNames(gmap);
-            foreach (var level in levelNames)
-            {
-                File.Copy(TemplateFile, $"{outputDir}/{level}");
-            }
-
-            // Create the gmap file
-            var gmapContent = gmapContentGen.Generate(gmap);
-            File.AppendAllText($"{outputDir}/{gmap.Name}.gmap", gmapContent);
         }
     }
 }

GraalGmapGeneratorTests/Fake/GmapContentGenerationOptionsFake.cs

@@ -0,0 +1,15 @@
+using GraalGmapGenerator.Options;
+
+namespace GraalGmapGeneratorTests.Fake
+{
+    internal static class GmapContentGenerationOptionsFake
+    {
+        internal static GmapContentGeneratorOptions Get()
+        {
+            return new GmapContentGeneratorOptions
+            {
+                LevelType = GraalGmapGenerator.Enums.LevelType.Graal
+            };
+        }
+    }
+}

GraalGmapGeneratorTests/Fake/GmapFake.cs

@@ -0,0 +1,58 @@
+using GraalGmapGenerator.Models;
+
+namespace GraalGmapGeneratorTests.Fake
+{
+    internal static class GmapFake
+    {
+        private const string DefaultName = "Test gmap";
+        private const int DefaultWidth = 8;
+        private const int DefaultHeight = 10;
+        private const bool DefaultNoAutomapping = false;
+        private const bool DefaultLoadFullMap = false;
+        private const bool DefaultAddLevelLinks = false;
+
+        internal static Gmap Get()
+        {
+            return new Gmap(
+                DefaultName,
+                DefaultWidth,
+                DefaultHeight,
+                noAutomapping: DefaultNoAutomapping,
+                loadFullMap: DefaultLoadFullMap,
+                addLevelLinks: DefaultAddLevelLinks);
+        }
+        
+        internal static Gmap GetWithAutomappingTrue()
+        {
+            return new Gmap(
+                DefaultName,
+                DefaultWidth,
+                DefaultHeight,
+                noAutomapping: true,
+                loadFullMap: DefaultLoadFullMap,
+                addLevelLinks: DefaultAddLevelLinks);
+        }
+
+        internal static Gmap GetWithLoadFullMapTrue()
+        {
+            return new Gmap(
+                DefaultName,
+                DefaultWidth,
+                DefaultHeight,
+                noAutomapping: DefaultNoAutomapping,
+                loadFullMap: true,
+                addLevelLinks: DefaultAddLevelLinks);
+        }
+
+        internal static Gmap GetWithAddLevelLinksTrue()
+        {
+            return new Gmap(
+                DefaultName,
+                DefaultWidth,
+                DefaultHeight,
+                noAutomapping: DefaultNoAutomapping,
+                loadFullMap: DefaultLoadFullMap,
+                addLevelLinks: true);
+        }
+    }
+}

GraalGmapGeneratorTests/GmapBuilderTests.cs

@@ -3,6 +3,7 @@ using NUnit.Framework;
 
 namespace GraalGmapGeneratorTests
 {
+    [TestFixture]
     public class GmapBuilderTests
     {
         GmapBuilder gmapBuilder;

GraalGmapGeneratorTests/GmapContentGeneratorTests.cs

@@ -1,5 +1,8 @@
-using GraalGmapGenerator;
+using GraalGmapGenerator.Enums;
-using GraalGmapGenerator.Enums;
+using GraalGmapGenerator.Generators;
+using GraalGmapGenerator.Models;
+using GraalGmapGenerator.Options;
+using GraalGmapGeneratorTests.Fake;
 using NUnit.Framework;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,34 +10,30 @@ using System.Text.RegularExpressions;
 
 namespace GraalGmapGeneratorTests
 {
+    [TestFixture]
     public class GmapContentGeneratorTests
     {
         [Test]
         public void Generate_SavesCorrectDimensions()
         {
-            var expectedWidth = 5;
+            Gmap gmap = GmapFake.Get();
-            var expectedHeight = 6;
 
-            var gmap = GetTestGmap();
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            gmap.Width = expectedWidth;
+            string result = generator.Generate(gmap).Content;
-            gmap.Height = expectedHeight;
+            string[] lines = result.Split("\n\r".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            Assert.AreEqual($"WIDTH {gmap.Width}", lines[1]);
-            var result = generator.Generate(gmap);
+            Assert.AreEqual($"HEIGHT {gmap.Height}", lines[2]);
-            var lines = result.Split("\n\r".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries);
-
-            Assert.AreEqual($"WIDTH {expectedWidth}", lines[1]);
-            Assert.AreEqual($"HEIGHT {expectedHeight}", lines[2]);
         }
 
         [Test]
         public void Generate_SavesHeader()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.Get();
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
-            var lines = SplitContentByLines(result);
+            List<string> lines = SplitContentByLines(result);
 
             Assert.AreEqual("GRMAP001", lines[0]);
         }
@@ -42,12 +41,11 @@ namespace GraalGmapGeneratorTests
         [Test]
         public void Generate_SaveNoAutomappingLine_WhenNoAutomappingIsTrue()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.GetWithAutomappingTrue();
-            gmap.NoAutomapping = true;
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
-            var lines = SplitContentByLines(result);
+            List<string> lines = SplitContentByLines(result);
 
             Assert.IsTrue(lines.Contains("NOAUTOMAPPING"));
         }
@@ -55,12 +53,11 @@ namespace GraalGmapGeneratorTests
         [Test]
         public void Generate_DoesntSaveNoAutomappingLine_WhenNoAutomappingIsFalse()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.Get();
-            gmap.NoAutomapping = false;
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
-            var lines = SplitContentByLines(result);
+            List<string> lines = SplitContentByLines(result);
 
             Assert.IsFalse(lines.Contains("NOAUTOMAPPING"));
         }
@@ -68,12 +65,11 @@ namespace GraalGmapGeneratorTests
         [Test]
         public void Generate_SaveLoadFullMapLine_WhenLoadFullMapIsTrue()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.GetWithLoadFullMapTrue();
-            gmap.LoadFullMap = true;
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
-            var lines = SplitContentByLines(result);
+            List<string> lines = SplitContentByLines(result);
 
             Assert.IsTrue(lines.Contains("LOADFULLMAP"));
         }
@@ -81,12 +77,11 @@ namespace GraalGmapGeneratorTests
         [Test]
         public void Generate_DoesntSaveLoadFullMapLine_WhenLoadFullMapIsFalse()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.Get();
-            gmap.LoadFullMap = false;
 
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
-            var lines = SplitContentByLines(result);
+            List<string> lines = SplitContentByLines(result);
 
             Assert.IsFalse(lines.Contains("LOADFULLMAP"));
         }
@@ -96,13 +91,16 @@ namespace GraalGmapGeneratorTests
         [TestCase(LevelType.Graal, ".graal")]
         public void Generate_SavesValidLevels_ForLevelType(LevelType levelType, string expectedFileExtension)
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.Get();
-            var generator = new GmapContentGenerator(levelType);
+            var generator = new GmapContentGenerator(new GmapContentGeneratorOptions
+            {
+                LevelType = levelType
+            });
 
-            var content = generator.Generate(gmap);
+            string content = generator.Generate(gmap).Content;
 
-            var levelNames = GetLevelNamesFromContent(content);
+            IEnumerable<string> levelNames = GetLevelNamesFromContent(content);
-            var isAllCorrectFileExtension = levelNames.All(levelName => levelName.EndsWith(expectedFileExtension));
+            bool isAllCorrectFileExtension = levelNames.All(levelName => levelName.EndsWith(expectedFileExtension));
 
             Assert.IsTrue(isAllCorrectFileExtension);
         }
@@ -110,9 +108,9 @@ namespace GraalGmapGeneratorTests
         [Test]
         public void Generate_DoesSaveLevelNamesTags()
         {
-            var gmap = GetTestGmap();
+            Gmap gmap = GmapFake.Get();
-            var generator = new GmapContentGenerator(LevelType.Graal);
+            var generator = new GmapContentGenerator(GmapContentGenerationOptionsFake.Get());
-            var result = generator.Generate(gmap);
+            string result = generator.Generate(gmap).Content;
 
             Assert.IsTrue(result.Contains("LEVELNAMES", System.StringComparison.Ordinal));
             Assert.IsTrue(result.Contains("LEVELNAMESEND", System.StringComparison.Ordinal));
@@ -124,11 +122,6 @@ namespace GraalGmapGeneratorTests
             return levelNamePattern.Matches(content).Select(x => x.Groups[1].Value);
         }
 
-        private Gmap GetTestGmap()
-        {
-            return new Gmap("My test gmap", 10, 11, true, true);
-        }
-
         private List<string> SplitContentByLines(string content)
         {
             return content.Split("\n\r".ToCharArray(), System.StringSplitOptions.RemoveEmptyEntries).ToList();

GraalGmapGeneratorTests/GmapPropertyValidatorsTests.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using GraalGmapGenerator;
+using NUnit.Framework;
+
+namespace GraalGmapGeneratorTests
+{
+    [TestFixture]
+    public class GmapPropertyValidatorsTests
+    {
+        internal static IEnumerable<string> GetInvalidPaths()
+        {
+            const string dummyPath = "dir/";
+            char[] invalidChars = System.IO.Path.GetInvalidPathChars();
+            foreach (char invalidChar in invalidChars)
+            {
+                yield return dummyPath + invalidChar;
+            }
+        }
+        
+        [TestCase("-1")]
+        [TestCase("0")]
+        [TestCase("abc")]
+        [TestCase("£$%^&*")]
+        [TestCase("123a")]
+        public void IsValidDimension_IfInvalidDimension_ReturnsFalse(string invalidDimension)
+        {
+            Assert.False(GmapPropertyValidators.IsValidDimension(invalidDimension));
+        }
+
+        [TestCase("1")]
+        [TestCase("12345")]
+        [TestCase("10")]
+        [TestCase("2147483647")]
+        public void IsValidDimension_IfValidDimension_ReturnsTrue(string validDimension)
+        {
+            Assert.True(GmapPropertyValidators.IsValidDimension(validDimension));
+        }
+
+        [TestCase("")]
+        [TestCase("oopsie")]
+        [TestCase("ye")]
+        [TestCase("yess")]
+        [TestCase("noo")]
+        [TestCase("12345")]
+        public void IsValidYesNoInput_IfIsInvalidValidInput_ReturnsFalse(string invalidInput)
+        {
+            Assert.False(GmapPropertyValidators.IsValidYesNoInput(invalidInput));
+        }
+
+        [TestCase("y")]
+        [TestCase("yes")]
+        [TestCase("n")]
+        [TestCase("no")]
+        public void IsValidYesNoInput_IfIsValidInput_ReturnsTrue(string validInput)
+        {
+            Assert.True(GmapPropertyValidators.IsValidYesNoInput(validInput));
+        }
+
+        [TestCaseSource(nameof(GetInvalidPaths))]
+        public void IsValidDirectory_IfIsInvalidDirectory_ReturnsFalse(string invalidPath)
+        {
+            Assert.False(GmapPropertyValidators.IsValidDirectory(invalidPath));
+        }
+
+        [TestCase("my/path")]
+        [TestCase("my/path/")]
+        [TestCase("directory")]
+        [TestCase("C:/users/Aaron/gmaps")]
+        public void IsValidDirectory_IfIsValidDirectory_ReturnsTrue(string validPath)
+        {
+            Assert.True(GmapPropertyValidators.IsValidDirectory(validPath));
+        }
+    }
+}

GraalGmapGeneratorTests/GmapTests.cs

@@ -1,8 +1,9 @@
-using GraalGmapGenerator;
+using GraalGmapGenerator.Models;
 using NUnit.Framework;
 
 namespace GraalGmapGeneratorTests
 {
+    [TestFixture]
     public class GmapTests
     {
         [Test]

GraalGmapGeneratorTests/GraalGmapGeneratorTests.csproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.0</TargetFramework>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
-
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 

README.md

@@ -1,5 +1,19 @@
-# Graal GMAP Generator 
+
-A tool to automatically generate a GMAP file and level files for a gmap of any given size. 
+# Graal GMAP Generator
+
+A tool to automatically generate a GMAP file and level files for a gmap of any given size.
 
 ![demonstration](https://i.imgur.com/qxU7XRZ.jpg)
 
+## Options
+
+The following options can be specified before generating a GMAP.
+|Option|Description|
+|--|--|
+|Name|The name of the gmap. The name will be used as the gmap filename, and also as the prefix for the level files it generates.|
+|Width, Height|The width and height of the GMAP in levels. For example, generating a 4 x 4 GMAP will result in 16 level files.| 
+|Load full map|Loads all map parts into memory on startup.|
+|Automapping|If "n" is selected, disables the assembly of automagical screenshots into a map that is drawn over the MAPIMG image.|
+|Level links|If "y" is selected, level links will be automatically added between GMAP levels.|
+
+You can also choose to generate the GMAP files in a specific directory on your computer. If no directory path is given, the files will be generated in the application folder under `gmaps/`