README.MD

Merge pull request #10 from bradybod/SquareSimulation
added to python script
2020-12-16 20:48:38 -07:00 · 2020-12-16 20:39:57 -07:00 · 2020-12-16 20:39:19 -07:00 · 2020-12-16 18:04:49 -07:00 · 2020-12-16 18:04:26 -07:00 · 2020-12-16 17:19:25 -07:00
60 changed files with 10346 additions and 226 deletions
--- a/.DS_Store
+++ b/.DS_Store
--- a/.idea/.idea.RobotIntelFinal/.idea/contentModel.xml
+++ b/.idea/.idea.RobotIntelFinal/.idea/contentModel.xml
@@ -7,22 +7,28 @@
        <e p="Bootstrapper.cs" t="Include" />
        <e p="ConsoleApp.csproj" t="IncludeRecursive" />
        <e p="CoreModule.cs" t="Include" />
+        <e p="IJsonDeserializor.cs" t="Include" />
        <e p="IModule.cs" t="Include" />
        <e p="ISimRunner.cs" t="Include" />
+        <e p="ISimulationResults.cs" t="Include" />
        <e p="IUserConsole.cs" t="Include" />
+        <e p="JsonDeserializor.cs" t="Include" />
        <e p="Maps" t="Include">
-          <e p="HexCell.cs" t="Include" />
+          <e p="AstarSquareSearch.cs" t="Include" />
+          <e p="Cell.cs" t="Include" />
+          <e p="GlobalDirection.cs" t="Include" />
+          <e p="Heading.cs" t="Include" />
          <e p="HexMap.cs" t="Include" />
-          <e p="IHexCell.cs" t="Include" />
+          <e p="ICell.cs" t="Include" />
          <e p="IHexMap.cs" t="Include" />
          <e p="IMapFactory.cs" t="Include" />
-          <e p="ISquareCell.cs" t="Include" />
+          <e p="IMineMap.cs" t="Include" />
          <e p="ISquareMap.cs" t="Include" />
+          <e p="MapExtensions.cs" t="Include" />
          <e p="MapFactory.cs" t="Include" />
-          <e p="SquareCell.cs" t="Include" />
+          <e p="MineMap.cs" t="Include" />
          <e p="SquareMap.cs" t="Include" />
        </e>
-        <e p="Module.cs" t="Include" />
        <e p="obj" t="ExcludeRecursive">
          <e p="Debug" t="Include">
            <e p="netcoreapp3.1" t="Include">
@@ -30,14 +36,46 @@
            </e>
          </e>
        </e>
+        <e p="Output" t="Include">
+          <e p="Data.txt" t="Include" />
+          <e p="HexCoverage.png" t="Include" />
+          <e p="HexCoveredCells.txt" t="Include" />
+          <e p="HexDetectedMines.txt" t="Include" />
+          <e p="HexPath.txt" t="Include" />
+          <e p="HexTest.png" t="Include" />
+          <e p="Mines.txt" t="Include" />
+          <e p="SquareCoverage.png" t="Include" />
+          <e p="SquareCoveredCells.txt" t="Include" />
+          <e p="SquareDetectedMines.txt" t="Include" />
+          <e p="SquarePath.txt" t="Include" />
+          <e p="SquareTest.png" t="Include" />
+        </e>
+        <e p="Output 2.zip" t="Include" />
+        <e p="Output.zip" t="Include" />
+        <e p="PathPlanners" t="Include">
+          <e p="IPathPlanner.cs" t="Include" />
+          <e p="IReactivePathPlanner.cs" t="Include" />
+          <e p="PathPlanner.cs" t="Include" />
+          <e p="ReactivePathPlanner.cs" t="Include" />
+        </e>
+        <e p="plotGraphs.py" t="Include" />
        <e p="Program.cs" t="Include" />
+        <e p="Sim" t="Include">
+          <e p="DetectionHead.cs" t="Include" />
+          <e p="IVehicle.cs" t="Include" />
+          <e p="Vehicle.cs" t="Include" />
+          <e p="VehicleConfiguration.cs" t="Include" />
+          <e p="VehicleConfiguration.json" t="Include" />
+        </e>
        <e p="SimRunner.cs" t="Include" />
+        <e p="SimulationResults.cs" t="Include" />
        <e p="UserConsole.cs" t="Include" />
      </e>
      <e p="packages" t="ExcludeRecursive" />
      <e p="RobotIntelFinal.sln" t="IncludeFlat" />
    </e>
-    <e p="$USER_HOME$/Library/Caches/JetBrains/Rider2020.2/extResources" t="IncludeRecursive" />
-    <e p="$USER_HOME$/Library/Caches/JetBrains/Rider2020.2/resharper-host/local/Transient/Rider/v202/SolutionCaches/_RobotIntelFinal.-1349721189.00" t="ExcludeRecursive" />
+    <e p="$APPLICATION_CONFIG_DIR$/consoles/ide" t="IncludeRecursive" />
+    <e p="$USER_HOME$/Library/Caches/JetBrains/Rider2020.3/extResources" t="IncludeRecursive" />
+    <e p="$USER_HOME$/Library/Caches/JetBrains/Rider2020.3/resharper-host/local/Transient/Rider/v203/SolutionCaches/_RobotIntelFinal.-1349721189.00" t="ExcludeRecursive" />
  </component>
 </project>
--- a/.idea/.idea.RobotIntelFinal/.idea/modules.xml
+++ b/.idea/.idea.RobotIntelFinal/.idea/modules.xml
@@ -2,7 +2,7 @@
 <project version="4">
  <component name="ProjectModuleManager">
    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/riderModule.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/riderModule.iml" filepath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/riderModule.iml" />
    </modules>
  </component>
 </project>
--- a/.idea/.idea.RobotIntelFinal/.idea/workspace.xml
+++ b/.idea/.idea.RobotIntelFinal/.idea/workspace.xml
@@ -4,6 +4,9 @@
    <projectFile>Simulator/Simulator.csproj</projectFile>
    <projectFile>ConsoleApp/ConsoleApp.csproj</projectFile>
  </component>
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
  <component name="BranchesTreeState">
    <expand>
      <path>
@@ -15,67 +18,124 @@
  </component>
  <component name="ChangeListManager">
    <list default="true" id="dafcaeb7-80aa-43a3-a480-786fafb78c0b" name="Default Changelist" comment="">
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/HexCell.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/HexMap.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/IHexCell.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/IHexMap.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/ISquareCell.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/ISquareMap.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/SquareCell.cs" afterDir="false" />
-      <change afterPath="$PROJECT_DIR$/ConsoleApp/Maps/SquareMap.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/contentModel.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/contentModel.xml" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/.idea.RobotIntelFinal/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ConsoleApp/Bootstrapper.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Bootstrapper.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ConsoleApp/ISimRunner.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/ISimRunner.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ConsoleApp/Maps/IMapFactory.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Maps/IMapFactory.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ConsoleApp/Maps/MapFactory.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Maps/MapFactory.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/ConsoleApp.csproj" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/ConsoleApp.csproj" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/HexPlot.py" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/plotGraphs.py" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/Data.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/Data.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/HexCoverage.png" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/HexCoverage.png" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/HexCoveredCells.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/HexCoveredCells.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/HexDetectedMines.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/HexDetectedMines.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/HexPath.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/HexPath.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/HexTest.png" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/HexTest.png" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/Mines.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/Mines.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/SquareCoverage.png" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/SquareCoverage.png" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/SquareCoveredCells.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/SquareCoveredCells.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/SquareDetectedMines.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/SquareDetectedMines.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/SquarePath.txt" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/SquarePath.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/Output/SquareTest.png" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Output/SquareTest.png" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/PathPlanners/PathPlanner.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/PathPlanners/PathPlanner.cs" afterDir="false" />
      <change beforePath="$PROJECT_DIR$/ConsoleApp/Program.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/Program.cs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/ConsoleApp/SimRunner.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/SimRunner.cs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/ConsoleApp/UserConsole.cs" beforeDir="false" afterPath="$PROJECT_DIR$/ConsoleApp/UserConsole.cs" afterDir="false" />
    </list>
    <option name="SHOW_DIALOG" value="false" />
    <option name="HIGHLIGHT_CONFLICTS" value="true" />
    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
    <option name="LAST_RESOLUTION" value="IGNORE" />
  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="JSON File" />
+      </list>
+    </option>
+  </component>
  <component name="Git.Settings">
    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
  </component>
+  <component name="HighlightingSettingsPerFile">
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/0b/0953c23b/GraphFactory.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/f7/268fdeac/Graph.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/133/Thread.CoreCLR.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/7AFCB195-1BDF-4087-9F2D-5BFCFC407B2B/46/ThrowHelper.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/84/4eb9c798/GraphUtils.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/39B/EqualityComparer.CoreCLR.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/da/c3cabb46/AStarSearch.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/11/Array.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/3A4/List.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/7AFCB195-1BDF-4087-9F2D-5BFCFC407B2B/30/Where.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/CD/ThrowHelper.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/8B2EA1A3-95EB-49F7-AF97-CA55CE776F10/4/Container.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/389/Comparer.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/EB067793-5C3F-4219-AEF1-3AB117C20649/B5/Random.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/3d/c367b191/Coordinate3D.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/SourcesCache/1C5C65AB-6C84-402C-B333-F3A5A7121EFE/D/Queue.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="mock:///Dummy.cs" root0="SKIP_HIGHLIGHTING" />
+    <setting file="file://$APPLICATION_CONFIG_DIR$/resharper-host/DecompilerCache/decompiler/EE5CA5D4-EDEB-48AE-9C0D-FE354330FB77/14/12025305/MovementTypes.cs" root0="SKIP_HIGHLIGHTING" />
+  </component>
  <component name="IdeDocumentHistory">
-    <option name="CHANGED_PATHS">
-      <list>
-        <option value="$PROJECT_DIR$/Simulator/Program.cs" />
-        <option value="$PROJECT_DIR$/Simulator/CoreModule.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/IModule.cs" />
-        <option value="$PROJECT_DIR$/Simulator/SimulatorModule.cs" />
-        <option value="$PROJECT_DIR$/Simulator/NetworkInterfaceFactory.cs" />
-        <option value="$PROJECT_DIR$/Simulator/INetworkInterfaceFactory.cs" />
-        <option value="$PROJECT_DIR$/Simulator/NetworkInterface.cs" />
-        <option value="$PROJECT_DIR$/Simulator/Networking/NetworkInterfaceFactory.cs" />
-        <option value="$PROJECT_DIR$/Simulator/Networking/INetworkInterfaceFactory.cs" />
-        <option value="$PROJECT_DIR$/Simulator/Networking/INetworkInterface.cs" />
-        <option value="$PROJECT_DIR$/Simulator/Networking/NetworkInterface.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/IUserConsole.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Module.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/CoreModule.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/MapFactory.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/UserConsole.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/IMapFactory.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Bootstrapper.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/IMapFactory.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/ISimRunner.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/SimRunner.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Program.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/MapFactory.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/SquareMap.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/HexMap.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/IHexMap.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/ISquareMap.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/HexCell.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/IHexCell.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/SquareCell.cs" />
-        <option value="$PROJECT_DIR$/ConsoleApp/Maps/ISquareCell.cs" />
-      </list>
-    </option>
+    <changedPaths>
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/Heading.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/Direction.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/IPathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/PathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/GlobalDirection.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/HexCoordinates.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/IVehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/IMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Vehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Vehicle/DetectionHead.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Vehicle/Vehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Vehicle/VehicleConfiguration.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Vehicle/IVehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/PathPlanners/IPathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/ConsoleApp.csproj" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/CellExtensions.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Sim/IVehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/IHexMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/HexMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/MapFactory.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/IMapFactory.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Sim/VehicleConfiguration.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Sim/Vehicle.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/CoreModule.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/plot.py" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/MineMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/IMineMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/ICell.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/MapExtensions.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/PathPlanners/IReactivePathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/PathPlanners/ReactivePathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/AstarSquareSearch.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/Cell.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/SquareMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Maps/ISquareMap.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/ISimulationResults.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/SimulationResults.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Sim/DetectionHead.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/SimRunner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Sim/VehicleConfiguration.json" />
+      <option value="$PROJECT_DIR$/ConsoleApp/PathPlanners/PathPlanner.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/UserConsole.cs" />
+      <option value="$PROJECT_DIR$/ConsoleApp/HexPlot.py" />
+      <option value="$PROJECT_DIR$/ConsoleApp/Program.cs" />
+    </changedPaths>
  </component>
  <component name="ProjectId" id="1lIZ7IfsUjzqV2Jb1obOFvGFAfp" />
  <component name="ProjectLevelVcsManager" settingsEditedManually="true">
@@ -86,15 +146,20 @@
    <option name="showLibraryContents" value="true" />
  </component>
  <component name="PropertiesComponent">
+    <property name="DebuggerViewTab_PTCS_FirstProportionKey" value="0.22508793" />
+    <property name="DebuggerViewTab_PTCS_LastProportionKey" value="0.0" />
    <property name="RunOnceActivity.OpenProjectViewOnStart" value="true" />
    <property name="WebServerToolWindowFactoryState" value="false" />
+    <property name="nodejs_package_manager_path" value="npm" />
+    <property name="restartRequiresConfirmation" value="false" />
+    <property name="settings.editor.selected.configurable" value="configurable.group.build" />
    <property name="vue.rearranger.settings.migration" value="true" />
  </component>
  <component name="RunManager" selected=".NET Project.ConsoleApp">
    <configuration name="ConsoleApp" type="DotNetProject" factoryName=".NET Project">
-      <option name="EXE_PATH" value="" />
+      <option name="EXE_PATH" value="$PROJECT_DIR$/ConsoleApp/bin/Debug/netcoreapp3.1/ConsoleApp.dll" />
      <option name="PROGRAM_PARAMETERS" value="" />
-      <option name="WORKING_DIRECTORY" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$/ConsoleApp/bin/Debug/netcoreapp3.1" />
      <option name="PASS_PARENT_ENVS" value="1" />
      <option name="USE_EXTERNAL_CONSOLE" value="0" />
      <option name="USE_MONO" value="0" />
@@ -104,7 +169,7 @@
      <option name="PROJECT_ARGUMENTS_TRACKING" value="1" />
      <option name="PROJECT_WORKING_DIRECTORY_TRACKING" value="1" />
      <option name="PROJECT_KIND" value="DotNetCore" />
-      <option name="PROJECT_TFM" value="" />
+      <option name="PROJECT_TFM" value=".NETCoreApp,Version=v3.1" />
      <method v="2">
        <option name="Build" />
      </method>
@@ -127,6 +192,10 @@
        <option name="Build" />
      </method>
    </configuration>
+    <list>
+      <item itemvalue=".NET Project.ConsoleApp" />
+      <item itemvalue=".NET Project.Simulator" />
+    </list>
  </component>
  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
  <component name="TaskManager">
@@ -137,6 +206,15 @@
      <option name="presentableId" value="Default" />
      <updated>1607286398679</updated>
      <workItem from="1607286402206" duration="6845000" />
+      <workItem from="1607640133651" duration="318000" />
+      <workItem from="1607640470920" duration="58000" />
+      <workItem from="1607640550443" duration="19992000" />
+      <workItem from="1607982179018" duration="634000" />
+      <workItem from="1607983288378" duration="86000" />
+      <workItem from="1607983862958" duration="7777000" />
+      <workItem from="1607993290571" duration="88336000" />
+      <workItem from="1608146906461" duration="175000" />
+      <workItem from="1608147111263" duration="16256000" />
    </task>
    <servers />
  </component>
@@ -160,35 +238,11 @@
  <component name="VcsManagerConfiguration">
    <option name="CLEAR_INITIAL_COMMIT_MESSAGE" value="true" />
  </component>
-  <component name="WindowStateProjectService">
-    <state width="1158" height="582" key="GridCell.Tab.0.bottom" timestamp="1607636097456">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state width="1158" height="582" key="GridCell.Tab.0.bottom/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607636097456" />
-    <state width="1158" height="582" key="GridCell.Tab.0.center" timestamp="1607636097453">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state width="1158" height="582" key="GridCell.Tab.0.center/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607636097453" />
-    <state width="1158" height="582" key="GridCell.Tab.0.left" timestamp="1607636097452">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state width="1158" height="582" key="GridCell.Tab.0.left/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607636097452" />
-    <state width="1158" height="582" key="GridCell.Tab.0.right" timestamp="1607636097454">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state width="1158" height="582" key="GridCell.Tab.0.right/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607636097454" />
-    <state x="1640" y="-86" key="Rider.ProjectTemplateDialog.Size" timestamp="1607287214952">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state x="1640" y="-86" key="Rider.ProjectTemplateDialog.Size/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607286605974" />
-    <state x="1640" y="-86" key="Rider.ProjectTemplateDialog.Size/0.25.1440.798/2640.-757.1200.1895/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607287214952" />
-    <state x="1860" y="-144" key="RiderGenerateDialog" timestamp="1607636510472">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state x="1860" y="-144" key="RiderGenerateDialog/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607636510472" />
-    <state x="1703" y="-333" width="672" height="678" key="search.everywhere.popup" timestamp="1607633696072">
-      <screen x="1440" y="-782" width="1200" height="1920" />
-    </state>
-    <state x="1703" y="-333" width="672" height="678" key="search.everywhere.popup/0.0.1440.900/2640.-782.1200.1920/1440.-782.1200.1920@1440.-782.1200.1920" timestamp="1607633696072" />
+  <component name="XDebuggerManager">
+    <pin-to-top-manager>
+      <pinned-members>
+        <PinnedItemInfo parentTag="Frame#ConsoleApp.PathPlanners.PathPlanner.GenerateOptimalHexPath" memberName="path" />
+      </pinned-members>
+    </pin-to-top-manager>
  </component>
 </project>
--- a/ConsoleApp/.DS_Store
+++ b/ConsoleApp/.DS_Store
--- a/ConsoleApp/ConsoleApp.csproj
+++ b/ConsoleApp/ConsoleApp.csproj
@@ -5,8 +5,30 @@
        <TargetFramework>netcoreapp3.1</TargetFramework>
    </PropertyGroup>

+    <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+      <DebugType>full</DebugType>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+      <DebugType>full</DebugType>
+    </PropertyGroup>
+
    <ItemGroup>
      <PackageReference Include="DryIoc.dll" Version="4.5.2" />
+      <PackageReference Include="HexCore" Version="4.1.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+      <None Update="Sim\VehicleConfiguration.json">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+      <None Update="plotGraphs.py">
+        <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      </None>
+    </ItemGroup>
+
+    <ItemGroup>
+      <Folder Include="Output" />
    </ItemGroup>

 </Project>
--- a/ConsoleApp/CoreModule.cs
+++ b/ConsoleApp/CoreModule.cs
@@ -1,17 +1,24 @@
-using System.Threading;
-using ConsoleApp;
+using ConsoleApp.Maps;
+using ConsoleApp.PathPlanners;
+using ConsoleApp.Sim;
 using DryIoc;
-using Module = ConsoleApp.Module;

-namespace Final
+namespace ConsoleApp
 {
-    public class CoreModule : Module
+    public class CoreModule : IModule
    {
-        public virtual void Register(IContainer container, ExecutionContext executionContext)
+        public virtual void Register(IContainer container)
        {
-            //container.Register<IUserConsole, UserConsole>(Reuse.Singleton);
+            container.Register<IMapFactory, MapFactory>(Reuse.Singleton);
+            container.Register<ISimRunner, SimRunner>(Reuse.Singleton);
+            container.Register<IVehicle, Vehicle>(Reuse.Singleton);
+            container.Register<IJsonDeserializor, JsonDeserializor>(Reuse.Singleton);
+            container.Register<IPathPlanner, PathPlanner>(Reuse.Singleton);
+            container.Register<IReactivePathPlanner, ReactivePathPlanner>(Reuse.Singleton);
+            container.Register<ISimulationResults, SimulationResults>(Reuse.Singleton);
        }
        
+
        public virtual void Resolve(IContainer container)
        {
            
--- a/ConsoleApp/IJsonDeserializor.cs
+++ b/ConsoleApp/IJsonDeserializor.cs
@@ -0,0 +1,7 @@
+namespace ConsoleApp
+{
+    public interface IJsonDeserializor
+    {
+        T DeserializeObject<T>(string filePath);
+    }
+}
--- a/ConsoleApp/ISimulationResults.cs
+++ b/ConsoleApp/ISimulationResults.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp
+{
+    public interface ISimulationResults
+    {
+        void WriteResults();
+        int HexTotalMoves { get; set; }
+        int HexBombsFound { get; set; }
+        int TotalBombs { get; set; }
+        List<Coordinate2D> HexPath { get; set; }
+        List<Coordinate2D> HexMappedBombs { get; set; }
+        List<Cell> Mines { get; set; }
+        int HexClearedCells { get; set; }
+        int HexUnClearedCells { get; set; }
+        List<ICell> SquarePath { get; set; }
+        List<ICell> SquareMappedBombs { get; set; }
+        int SquareCellsUncleared { get; set; }
+        int SquareCellsCleared { get; set; }
+        int SquareBombsFound { get; set; }
+        int SquareTotalMoves { get; set; }
+        List<ICell> SquareCoveredCells { get; set; }
+        List<Coordinate2D> HexCoveredCells { get; set; }
+    }
+}
--- a/ConsoleApp/JsonDeserializor.cs
+++ b/ConsoleApp/JsonDeserializor.cs
@@ -0,0 +1,15 @@
+using System;
+using System.IO;
+using System.Text.Json;
+
+namespace ConsoleApp
+{
+    public class JsonDeserializor : IJsonDeserializor
+    {
+        public T DeserializeObject<T>(string filePath)
+        {
+            var jString = File.ReadAllText(filePath);
+            return JsonSerializer.Deserialize<T>(jString);
+        }
+    }
+}
--- a/ConsoleApp/Maps/AstarSquareSearch.cs
+++ b/ConsoleApp/Maps/AstarSquareSearch.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using HexCore;
+
+namespace ConsoleApp.Maps
+{
+    public class AstarSquareSearch
+    {
+        private static double Heuristic(ICell a, ICell b)
+        {
+            return Math.Abs(a.X - b.X) + Math.Abs(a.Y - b.Y);
+        }
+
+        public static List<ICell> FindShortestPath(ISquareMap graph, ICell start, ICell goal)
+        {
+            var costSoFar = new Dictionary<ICell, int>();
+            var cameFrom = new Dictionary<ICell, ICell>();
+            var frontier = new PriorityQueue<ICell>();
+
+            frontier.Enqueue(start, 0);
+            cameFrom[start] = start;
+            costSoFar[start] = 0;
+
+            while (frontier.Count > 0)
+            {
+                var current = frontier.Dequeue();
+
+                if (current.Equals(goal)) break;
+
+                foreach (var next in graph.GetPassableNeighbors(current))
+                {
+                    var newCost = costSoFar[current] + (int)graph.GetCell(next.X, next.Y).Coverage;
+                    if (costSoFar.ContainsKey(next) && newCost >= costSoFar[next]) continue;
+                    costSoFar[next] = newCost;
+                    var priority = newCost + Heuristic(next, goal);
+                    frontier.Enqueue(next, priority);
+                    cameFrom[next] = current;
+                }
+            }
+
+            var path = new List<ICell>();
+            var pathWasNotFound = !cameFrom.ContainsKey(goal);
+
+            // Returning an empty list if the path wasn't found
+            if (pathWasNotFound) return path;
+
+            // Reconstructing path
+            var curr = goal;
+            while (!curr.Equals(start))
+            {
+                path.Add(curr);
+                curr = cameFrom[curr];
+            }
+
+            // Reverse it to start at actual start point
+            path.Reverse();
+            return path;
+        }
+    }
+}
--- a/ConsoleApp/Maps/Cell.cs
+++ b/ConsoleApp/Maps/Cell.cs
@@ -0,0 +1,28 @@
+using System;
+
+namespace ConsoleApp.Maps
+{
+    public enum Coverage
+    {
+        //Order here matters these are cast to ints for the heuristic algorithm
+        Uncovered,
+        Covered
+    }
+    public class Cell : ICell
+    {
+        public int X { get; }
+        public int Y { get; }
+        public Coverage Coverage { get; set; }
+        public bool Blocked { get; set; }
+        
+        public Cell(int x, int y)
+        {
+            X = x;
+            Y = y;
+            Coverage = Coverage.Uncovered;
+            Blocked = false;
+        }
+
+        
+    }
+}
--- a/ConsoleApp/Maps/Direction.cs
+++ b/ConsoleApp/Maps/Direction.cs
@@ -1,7 +0,0 @@
-namespace ConsoleApp.Maps
-{
-    public enum Direction
-    {
-        Forward, Reverse
-    }
-}
--- a/ConsoleApp/Maps/GlobalDirection.cs
+++ b/ConsoleApp/Maps/GlobalDirection.cs
@@ -0,0 +1,14 @@
+namespace ConsoleApp.Maps
+{
+    public enum GlobalDirection
+    {
+        North,
+        South,
+        East,
+        West,
+        NorthEast,
+        SouthEast,
+        NorthWest,
+        SouthWest
+    }
+}
--- a/ConsoleApp/Maps/Heading.cs
+++ b/ConsoleApp/Maps/Heading.cs
@@ -0,0 +1,50 @@
+namespace ConsoleApp.Maps
+{
+    public class Oreientation
+    {
+        public static (int, int) Forward = (0, 1);
+        public static (int, int) Backward = (0, -1);
+        public static (int, int) Left = (-1, 0);
+        public static (int, int) Right = (1, 0);
+        public static (int, int) LeftBack = (-1, -1);
+        public static (int, int) LeftForward = (-1, 1);
+        public static (int, int) RightBack = (1, -1);
+        public static (int, int) RightForward = (1, 1);
+    }
+    public class Heading
+    {
+        private (int, int) _currentHeading;
+        public (int, int) CurrentHeading { get; }
+
+        
+        public void SetHeading((int,int)frontAxel, (int,int)backAxel)
+        {
+            var x = frontAxel.Item1 - backAxel.Item1;
+            var y = frontAxel.Item2 - backAxel.Item2;
+            //forward
+            if (x == 0 && y >= 1) _currentHeading = Oreientation.Forward;
+            //backward
+            if (x == 0 && y <= -1) _currentHeading = Oreientation.Backward;
+            //right
+            if (x >= 1 && y == 0) _currentHeading = Oreientation.Right;
+            //left
+            if (x <= -1 && y == 0) _currentHeading = Oreientation.Left;
+            //left, back
+            if (x <= -1 && y <= -1) _currentHeading = Oreientation.LeftBack;
+            //right, forward
+            if (x >= 1 && y >= 1) _currentHeading = Oreientation.RightForward;
+            //left, forward
+            if (x <= -1 && y >= 1) _currentHeading = Oreientation.LeftForward;
+            //right, back
+            if (x >= 1 && y <= -1) _currentHeading = Oreientation.RightBack;
+
+        }
+        public Heading()
+        {
+            _currentHeading = Oreientation.Forward;
+            CurrentHeading = _currentHeading;
+        }
+
+
+    }
+}
--- a/ConsoleApp/Maps/HexCell.cs
+++ b/ConsoleApp/Maps/HexCell.cs
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace ConsoleApp.Maps
-{
-    public struct HexCell
-    {
-        public int Q { get; }
-        public int R { get; }
-        public int S { get; }
-        public HexCell(int q, int r, int s)
-        {
-            if (q + r + s != 0) throw new ArgumentException("q + r + s must be 0");
-            Q = q;
-            R = r;
-            S = s;
-        }
-  
-    }
-}
--- a/ConsoleApp/Maps/HexMap.cs
+++ b/ConsoleApp/Maps/HexMap.cs
@@ -1,25 +1,58 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
+using HexCore;
+using ImTools;

 namespace ConsoleApp.Maps
 {
-    public class HexMap
+    public class HexMap : IHexMap
    {
-        private HexCell[,] Map { get; }

+        public int Width { get; }
+
+        public int Height { get; }
+
+        public Graph Graph { get; }
+        
+        public OffsetTypes OffsetType { get; }
+        public MovementType DefaultMovement { get; }
+        public TerrainType ClearedTerrain { get; }
+
+        public TerrainType UnclearedTerrain { get; }
+
+
+        /// <summary>
+        /// Generate Hex map with cells of 25cm X 25cm
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
        public HexMap(int x, int y)
        {
-            for (int r = 0; r < y; r++) {
-                int r_offset = Convert.ToInt32(Math.Floor(Convert.ToDouble(r)/2));
-                for (int q = -r_offset; q < x - r_offset; q++) {
-                    Map[r, q] = new HexCell(q, r, -q-r);
+            //Set Offset Type for 2d -> 3d conversion
+            OffsetType = OffsetTypes.OddRowsRight;
+
+            Height = y;
+            Width = x;
+            
+            UnclearedTerrain = new TerrainType(1, "uncleared");
+            ClearedTerrain = new TerrainType(2, "cleared");
+            
+            DefaultMovement = new MovementType(1, "default");
+            var movementTypes = new MovementTypes(
+                new ITerrainType[] { UnclearedTerrain, ClearedTerrain }, 
+                new Dictionary<IMovementType, Dictionary<ITerrainType, int>>
+                {
+                    [DefaultMovement] = new Dictionary<ITerrainType, int>
+                    {
+                        [UnclearedTerrain] = 1,
+                        [ClearedTerrain] = 2
+                    }
                }
-            }
+            );
+            Graph = GraphFactory.CreateRectangularGraph(Width, Height, movementTypes, UnclearedTerrain);
        }

-        public List<HexCell> PossibleMoves(HexCell fromCell, Direction direction, Double orientation)
-        {

-        }
    }
 }
--- a/ConsoleApp/Maps/ICell.cs
+++ b/ConsoleApp/Maps/ICell.cs
@@ -0,0 +1,10 @@
+namespace ConsoleApp.Maps
+{
+    public interface ICell
+    {
+        int X { get; }
+        int Y { get; }
+        Coverage Coverage { get; set; }
+        bool Blocked { get; set; }
+    }
+}
--- a/ConsoleApp/Maps/IHexCell.cs
+++ b/ConsoleApp/Maps/IHexCell.cs
@@ -1,7 +0,0 @@
-namespace ConsoleApp.Maps
-{
-    public interface IHexCell
-    {
-        
-    }
-}
--- a/ConsoleApp/Maps/IHexMap.cs
+++ b/ConsoleApp/Maps/IHexMap.cs
@@ -1,7 +1,15 @@
+using HexCore;
+
 namespace ConsoleApp.Maps
 {
    public interface IHexMap
    {
-        
+        Graph Graph { get; }
+        OffsetTypes OffsetType { get; }
+        int Width { get; }
+        int Height { get; }
+        MovementType DefaultMovement { get; }
+        public TerrainType ClearedTerrain { get; }
+        public TerrainType UnclearedTerrain { get; }
    }
 }
--- a/ConsoleApp/Maps/IMapFactory.cs
+++ b/ConsoleApp/Maps/IMapFactory.cs
@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Dynamic;

 namespace ConsoleApp.Maps
@@ -6,7 +7,9 @@ namespace ConsoleApp.Maps
    {
        int Height { get; }
        int Width { get; }
-        SquareMap SquareMap { get; }
-        void GenerateMaps(int x, int y);
+        void GenerateMaps(int x, int y, double minePercentage);
+        IHexMap GetHexMap();
+        ISquareMap GetSquareMap();
+        IMineMap GetMineMap();
    }
 }
--- a/ConsoleApp/Maps/IMineMap.cs
+++ b/ConsoleApp/Maps/IMineMap.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace ConsoleApp.Maps
+{
+    public interface IMineMap
+    {
+        bool[,] Map { get; }
+        
+        int TotalBombs { get; }
+        bool GetCell(int x, int y);
+        List<Cell> PlacedMines { get; }
+    }
+}
--- a/ConsoleApp/Maps/ISquareCell.cs
+++ b/ConsoleApp/Maps/ISquareCell.cs
@@ -1,7 +0,0 @@
-namespace ConsoleApp.Maps
-{
-    public interface ISquareCell
-    {
-        
-    }
-}
--- a/ConsoleApp/Maps/ISquareMap.cs
+++ b/ConsoleApp/Maps/ISquareMap.cs
@@ -1,7 +1,20 @@
+using System.Collections.Generic;
+using HexCore;
+
 namespace ConsoleApp.Maps
 {
    public interface ISquareMap
    {
-        
+        Cell[,] Map { get; }
+        Cell StartingCell { get; }
+        Cell LastCell { get; }
+        List<GlobalDirection> PossibleMoves(ICell currentCell);
+        Cell GetCell(int x, int y);
+        int Height { get; }
+        int Width { get; }
+        List<Cell> GetRange(ICell centerCell, int radius);
+        List<Cell> GetNeighbors(ICell cell);
+        List<ICell> GetPassableNeighbors(ICell cell);
+        List<ICell> GetShortestPath(ICell start, ICell goal);
    }
 }
--- a/ConsoleApp/Maps/MapExtensions.cs
+++ b/ConsoleApp/Maps/MapExtensions.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using Example;
+
+namespace ConsoleApp.Maps
+{
+
+    public static class MapExtensions
+    {
+        public static void Fill2DArray<T>(this T[,] arr, T value)
+        {
+            int numRows = arr.GetLength(0);
+            int numCols = arr.GetLength(1);
+
+            for (int i = 0; i < numRows; ++i)
+            {
+                for (int j = 0; j < numCols; ++j)
+                {
+                    arr[i, j] = value;
+                }
+            }
+        }
+    }
+}
--- a/ConsoleApp/Maps/MapFactory.cs
+++ b/ConsoleApp/Maps/MapFactory.cs
@@ -1,3 +1,7 @@
+using System;
+using System.Collections.Generic;
+using ConsoleApp.Sim;
+
 namespace ConsoleApp.Maps
 {
    public class MapFactory : IMapFactory
@@ -6,23 +10,41 @@ namespace ConsoleApp.Maps
        private int _defaultWidth;
        public int Height { get; protected set; }
        public int Width { get; protected set; }
-        public SquareMap SquareMap { get; }
-        public HexMap HexMap { get; }
        

-        public void GenerateMaps(int x, int y)
+        
+        private ISquareMap _squareMap;
+
+        private IHexMap _hexMap;
+        
+        private IMineMap _mineMap;
+
+        public void GenerateMaps(int x, int y, double minePercentage)
        {
-            Width = x;
-            Height = y;
-            throw new System.NotImplementedException();
+            //convert to cm
+            x *= 100;
+            y *= 100;
+            //calculate number of cells on x and y axis
+            var xCellCount = (int)Math.Ceiling((decimal) (x) / 25);
+            var yCellCount = (int)Math.Ceiling((decimal) (y) / 25);
+            Width = xCellCount;
+            Height = yCellCount;
+            _squareMap = new SquareMap(xCellCount, yCellCount);
+            _hexMap = new HexMap(xCellCount, yCellCount);
+            _mineMap = new MineMap(xCellCount, yCellCount, minePercentage);
        }
+        public IHexMap GetHexMap() => _hexMap ?? throw new NullReferenceException("hex map not initialized");
+        public ISquareMap GetSquareMap() => _squareMap ?? throw new NullReferenceException("square map not initialized");
+        public IMineMap GetMineMap() => _mineMap ?? throw new NullReferenceException("mine map not initialized");

-        public MapFactory()
+        public MapFactory(IVehicle vehicle)
        {
            _defaultHeight = 0;
            _defaultWidth = 0;
            Height = _defaultHeight;
            Width = _defaultWidth;
+            _hexMap = default;
+            _squareMap = default;
        }
        
    }
--- a/ConsoleApp/Maps/MineMap.cs
+++ b/ConsoleApp/Maps/MineMap.cs
@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using HexCore;
+
+namespace ConsoleApp.Maps
+{
+    public class MineMap : IMineMap
+    {
+        private int _mineCount;
+        private int _x;
+        private int _y;
+        public bool[,] Map { get; }
+        public int TotalBombs { get; }
+        public List<Cell> PlacedMines { get; }
+
+        public MineMap(int x, int y, double minePercentage)
+        {
+            _x = x;
+            _y = y;
+            PlacedMines = new List<Cell>();
+            _mineCount = (int)(x*y*(minePercentage/100));
+            TotalBombs = _mineCount;
+            Map = new bool[x, y];
+            Map.Fill2DArray(false);
+            PlaceMines();
+            
+        }
+        public bool GetCell(int x, int y) => Map[x,y];
+
+
+        private void PlaceMines()
+        {
+            var rand = new Random();
+            for (var i = 0; i < _mineCount; i++) 
+            {
+                var x = rand.Next(5,_x-5);
+                var y = rand.Next(5,_y-5);
+                if (Map[x, y] == true)
+                {
+                    i--;
+                }
+                else
+                {
+                    Map[x, y] = true;
+                    PlacedMines.Add(new Cell(x,y));
+                }
+            }
+        }
+    }
+}
--- a/ConsoleApp/Maps/SquareCell.cs
+++ b/ConsoleApp/Maps/SquareCell.cs
@@ -1,7 +0,0 @@
-namespace ConsoleApp.Maps
-{
-    public class SquareCell
-    {
-        
-    }
-}
--- a/ConsoleApp/Maps/SquareMap.cs
+++ b/ConsoleApp/Maps/SquareMap.cs
@@ -1,7 +1,148 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection.Metadata.Ecma335;
+using System.Threading;
+using HexCore;
+
+
 namespace ConsoleApp.Maps
 {
-    public class SquareMap
+    public class SquareMap : ISquareMap
    {
+        public Cell[,] Map { get;}
+        public Cell StartingCell { get; }
+        public Cell LastCell { get; }
+        public int Height { get; }
+        public int Width { get; }
+
+        /// <summary>
+        /// Returns a map with square cells
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        public SquareMap(int x, int y)
+        {
+  
+            
+            //set Width and height Properties
+            Width = x-1;
+            Height = y-1;
+
+            
+            //Initialize Map
+            Map = new Cell[x, y];
+
+            
+            for (int i = 0; i < x; i++)
+            {
+                for (int j = 0; j < y; j++)
+                {
+                    Map[i,j] = new Cell(i, j);
+                }
+            }
+            
+            //set Starting cell;
+            StartingCell = GetCell(0,0);
+        }
+
+
+        public List<GlobalDirection> PossibleMoves(ICell currentCell)
+        {
+            
+            var possibles = new List<GlobalDirection>();
+            if (currentCell.X != 0)
+                possibles.Add(GlobalDirection.West);
+            if (currentCell.X != Width)
+                possibles.Add(GlobalDirection.East);
+            if (currentCell.Y != Height)
+                possibles.Add(GlobalDirection.North);
+            if (currentCell.Y != 0)
+                possibles.Add(GlobalDirection.South);
+
+            return possibles;
+        }
+        
+        public List<ICell> GetShortestPath(ICell start, ICell goal)
+        {
+            return AstarSquareSearch.FindShortestPath(this, start, goal);
+        }
+
+        public List<Cell> GetRange(ICell centerCell, int radius)
+        {
+            var inRange = new List<Cell>();
+            var cx = centerCell.X;
+            var cy = centerCell.Y;
+            var topLeft = GetTopCellInBoundingBox(cx, cy, radius);
+            var bottomRight = GetBottomCellInBoundingBox(cx, cy, radius);
+            for (var i = topLeft.X; i < bottomRight.X; i++)
+            {
+                for (var j = bottomRight.Y; j < topLeft.Y; j++)
+                {
+                    if (Math.Pow(i - cx, 2) + Math.Pow(j - cy, 2) < Math.Pow(radius,2))
+                    {
+                        inRange.Add(Map[i,j]);
+                    }
+                }
+            }
+            return inRange;
+        }
+
+        public List<ICell> GetPassableNeighbors(ICell cell) => 
+            GetNeighbors(cell).Where(neighbor => !neighbor.Blocked).Cast<ICell>().ToList();
+        
+        
+        private static int ComputeHScore(ICell src, Cell dest)
+        {
+            return Math.Abs(dest.X - src.X) + Math.Abs(dest.Y - src.Y);
+        }
+        
+
+        public List<Cell> GetNeighbors(ICell cell)
+        {
+            var rlist = new List<Cell>();
+            var rowOperations = new int[] { -1, 0, 0, 1};
+            var colOperations = new int[] {0, -1, 1, 0};
+            for (var i = 0; i < 4; i++)
+            {
+                var curCell = GetCell(cell.X + rowOperations[i], cell.Y + colOperations[i]);
+                if (curCell != default)
+                {
+                    rlist.Add(curCell);
+                }
+            }
+            return rlist;
+        }
+
+        private Cell GetTopCellInBoundingBox(int cx, int cy, int radius)
+        {
+            int topX, topY;
+            if (cy + radius > Height) topY = Height;
+            else
+                topY = cy + radius;
+            if (cx - radius < 0) topX = 0;
+            else
+                topX = cx - radius;
+            return Map[topX, topY];
+        }
+        private Cell GetBottomCellInBoundingBox(int cx, int cy, int radius)
+        {
+            int bottomX, bottomY;
+            if (cy - radius < 0) bottomY = 0;
+            else
+                bottomY = cy - radius;
+            if (cx + radius > Width) bottomX = Width;
+            else
+                bottomX = cx + radius;
+            return Map[bottomX, bottomY];
+        }
+
+        public Cell GetCell(int x, int y)
+        {
+            if (x > Width || y > Height || x < 0 || y < 0)
+                return default;
+            return Map[x, y];
+        }

    }
 }
--- a/ConsoleApp/Module.cs
+++ b/ConsoleApp/Module.cs
@@ -1,21 +0,0 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Linq;
-using System.Collections.Generic;
-
-using DryIoc;
-
-namespace ConsoleApp
-{
-    public abstract class Module : IModule
-    {
-        public virtual void Register(IContainer container)
-        {
-        }
-
-        public virtual void Resolve(IContainer container)
-        {
-        }
-    }
-}
--- a/ConsoleApp/Output
+++ b/ConsoleApp/Output
--- a/ConsoleApp/Output.zip
+++ b/ConsoleApp/Output.zip
--- a/ConsoleApp/Output/Data.txt
+++ b/ConsoleApp/Output/Data.txt
@@ -0,0 +1,14 @@
+General:
+	 Total Mines: 36
+Hex: 
+	 Total Moves: 687
+	 Bombs Found: 35
+	 Cleared Cell Count: 3591
+	 Uncleared Cell Count: 9
+	 Percentage Cleared: 99.75
+Square: 
+	 Total Moves: 1045
+	 Bombs Found: 34
+	 Cleared Cell Count: 3251
+	 Uncleared Cell Count: 349
+	 Percentage Cleared: 90.30555555555554
--- a/ConsoleApp/Output/HexCoverage.png
+++ b/ConsoleApp/Output/HexCoverage.png
--- a/ConsoleApp/Output/HexCoveredCells.txt
+++ b/ConsoleApp/Output/HexCoveredCells.txt
--- a/ConsoleApp/Output/HexDetectedMines.txt
+++ b/ConsoleApp/Output/HexDetectedMines.txt
@@ -0,0 +1,35 @@
+48 7
+47 13
+35 8
+12 8
+5 18
+31 14
+28 20
+36 14
+37 12
+42 18
+49 16
+45 23
+42 23
+49 27
+42 29
+6 22
+10 28
+9 31
+19 27
+54 29
+16 39
+10 34
+26 40
+33 42
+50 42
+52 53
+45 48
+38 48
+36 51
+34 51
+29 54
+30 50
+27 54
+26 49
+12 49
--- a/ConsoleApp/Output/HexPath.txt
+++ b/ConsoleApp/Output/HexPath.txt
@@ -0,0 +1,687 @@
+0 0
+1 0
+2 0
+3 0
+4 0
+5 0
+6 0
+7 0
+8 0
+9 0
+10 0
+11 0
+12 0
+13 0
+14 0
+15 0
+16 0
+17 0
+18 0
+19 0
+20 0
+21 0
+22 0
+23 0
+24 0
+25 0
+26 0
+27 0
+28 0
+29 0
+30 0
+31 0
+32 0
+33 0
+34 0
+35 0
+36 0
+37 0
+38 0
+39 0
+40 0
+41 0
+42 0
+43 0
+44 0
+45 0
+46 0
+47 0
+48 0
+49 0
+50 0
+51 0
+52 0
+53 0
+54 0
+55 0
+56 0
+57 0
+58 0
+59 0
+59 1
+59 2
+59 3
+59 4
+59 5
+59 6
+59 7
+58 7
+57 7
+56 7
+55 7
+54 7
+53 7
+52 7
+51 7
+51 7
+51 7
+51 8
+50 9
+50 10
+49 10
+48 10
+47 10
+46 9
+46 8
+45 7
+44 7
+43 7
+42 7
+41 7
+40 7
+39 7
+38 7
+37 7
+37 7
+37 6
+36 5
+35 5
+34 5
+33 5
+33 6
+32 7
+31 7
+30 7
+29 7
+28 7
+27 7
+26 7
+25 7
+24 7
+23 7
+22 7
+21 7
+20 7
+19 7
+18 7
+17 7
+16 7
+15 7
+14 7
+14 7
+14 6
+13 5
+12 5
+11 5
+10 5
+10 6
+9 7
+8 7
+7 7
+6 7
+5 7
+4 7
+3 7
+2 7
+1 7
+0 7
+1 8
+1 9
+2 10
+1 11
+1 12
+0 13
+0 14
+1 14
+2 14
+3 14
+4 14
+5 14
+6 14
+7 14
+8 14
+9 14
+10 14
+11 14
+12 14
+13 14
+14 14
+15 14
+16 14
+17 14
+18 14
+19 14
+20 14
+21 14
+22 14
+23 14
+24 14
+25 14
+26 14
+27 14
+28 14
+28 14
+28 14
+28 15
+29 16
+29 17
+30 17
+31 17
+32 17
+33 17
+33 17
+34 17
+35 17
+36 17
+37 17
+38 16
+38 15
+39 14
+40 14
+41 14
+42 14
+43 14
+44 14
+45 14
+45 14
+45 15
+46 16
+46 17
+47 18
+47 19
+48 19
+49 19
+50 19
+51 18
+51 17
+52 16
+51 15
+52 14
+53 14
+54 14
+55 14
+56 14
+57 14
+58 14
+59 14
+59 15
+59 16
+59 17
+59 18
+59 19
+59 20
+59 21
+58 21
+57 21
+56 21
+55 21
+54 21
+53 21
+52 21
+51 21
+50 21
+49 21
+48 21
+47 21
+47 21
+47 20
+46 20
+45 20
+46 20
+47 20
+47 21
+48 22
+48 23
+48 24
+47 25
+47 26
+46 26
+45 26
+44 26
+43 26
+42 26
+41 26
+40 25
+40 24
+39 23
+39 22
+38 21
+37 21
+36 21
+35 21
+34 21
+33 21
+32 21
+31 21
+30 21
+30 21
+30 22
+29 23
+28 23
+27 23
+26 23
+26 22
+25 21
+24 21
+23 21
+22 21
+21 21
+20 21
+19 21
+18 21
+17 21
+16 21
+15 21
+14 21
+13 21
+12 21
+11 21
+10 21
+9 21
+8 21
+8 21
+9 22
+8 23
+8 24
+7 25
+6 25
+5 25
+4 25
+4 24
+3 23
+3 22
+2 21
+1 21
+0 21
+1 22
+1 23
+2 24
+1 25
+1 26
+0 27
+0 28
+1 28
+2 28
+3 28
+4 28
+5 28
+6 28
+7 28
+7 28
+7 27
+8 26
+8 25
+9 25
+10 25
+11 25
+12 26
+12 27
+13 28
+14 28
+15 28
+16 28
+17 28
+17 28
+17 29
+18 30
+19 30
+20 30
+21 30
+21 29
+22 28
+23 28
+24 28
+25 28
+26 28
+27 28
+28 28
+29 28
+30 28
+31 28
+32 28
+33 28
+34 28
+35 28
+36 28
+37 28
+38 28
+39 28
+40 28
+40 28
+40 27
+41 26
+42 26
+43 26
+44 26
+44 27
+45 28
+46 28
+47 28
+47 28
+47 29
+48 30
+49 30
+50 30
+51 30
+51 29
+52 28
+52 27
+53 26
+54 26
+55 26
+56 26
+56 27
+57 28
+58 28
+59 28
+59 29
+59 30
+59 31
+59 32
+59 33
+59 34
+59 35
+58 35
+57 35
+56 35
+55 35
+54 35
+53 35
+52 35
+51 35
+50 35
+49 35
+48 35
+47 35
+46 35
+45 35
+44 35
+43 35
+42 35
+41 35
+40 35
+39 35
+38 35
+37 35
+36 35
+35 35
+34 35
+33 35
+32 35
+31 35
+30 35
+29 35
+28 35
+27 35
+26 35
+25 35
+24 35
+23 35
+22 35
+21 35
+20 35
+19 35
+18 35
+17 35
+16 35
+15 35
+14 35
+13 35
+12 35
+12 35
+12 36
+11 37
+10 37
+9 37
+8 37
+8 36
+7 35
+6 35
+5 35
+4 35
+3 35
+2 35
+1 35
+0 35
+1 36
+1 37
+2 38
+1 39
+1 40
+0 41
+0 42
+1 42
+2 42
+3 42
+4 42
+5 42
+6 42
+7 42
+8 42
+9 42
+10 42
+11 42
+12 42
+13 42
+14 42
+15 42
+16 42
+17 42
+18 42
+19 42
+20 42
+21 42
+22 42
+23 42
+24 42
+24 42
+24 43
+25 43
+26 43
+27 43
+28 42
+29 42
+30 42
+30 42
+30 42
+30 43
+31 44
+31 45
+32 45
+33 45
+34 45
+35 44
+35 43
+36 42
+37 42
+38 42
+39 42
+40 42
+41 42
+42 42
+43 42
+44 42
+45 42
+46 42
+47 42
+47 42
+47 42
+47 43
+48 44
+48 45
+49 45
+50 45
+51 45
+52 44
+52 43
+53 42
+54 42
+55 42
+56 42
+57 42
+58 42
+59 42
+59 43
+59 44
+59 45
+59 46
+59 47
+59 48
+59 49
+58 49
+57 49
+56 49
+55 49
+54 49
+53 49
+52 49
+51 49
+50 49
+49 49
+48 49
+47 49
+47 49
+47 50
+46 51
+45 51
+44 51
+43 51
+43 50
+42 49
+41 49
+40 49
+40 49
+40 50
+39 51
+39 52
+38 53
+38 54
+37 54
+36 54
+35 54
+34 54
+33 54
+32 53
+32 54
+31 55
+31 56
+30 57
+29 57
+28 57
+27 57
+26 57
+25 57
+25 56
+24 55
+24 54
+24 53
+24 52
+23 51
+23 50
+23 49
+22 49
+21 49
+20 49
+19 49
+18 49
+17 49
+16 49
+15 49
+15 49
+15 49
+15 50
+14 51
+14 52
+13 52
+12 52
+11 52
+10 51
+10 50
+9 49
+8 49
+7 49
+6 49
+5 49
+4 49
+3 49
+2 49
+1 49
+0 49
+1 50
+1 51
+2 52
+1 53
+1 54
+0 55
+0 56
+1 56
+2 56
+3 56
+4 56
+5 56
+6 56
+7 56
+8 56
+9 56
+10 56
+11 56
+12 56
+13 56
+14 56
+15 56
+16 56
+17 56
+18 56
+19 56
+20 56
+21 56
+22 56
+23 56
+24 56
+25 56
+25 56
+25 57
+26 57
+27 57
+28 57
+29 57
+30 57
+31 56
+32 56
+33 56
+34 56
+35 56
+36 56
+37 56
+38 56
+39 56
+40 56
+41 56
+42 56
+43 56
+44 56
+45 56
+46 56
+47 56
+48 56
+49 56
+50 56
+51 56
+52 56
+53 56
+54 56
+55 56
+56 56
+57 56
+58 56
+59 56
--- a/ConsoleApp/Output/HexTest.png
+++ b/ConsoleApp/Output/HexTest.png
--- a/ConsoleApp/Output/Mines.txt
+++ b/ConsoleApp/Output/Mines.txt
@@ -0,0 +1,36 @@
+30 50
+48 7
+16 39
+42 18
+47 13
+50 42
+52 53
+49 16
+36 14
+54 29
+6 22
+26 49
+28 20
+10 34
+27 54
+49 27
+35 8
+26 40
+38 48
+10 28
+12 8
+5 18
+42 23
+45 23
+42 29
+36 51
+37 12
+29 54
+34 51
+33 12
+45 48
+19 27
+12 49
+31 14
+33 42
+9 31
--- a/ConsoleApp/Output/SquareCoverage.png
+++ b/ConsoleApp/Output/SquareCoverage.png
--- a/ConsoleApp/Output/SquareCoveredCells.txt
+++ b/ConsoleApp/Output/SquareCoveredCells.txt
--- a/ConsoleApp/Output/SquareDetectedMines.txt
+++ b/ConsoleApp/Output/SquareDetectedMines.txt
@@ -0,0 +1,34 @@
+48 7
+47 13
+49 16
+35 8
+12 8
+31 14
+28 20
+36 14
+42 18
+42 23
+42 29
+49 27
+54 29
+45 23
+6 22
+5 18
+9 31
+10 28
+10 34
+16 39
+19 27
+26 40
+33 42
+38 48
+34 51
+36 51
+30 50
+26 49
+27 54
+29 54
+45 48
+52 53
+50 42
+12 49
--- a/ConsoleApp/Output/SquarePath.txt
+++ b/ConsoleApp/Output/SquarePath.txt
--- a/ConsoleApp/Output/SquareTest.png
+++ b/ConsoleApp/Output/SquareTest.png
--- a/ConsoleApp/PathPlanners/IPathPlanner.cs
+++ b/ConsoleApp/PathPlanners/IPathPlanner.cs
@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+using ConsoleApp.Sim;
+using HexCore;
+
+namespace ConsoleApp.PathPlanners
+{
+    public interface IPathPlanner
+    {
+        Queue<ICell> GenerateOptimalSquarePath(ISquareMap map, IVehicle vehicle);
+        Queue<Coordinate2D> GenerateOptimalHexPath(IHexMap hexMap, IVehicle vehicle);
+    }
+    
+}
--- a/ConsoleApp/PathPlanners/IReactivePathPlanner.cs
+++ b/ConsoleApp/PathPlanners/IReactivePathPlanner.cs
@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp.PathPlanners
+{
+    public interface IReactivePathPlanner
+    {
+        Queue<Coordinate2D> ReactiveHexPath { get; }
+        void GenerateReactiveHexPath(IHexMap hexMap, Queue<Coordinate2D> optimalPath, Coordinate2D vehicleCurrentHexCell);
+        
+        Queue<ICell> ReactiveSquarePath { get; }
+
+        void GenerateReactiveSquarePath(ISquareMap squareMap, Queue<ICell> optimalPath,
+            ICell vehicleCurrentSquareCell);
+    }
+}
--- a/ConsoleApp/PathPlanners/PathPlanner.cs
+++ b/ConsoleApp/PathPlanners/PathPlanner.cs
@@ -0,0 +1,122 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ConsoleApp.Maps;
+using ConsoleApp.Sim;
+using HexCore;
+
+namespace ConsoleApp.PathPlanners
+{
+    public class PathPlanner : IPathPlanner
+    {
+        public Queue<ICell> GenerateOptimalSquarePath(ISquareMap map, IVehicle vehicle)
+        {
+            var currentPostion = vehicle.CurrentSquareCell;
+            var currentHeading = GlobalDirection.East;
+            var finished = false;
+            var path = new List<ICell>();
+            while (!finished)
+            {
+                //Heading East
+                if (currentHeading == GlobalDirection.East)
+                {
+                    path.AddRange(
+                        map.GetShortestPath(currentPostion, map.GetCell(map.Width - 1, currentPostion.Y)));
+                    currentPostion = new Cell(map.Width - 1, currentPostion.Y);
+                }
+                //Heading West
+                else if (currentHeading == GlobalDirection.West)
+                {
+                    path.AddRange(
+                        map.GetShortestPath(currentPostion, map.GetCell(0, currentPostion.Y)));
+                    currentPostion = new Cell(0, currentPostion.Y);
+                }
+                //Check for finish
+                if (currentPostion.Y + (vehicle.DetectorRadius * 2) >= map.Height)
+                {
+                    finished = true;
+                    continue;
+                }
+                
+                //Move up X Axis
+                path.AddRange(
+                    map.GetShortestPath(
+                        currentPostion, 
+                        map.GetCell(currentPostion.X, currentPostion.Y + (vehicle.DetectorRadius * 2) - 1)));
+
+                currentPostion = new Cell(currentPostion.X, currentPostion.Y + (vehicle.DetectorRadius * 2) -1);
+                if (currentHeading == GlobalDirection.East)
+                    currentHeading = GlobalDirection.West;
+                else
+                    currentHeading = GlobalDirection.East;
+                
+            }
+
+
+            return new Queue<ICell>(path);
+        }
+
+        public Queue<Coordinate2D> GenerateOptimalHexPath(IHexMap hexMap, IVehicle vehicle)
+        {
+            var currentPostion = vehicle.CurrentHexCell;
+            var currentHeading = GlobalDirection.East;
+            var finished = false;
+            var path = new List<Coordinate2D>();
+            while (!finished)
+            {
+                //Heading East
+                if (currentHeading == GlobalDirection.East)
+                {
+                    path.AddRange(hexMap.Graph.GetShortestPath(
+                        currentPostion,
+                        new Coordinate2D(hexMap.Width-1, currentPostion.Y, hexMap.OffsetType),
+                        hexMap.DefaultMovement));
+                    currentPostion = new Coordinate2D(hexMap.Width-1, currentPostion.Y, hexMap.OffsetType);
+                }
+                //Heading West
+                else if (currentHeading == GlobalDirection.West)
+                {
+                    path.AddRange(hexMap.Graph.GetShortestPath(
+                        currentPostion,
+                        new Coordinate2D(0, currentPostion.Y, hexMap.OffsetType),
+                        hexMap.DefaultMovement));
+                    currentPostion = new Coordinate2D(0, currentPostion.Y, hexMap.OffsetType);
+                
+                }
+
+                //Check for finish
+                if (currentPostion.Y + (vehicle.DetectorRadius * 2) >= hexMap.Height - 1)
+                {
+                    finished = true;
+                    break;
+                }
+
+                //Move Up edges of map
+                var tmpPosition = currentPostion;
+                var range = hexMap.Graph.GetRange(currentPostion, vehicle.DetectorRadius * 2);
+                for (var i = currentPostion.Y; i < currentPostion.Y + vehicle.DetectorRadius * 2; i++)
+                {
+                    var newCoord = new Coordinate2D(currentPostion.X, i, hexMap.OffsetType);
+                    if (range.Contains(newCoord))
+                        tmpPosition = newCoord;
+                   
+                }
+                
+                path.AddRange(hexMap.Graph.GetShortestPath(
+                    currentPostion,
+                    tmpPosition,
+                    hexMap.DefaultMovement));
+                currentPostion = tmpPosition;
+                if (currentHeading == GlobalDirection.East)
+                    currentHeading = GlobalDirection.West;
+                else
+                    currentHeading = GlobalDirection.East;
+                
+                
+               
+            }
+
+            return new Queue<Coordinate2D>(path);
+        }
+    }
+}
--- a/ConsoleApp/PathPlanners/ReactivePathPlanner.cs
+++ b/ConsoleApp/PathPlanners/ReactivePathPlanner.cs
@@ -0,0 +1,76 @@
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp.PathPlanners
+{
+    public class ReactivePathPlanner : IReactivePathPlanner
+    {
+        private Queue<Coordinate2D> _reactiveHexPath;
+        private Queue<ICell> _reactiveSquarePath;
+        public Queue<Coordinate2D> ReactiveHexPath => _reactiveHexPath;
+        public Queue<ICell> ReactiveSquarePath => _reactiveSquarePath;
+
+        
+
+        public ReactivePathPlanner()
+        {
+            _reactiveHexPath = new Queue<Coordinate2D>();
+            _reactiveSquarePath = new Queue<ICell>();
+
+        }
+        public void GenerateReactiveHexPath(IHexMap hexMap, Queue<Coordinate2D> optimalPath,
+            Coordinate2D vehicleCurrentHexCell)
+        {
+            //Clean out any old path
+            _reactiveHexPath.Clear();
+            
+            //If the optimal path is empty well we are done, otherwise pop 1
+            if (!optimalPath.TryDequeue(out var convergentPoint))
+                return;
+
+            //Dequeue until the cell is not blocked
+            while (hexMap.Graph.IsCellBlocked(convergentPoint))
+            {
+                //if optimal path is empty were done and we can not clear around this position, otherwise
+                //lest pop another.
+                if (!optimalPath.TryDequeue(out convergentPoint))
+                    return;
+            }
+
+            var reactivePath = hexMap.Graph.GetShortestPath(vehicleCurrentHexCell, convergentPoint, hexMap.DefaultMovement);
+            foreach (var node in reactivePath)
+            {
+                _reactiveHexPath.Enqueue(node);
+            }
+        }
+
+
+        public void GenerateReactiveSquarePath(ISquareMap squareMap, Queue<ICell> optimalPath,
+            ICell vehicleCurrentSquareCell)
+        {
+            //Clean out old path
+            _reactiveSquarePath.Clear();
+            
+            //If the optimal path is empty well we are done, otherwise pop 1
+            if (!optimalPath.TryDequeue(out ICell convergentPoint))
+                return;
+
+            //Dequeue until the cell is not blocked
+            while (squareMap.GetCell(convergentPoint.X, convergentPoint.Y).Blocked)
+            {
+                //if optimal path is empty were done and we can not clear around this position, otherwise
+                //lest pop another.
+                if (!optimalPath.TryDequeue(out convergentPoint))
+                    return;
+            }
+
+            var map = (SquareMap)squareMap;
+            var reactivePath = map.GetShortestPath(vehicleCurrentSquareCell, convergentPoint);
+            foreach (var node in reactivePath)
+            {
+                _reactiveSquarePath.Enqueue(node);
+            }
+        }
+    }
+}
--- a/ConsoleApp/Program.cs
+++ b/ConsoleApp/Program.cs
@@ -1,4 +1,8 @@
 using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading;
 using ConsoleApp.Maps;

 namespace ConsoleApp
@@ -10,35 +14,53 @@ namespace ConsoleApp

        static void Main(string[] args)
        {
-            _bootstrapper = new BootStrapper();
+            _bootstrapper = BootStrapper.BootstrapSystem(new CoreModule());
+            var simResults = _bootstrapper.Resolve<ISimulationResults>();
            _userConsole = new UserConsole();
-            StartSimulation();
+            Initialization();
+            simResults.WriteResults();
+            GenerateImages();
+            Console.WriteLine("Program Completed");
        }

-        private static void StartSimulation()
+       
+
+        private static void Initialization()
        {
-            _userConsole.PrintStartMenu();
-            var input = _userConsole.GetUserInput();
-            if (input == "1")
-            {
-                var (x,y) = _userConsole.GetMapDimensions();
-                RunSimulation(x, y);
-            }
-            else
-            {
-                _userConsole.PrintInvalidInput();
-                StartSimulation();
-            }
+            var (x,y) = _userConsole.GetMapDimensions();
+            var minePercentage = 1;
+            RunSimulation(x, y, minePercentage);
+
        }

-        private static void RunSimulation(int x,int y)
+        private static void RunSimulation(int x, int y, double minePercentage)
        {
-            var simRunner = _bootstrapper.Resolve<ISimRunner>();
            var mapFactory = _bootstrapper.Resolve<IMapFactory>();
+            var simRunner = _bootstrapper.Resolve<ISimRunner>();
            
-            mapFactory.GenerateMaps(x, y);
+            mapFactory.GenerateMaps(x, y, minePercentage);
            simRunner.Run();
        }
        
+        private static void GenerateImages()
+        {
+            var file = Path.Combine("./",Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), @"plotGraphs.py");
+            ProcessStartInfo startInfo = new ProcessStartInfo()
+            {
+                FileName = "python3",
+                Arguments = file,
+                UseShellExecute = true
+            };
+            Process proc = new Process()
+            {
+                StartInfo = startInfo,
+            };
+            proc.Start();
+            while (!proc.HasExited)
+            {
+                Thread.Sleep(500);
+            }
+        }
+
    }
 }
--- a/ConsoleApp/Sim/DetectionHead.cs
+++ b/ConsoleApp/Sim/DetectionHead.cs
@@ -0,0 +1,29 @@
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp.Sim
+{
+    public static class DetectionHead
+    {
+        public static List<Coordinate2D> GetCoveredCells(
+            Graph graph,
+            Coordinate2D centerCoordinate,
+            int detectorRadius,
+            int vehicleTurnRadius)
+        {
+            var detectorCells = graph.GetRange(centerCoordinate, detectorRadius);
+            // var vehicleCells = graph.GetRange(centerCoordinate, vehicleTurnRadius);
+            // foreach (var vehicleCell in vehicleCells)
+            // {
+            //     detectorCells.Remove(vehicleCell);
+            // }
+            return detectorCells;
+        }
+
+        public static List<Cell> GetCoveredCells(
+            ISquareMap squareMap,
+            Cell centerCell,
+            int detectorRadius) => squareMap.GetRange(centerCell, detectorRadius * 2 - detectorRadius%2);
+    }
+}
--- a/ConsoleApp/Sim/IVehicle.cs
+++ b/ConsoleApp/Sim/IVehicle.cs
@@ -0,0 +1,15 @@
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp.Sim
+{
+    public interface IVehicle
+    {
+        int Length { get; }
+        int Width { get; }
+        int TurnRadius { get; }
+        int DetectorRadius { get;}
+        Coordinate2D CurrentHexCell { get; set; }
+        Cell CurrentSquareCell { get; set; }
+    }
+}
--- a/ConsoleApp/Sim/Vehicle.cs
+++ b/ConsoleApp/Sim/Vehicle.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using ConsoleApp.Maps;
+
+namespace ConsoleApp.Sim
+{
+    public class Vehicle : IVehicle
+    {
+        public int Length { get; }
+        public int Width { get; }
+        public int TurnRadius { get; }
+        public int DetectorRadius { get;}
+        public HexCore.Coordinate2D CurrentHexCell { get; set; }
+        public Cell CurrentSquareCell { get; set; }
+        
+        
+
+        
+        public Vehicle(IJsonDeserializor jsonDeserializor)
+        {
+            var config = jsonDeserializor.DeserializeObject<VehicleConfiguration>("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Sim/VehicleConfiguration.json");
+            var length = config.Length;
+            length *= 100;
+            Length = (int)Math.Ceiling((decimal)length/ 25);
+            var width = config.Width;
+            width *= 100;
+            Width = (int)Math.Ceiling((decimal)width/ 25);
+            DetectorRadius = (int)Math.Floor(((decimal)config.DetectorRadius * 100)/25)/2;
+            TurnRadius = (int)Math.Ceiling(Math.Sqrt(Math.Pow(config.Length, 2) * Math.Pow(config.Width, 2))/2);
+            // if (DetectorRadius <= TurnRadius)
+            //     throw new ArgumentException("Detection radius must be larger than the vehicle turn radius");
+
+        }
+    }
+}
--- a/ConsoleApp/Sim/VehicleConfiguration.cs
+++ b/ConsoleApp/Sim/VehicleConfiguration.cs
@@ -0,0 +1,9 @@
+namespace ConsoleApp.Sim
+{
+    public class VehicleConfiguration
+    {
+        public int Length { get; set; }
+        public int Width { get; set; }
+        public int DetectorRadius { get; set; }
+    }
+}
--- a/ConsoleApp/Sim/VehicleConfiguration.json
+++ b/ConsoleApp/Sim/VehicleConfiguration.json
@@ -0,0 +1,5 @@
+{
+  "Length": 1,
+  "Width": 1,
+  "DetectorRadius": 2
+}
--- a/ConsoleApp/SimRunner.cs
+++ b/ConsoleApp/SimRunner.cs
@@ -1,19 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using ConsoleApp.Maps;
+using ConsoleApp.PathPlanners;
+using ConsoleApp.Sim;
+using HexCore;

 namespace ConsoleApp
 {
    public class SimRunner : ISimRunner
    {
        private IMapFactory _mapFactory;
+        private IVehicle _vehicle;

-        public SimRunner(IMapFactory mapFactory)
+        private IPathPlanner _pathPlanner;
+        private IMineMap _mineMap;
+        private IReactivePathPlanner _reactivePathPlanner;
+        private HashSet<Coordinate2D> hexBombsFound = new HashSet<Coordinate2D>();
+        private ISimulationResults _simulationResults;
+        private HashSet<ICell> squareBombsFound = new HashSet<ICell>();
+        
+
+
+        public SimRunner(IMapFactory mapFactory, IVehicle vehicle, IPathPlanner pathPlanner, IReactivePathPlanner reactivePathPlanner, ISimulationResults simulationResults)
        {
            _mapFactory = mapFactory;
+            _vehicle = vehicle;
+            _pathPlanner = pathPlanner;
+            _reactivePathPlanner = reactivePathPlanner;
+            _simulationResults = simulationResults;
        }

        public void Run()
        {
-            throw new System.NotImplementedException();
+            _mineMap = _mapFactory.GetMineMap();
+            _simulationResults.Mines = _mineMap.PlacedMines;
+            _simulationResults.TotalBombs = _mineMap.TotalBombs;
+            SquareSimulation();
+            HexSimulation();
+            // while(!squareTask.IsCompleted && !hexTask.IsCompleted){Thread.Sleep(500);}
+
        }
+
+        #region HexSimulation
+
+        private void HexSimulation()
+        {
+            var hexMap = _mapFactory.GetHexMap();
+            _vehicle.CurrentHexCell = new Coordinate2D(0, 0, OffsetTypes.OddRowsRight);
+            var optimalPath = _pathPlanner.GenerateOptimalHexPath(hexMap, _vehicle);
+            var finished = false;
+            var totalMoves = 0;
+            while (!finished)
+            {
+                totalMoves += 1;
+                _simulationResults.HexPath.Add(_vehicle.CurrentHexCell);
+
+                var detectionCells = DetectionHead.GetCoveredCells(hexMap.Graph, _vehicle.CurrentHexCell, _vehicle.DetectorRadius, _vehicle.TurnRadius);
+                //Check Cells for mine
+                var detection = CheckCells(detectionCells);
+                //mark as cleared
+                hexMap.Graph.SetCellsTerrainType(detectionCells, hexMap.ClearedTerrain);
+                //Handle any detections
+                if (detection)
+                {
+                    _reactivePathPlanner.GenerateReactiveHexPath(hexMap, optimalPath, _vehicle.CurrentHexCell);
+                }
+                
+                //If the reactive Planner is not empty, empty it before the optimal.
+                if (_reactivePathPlanner.ReactiveHexPath.TryDequeue(out var next))
+                    _vehicle.CurrentHexCell = next;
+                //Else we will work off of the optimal path
+                else
+                {
+                    //If the optimal path is empty we are done otherwise pop.
+                    if (!optimalPath.TryDequeue(out var nextOptimal))
+                    {
+                        finished = true;
+                        continue;
+                    }
+
+                    if (hexMap.Graph.IsCellBlocked(nextOptimal))
+                    {
+                        _reactivePathPlanner.GenerateReactiveHexPath(hexMap, optimalPath, _vehicle.CurrentHexCell);
+                    }
+                    else
+                        _vehicle.CurrentHexCell = nextOptimal;
+                }
+            }
+            
+            
+            //Debugging information
+            var (cleared, uncleared) = CoveredCells();
+            _simulationResults.HexClearedCells = cleared;
+            _simulationResults.HexUnClearedCells = uncleared;
+            _simulationResults.HexTotalMoves = totalMoves;
+            _simulationResults.HexBombsFound = hexBombsFound.Count;
+            _simulationResults.HexMappedBombs = hexBombsFound.ToList();
+            
+            foreach (var cell in hexMap.Graph.GetAllCells())
+            {
+                if(cell.TerrainType.Id == hexMap.ClearedTerrain.Id)
+                    _simulationResults.HexCoveredCells.Add(cell.Coordinate3.To2D(hexMap.OffsetType));
+            }
+        }
+
+        private (int, int) CoveredCells()
+        {
+            var cleared = 0;
+            var uncleared = 0;
+            var hexMap = _mapFactory.GetHexMap();
+            foreach (var cellState in hexMap.Graph.GetAllCells())
+            {
+                if (cellState.TerrainType.Id == hexMap.ClearedTerrain.Id)
+                    cleared++;
+                if (cellState.TerrainType.Id == hexMap.UnclearedTerrain.Id)
+                    uncleared++;
+            }
+
+            return (cleared, uncleared);
+        }
+
+
+        private bool CheckCells(List<Coordinate2D> detectionCells)
+        {
+            var found = false;
+            foreach (var cell in detectionCells.Where(cell => _mineMap.GetCell(cell.X, cell.Y)))
+            {
+                if (!hexBombsFound.Add(cell)) continue;
+                BlockCells(cell);
+                found = true;
+            }
+            return found;
+        }
+
+        private void BlockCells(Coordinate2D cell)
+        {
+            var hexMap = _mapFactory.GetHexMap();
+            var cellsToBlock = hexMap.Graph.GetRange(cell, _vehicle.Width / 2);
+            hexMap.Graph.BlockCells(cellsToBlock);
+            
+        }
+        #endregion
+
+        #region SquareSimulation
+        private void SquareSimulation()
+        {
+            var squareMap = _mapFactory.GetSquareMap();
+            _vehicle.CurrentSquareCell = squareMap.StartingCell;
+            var optimalPath = _pathPlanner.GenerateOptimalSquarePath(squareMap, _vehicle);
+            var finished = false;
+            while (!finished)
+            {
+                _simulationResults.SquareTotalMoves++;
+                _simulationResults.SquarePath.Add(_vehicle.CurrentSquareCell);
+                var detector = squareMap.GetRange(_vehicle.CurrentSquareCell, _vehicle.DetectorRadius);
+                var detection = CheckForMines(detector);
+                //Mark cells as covered.
+                foreach (var cell in detector)
+                {
+                    cell.Coverage = Coverage.Covered;
+                }
+                if (detection)
+                    _reactivePathPlanner.GenerateReactiveSquarePath(squareMap, optimalPath, _vehicle.CurrentSquareCell);
+                if (_reactivePathPlanner.ReactiveSquarePath.TryDequeue(out var next))
+                {
+                    _vehicle.CurrentSquareCell = (Cell) next;
+                }
+                else
+                {
+                    if (!optimalPath.TryDequeue(out var current))
+                    {
+                        finished = true;
+                        continue;
+                    }
+
+                    if (current.Blocked)
+                    {
+                        _reactivePathPlanner.GenerateReactiveSquarePath(squareMap, optimalPath, current);
+                    }
+                    else
+                        _vehicle.CurrentSquareCell = (Cell) current;
+                }
+            }
+
+            //Debugging information
+            var (cleared, uncleared) = CoveredSquareCells();
+            _simulationResults.SquareCellsCleared = cleared;
+            _simulationResults.SquareCellsUncleared = uncleared;
+            _simulationResults.SquareBombsFound = squareBombsFound.Count;
+            _simulationResults.SquareMappedBombs = squareBombsFound.ToList();
+
+            foreach (var cell in squareMap.Map)
+            {
+                if (cell.Coverage == Coverage.Covered)
+                {
+                    _simulationResults.SquareCoveredCells.Add(cell);
+                }
+            }
+
+        }
+
+        private (int, int) CoveredSquareCells()
+        {
+            var cleared = 0;
+            var uncleared = 0;
+            var map = _mapFactory.GetSquareMap();
+            foreach (var cellState in map.Map)
+            {
+                switch (cellState.Coverage)
+                {
+                    case Coverage.Covered:
+                        cleared++;
+                        break;
+                    case Coverage.Uncovered:
+                        uncleared++;
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+
+            return (cleared, uncleared);
+        }
+
+        private bool CheckForMines(List<Cell> detector)
+        {
+            var found = false;
+            foreach (var cell in detector.Where(cell => _mineMap.GetCell(cell.X, cell.Y)))
+            {
+                if(!squareBombsFound.Add(cell)) continue;
+                found = true;
+                BlockSquareCells(cell);
+            }
+
+            return found;
+        }
+
+        private void BlockSquareCells(Cell cell)
+        {
+            var map = _mapFactory.GetSquareMap();
+            var cellsToBlock = map.GetRange(cell, _vehicle.DetectorRadius);
+            foreach (var blockCell in cellsToBlock)
+            {
+                blockCell.Blocked = true;
+            }
+        }
+
+        #endregion
+
    }
 }
--- a/ConsoleApp/SimulationResults.cs
+++ b/ConsoleApp/SimulationResults.cs
@@ -0,0 +1,138 @@
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using ConsoleApp.Maps;
+using HexCore;
+
+namespace ConsoleApp
+{
+    public class SimulationResults : ISimulationResults
+    {
+        public int HexTotalMoves { get; set; }
+        public int HexBombsFound { get; set; }
+        public int TotalBombs { get; set; }
+        public List<Coordinate2D> HexPath { get; set; }
+        public List<Coordinate2D> HexMappedBombs { get; set; }
+        public List<Cell> Mines { get; set; }
+        public int HexClearedCells { get; set; }
+        public int HexUnClearedCells { get; set; }
+        
+        public List<ICell> SquarePath { get; set; }
+        public List<ICell> SquareMappedBombs { get; set; }
+        public int SquareCellsUncleared { get; set; }
+        public int SquareCellsCleared { get; set; }
+        public int SquareBombsFound { get; set; }
+        public int SquareTotalMoves { get; set; }
+        public List<ICell> SquareCoveredCells { get; set; }
+        public List<Coordinate2D> HexCoveredCells { get; set; }
+
+        public SimulationResults()
+        {
+            HexTotalMoves = 0;
+            HexBombsFound = 0;
+            TotalBombs = 0;
+            HexPath = new List<Coordinate2D>();
+            HexMappedBombs = new List<Coordinate2D>();
+            Mines = new List<Cell>();
+            HexClearedCells = 0;
+            HexUnClearedCells = 0;
+            SquarePath = new List<ICell>();
+            SquareMappedBombs = new List<ICell>();
+            SquareCellsUncleared = 0;
+            SquareCellsCleared = 0;
+            SquareBombsFound = 0;
+            SquareTotalMoves = 0;
+            SquareCoveredCells = new List<ICell>();
+            HexCoveredCells = new List<Coordinate2D>();
+
+        }
+
+        public void WriteResults()
+        {
+            WriteData();
+            WriteMines();
+            WritePaths();
+            WriteDetectedMines();
+            WriteCoveredCells();
+        }
+        
+
+        private void WriteData()
+        {
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/Data.txt"))
+            {
+                tw.WriteLine($"General:");
+                tw.WriteLine($"\t Total Mines: {TotalBombs}");
+                tw.WriteLine($"Hex: ");
+                tw.WriteLine($"\t Total Moves: {HexTotalMoves}");
+                tw.WriteLine($"\t Bombs Found: {HexBombsFound}");
+                tw.WriteLine($"\t Cleared Cell Count: {HexClearedCells}");
+                tw.WriteLine($"\t Uncleared Cell Count: {HexUnClearedCells}");
+                tw.WriteLine($"\t Percentage Cleared: {(double)HexClearedCells/(HexClearedCells+HexUnClearedCells)*100}");
+                tw.WriteLine($"Square: ");
+                tw.WriteLine($"\t Total Moves: {SquareTotalMoves}");
+                tw.WriteLine($"\t Bombs Found: {SquareBombsFound}");
+                tw.WriteLine($"\t Cleared Cell Count: {SquareCellsCleared}");
+                tw.WriteLine($"\t Uncleared Cell Count: {SquareCellsUncleared}");
+                tw.WriteLine($"\t Percentage Cleared: {(double) SquareCellsCleared / (SquareCellsCleared + SquareCellsUncleared)*100}");
+
+            }
+        }
+
+       
+        
+        private void WriteMines()
+        {
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/Mines.txt"))
+            {
+                foreach (var s in Mines)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }
+        }
+
+        private void WriteCoveredCells()
+        {
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexCoveredCells.txt"))
+            {
+                foreach (var s in HexCoveredCells)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }        
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareCoveredCells.txt"))
+            {
+                foreach (var s in SquareCoveredCells)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }        
+        }
+        
+        private void WriteDetectedMines()
+        {
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexDetectedMines.txt"))
+            {
+                foreach (var s in HexMappedBombs)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }        
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareDetectedMines.txt"))
+            {
+                foreach (var s in SquareMappedBombs)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }        
+        }
+
+        private void WritePaths()
+        {
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexPath.txt"))
+            {
+                foreach (var s in HexPath)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }
+            using(TextWriter tw = new StreamWriter("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquarePath.txt"))
+            {
+                foreach (var s in SquarePath)
+                    tw.WriteLine($"{s.X} {s.Y}");
+            }
+            
+        }
+    }
+}
--- a/ConsoleApp/UserConsole.cs
+++ b/ConsoleApp/UserConsole.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using ConsoleApp.Maps;

@@ -6,8 +7,6 @@ namespace ConsoleApp
 {
    public class UserConsole : IUserConsole
    {
-        private IMapFactory _mapFactory;
-
        public UserConsole()
        {
        }
@@ -19,28 +18,40 @@ namespace ConsoleApp
                              $"\t 2: Load custom map. \n");
        }

-        public string GetUserInput() => Console.ReadLine();
+        public static string GetUserInput() => Console.ReadLine();

-        public void PrintInvalidInput()
-        {
-            Console.WriteLine($"Invalid input try again \n");
-        }
+        public static void PrintInvalidInput() => Console.WriteLine($"Invalid input try again \n");

        public (int width, int height) GetMapDimensions()
        {
-            Console.WriteLine($"Enter Dimensions of map/area to clear as (x, y)");
-            var input = GetUserInput();
-            var numbers = input.Split();
-            if (numbers.Length != 4)
+            Console.WriteLine($"Enter map width (5-15) meters: ");
+            var x = GetUserInput();
+
+            if (!int.TryParse(x, out var width) && width >= 5 && width <= 15)
            {
                PrintInvalidInput();
                GetMapDimensions();
            }

-            var parsedNumbers = numbers.Where(x => !(x.Equals("(") || x.Equals(")"))).ToList();
-            int.TryParse(parsedNumbers[0], out var width);
-            int.TryParse(parsedNumbers[1], out var height);
+            Console.WriteLine($"Enter map height (5-15) meters: ");
+            var y = GetUserInput();
+            if (int.TryParse(y, out var height) && height >= 5 && height <= 15) return (width, height);
+            PrintInvalidInput();
+            GetMapDimensions();
            return (width, height);
        }
+
+        public static double GetMinePercentage()
+        {
+            
+            Console.WriteLine($"Enter desired percentage of mines: ");
+            var x = GetUserInput();
+
+            if (double.TryParse(x, out var percent)) return percent;
+            PrintInvalidInput();
+            GetMinePercentage();
+
+            return percent;
+        }
    }
 }
--- a/ConsoleApp/plotGraphs.py
+++ b/ConsoleApp/plotGraphs.py
@@ -0,0 +1,122 @@
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+
+
+if __name__ == "__main__":
+    xc = []
+    yc = []
+    xm = []
+    ym = []
+    xf = []
+    yf = []
+    sxc = []
+    syc = []
+    sxm = []
+    sym = []
+    sxf = []
+    syf = []
+    
+    sccx = []
+    sccy = []
+    hccx = []
+    hccy = []
+
+    mx = []
+    my = []
+    
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareCoveredCells.txt") as c:
+        for line in c:
+            x, y = line.split()
+            sccx.append(int(x))
+            sccy.append(int(y))
+            
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/Mines.txt") as c:
+        for line in c:
+            x, y = line.split()
+            mx.append(int(x))
+            my.append(int(y))
+    
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareDetectedMines.txt") as c:
+        for line in c:
+            x, y = line.split()
+            sxf.append(int(x))
+            syf.append(int(y))
+           
+                
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexCoveredCells.txt") as c:
+        for line in c:
+            x, y = line.split()
+            hccx.append(int(x))
+            hccy.append(int(y))
+    
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexPath.txt") as c:
+        for line in c:
+            x, y = line.split()
+            xc.append(int(x))
+            yc.append(int(y))
+            
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquarePath.txt") as c:
+        for line in c:
+            x, y = line.split()
+            sxc.append(int(x))
+            syc.append(int(y))
+                
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/Mines.txt") as m:
+        for line in m:
+            x, y = line.split()
+            xm.append(int(x))
+            ym.append(int(y))
+
+    with open("/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexDetectedMines.txt") as f:
+        for line in f:
+            x, y = line.split()
+            xf.append(int(x))
+            yf.append(int(y))
+            
+    fig = plt.figure(1)
+    plt.plot(xc, yc, 'h', label='vehicle',  color='blue', linestyle='None')
+    plt.plot(xm, ym, 'h', label='all mines', color='red', linestyle='None')
+    plt.plot(xf, yf, 'h', label='detected mines', color='orange', linestyle='None')
+    plt.title('Hex Simulation')
+    plt.legend(loc='lower left', fontsize='xx-small')
+    matplotlib.pyplot.savefig('/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexTest.png')
+    
+    plt.plot()
+    plt.close(fig)
+    
+    fig = plt.figure(2)
+    plt.plot(sxc, syc, 's', label='vehicle',  color='blue', linestyle='None')
+    plt.plot(sxm, sym, 's', label='all mines', color='red', linestyle='None')
+    plt.plot(sxf, syf, 's', label='detected mines', color='orange', linestyle='None')
+    plt.title('Square Simulation')
+    plt.legend(loc='lower left', fontsize='xx-small')
+    matplotlib.pyplot.savefig('/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareTest.png')
+    plt.plot()
+    plt.close(fig)
+    
+    fig = plt.figure(3)
+    plt.plot(hccx, hccy, 'h', label='covered cells', color='red', linestyle='None')
+    plt.plot(xf, yf, 'h', label='detected mines',  color='blue', linestyle='None')
+    plt.title('Hex Coverage')
+    plt.legend(loc='lower left', fontsize='xx-small')
+    matplotlib.pyplot.savefig('/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/HexCoverage.png')
+    plt.plot()
+    plt.close(fig)
+    
+    fig = plt.figure(4)
+    plt.plot(sccx, sccy, 's', label='covered cells', color='red', linestyle='None')
+    plt.plot(sxf, syf, 's', label='detected mines',  color='blue', linestyle='None')
+    plt.title('Square Coverage')
+    plt.legend(loc='lower left', fontsize='xx-small')
+    matplotlib.pyplot.savefig('/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/SquareCoverage.png')
+    plt.plot()
+    plt.close(fig)
+    
+    fig = plt.figure(5)
+    plt.plot(mx, my, 'o', label='mines', color='red', linestyle='None')
+    plt.title('Mine Map')
+    plt.legend(loc='lower left', fontsize='xx-small')
+    matplotlib.pyplot.savefig('/Users/brady.bodily/Documents/Repositories/CS5890_Robot_Intelligence/RobotIntelFinal/ConsoleApp/Output/Mines.png')
+    plt.plot()
+    plt.close(fig)
--- a/README.md
+++ b/README.md
@@ -0,0 +1 @@
+# RobotIntelligence_Final_Project
--- a/RobotIntelFinal.sln.DotSettings.user
+++ b/RobotIntelFinal.sln.DotSettings.user
@@ -0,0 +1,4 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/Environment/Hierarchy/Build/BuildTool/DotNetCliExePath/@EntryValue">/Users/brady.bodily/.dotnet/dotnet</s:String>
+	
+	<s:String x:Key="/Default/Environment/Hierarchy/Build/BuildTool/CustomBuildToolPath/@EntryValue">/Users/brady.bodily/.dotnet/sdk/3.1.402/MSBuild.dll</s:String></wpf:ResourceDictionary>
Author	SHA1	Message	Date
bradybod	fa88af55a5	README.MD	2020-12-16 20:48:38 -07:00
bradybod	7bf6834313	Merge pull request #10 from bradybod/SquareSimulation added to python script	2020-12-16 20:39:57 -07:00
Brady Bodily	588c004c1b	added to python script	2020-12-16 20:39:19 -07:00
Brady Bodily	6532f58c02	Merge branch 'SquareSimulation' into main	2020-12-16 18:04:49 -07:00
Brady Bodily	74035a16eb	Finished	2020-12-16 18:04:26 -07:00
Brady Bodily	e335ce3c68	I think its done	2020-12-16 17:19:25 -07:00
Brady Bodily	a792de99f3	Merge branch 'AddLogicToReactivePlanner' into main	2020-12-16 04:50:40 -07:00
Brady Bodily	e8ffbd3151	Hex is done and working	2020-12-16 04:50:21 -07:00
Brady Bodily	f8ce6d0c83	Getting close	2020-12-16 04:02:37 -07:00
Brady Bodily	cf432a348b	Merge branch 'SquareMap' into main	2020-12-15 18:19:48 -07:00
Brady Bodily	4edcef4664	Created Mine Map and ReactivePlanner	2020-12-15 18:19:07 -07:00
Brady Bodily	45eca3b572	Back up	2020-12-15 15:46:45 -07:00
Brady Bodily	00444fbba9	Cleaned up some files	2020-12-15 00:37:47 -07:00
Brady Bodily	257aaa331f	Done for the night Need to change planning algo for square to go right to left.	2020-12-15 00:09:29 -07:00
Brady Bodily	5bb82f7579	Optimal path for square map	2020-12-14 18:24:10 -07:00
Brady Bodily	80ea690330	Optimal path generated for square cells	2020-12-14 18:23:25 -07:00
Brady Bodily	d63066c150	Backup Working through some localization stuff will probably be pretty fluid.	2020-12-14 16:08:59 -07:00
Brady Bodily	2c5f0b73b9	Added detector info	2020-12-10 21:18:15 -07:00
Brady Bodily	3fee402da1	Added deserializor and vehicle configuration	2020-12-10 21:01:23 -07:00
Brady Bodily	d725372ffb	Maps are more generic as well as cells.	2020-12-10 20:34:45 -07:00
Brady Bodily	7f0cb10198	Backup	2020-12-10 20:15:09 -07:00
Brady Bodily	bd7264f893	Merge branch 'hex' into SquareMap	2020-12-10 20:14:40 -07:00
Brady Bodily	63f158afd9	backing up	2020-12-10 20:07:23 -07:00