maps4fs 0.7.8__py3-none-any.whl → 0.9.93__py3-none-any.whl

maps4fs/generator/dem.py

@@ -9,17 +9,19 @@ import cv2
 import numpy as np
 import rasterio  # type: ignore
 import requests
+from pympler import asizeof  # type: ignore
 
 from maps4fs.generator.component import Component
 
 SRTM = "https://elevation-tiles-prod.s3.amazonaws.com/skadi/{latitude_band}/{tile_name}.hgt.gz"
 DEFAULT_MULTIPLIER = 1
-DEFAULT_BLUR_RADIUS = 21
+DEFAULT_BLUR_RADIUS = 35
+DEFAULT_PLATEAU = 0
 
 
-# pylint: disable=R0903
+# pylint: disable=R0903, R0902
 class DEM(Component):
-    """Component for map settings and configuration.
+    """Component for processing Digital Elevation Model data.
 
     Args:
         coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
@@ -40,19 +42,34 @@ class DEM(Component):
 
         self.multiplier = self.kwargs.get("multiplier", DEFAULT_MULTIPLIER)
         blur_radius = self.kwargs.get("blur_radius", DEFAULT_BLUR_RADIUS)
-        if blur_radius % 2 == 0:
+        if blur_radius is None or blur_radius <= 0:
+            # We'll disable blur if the radius is 0 or negative.
+            blur_radius = 0
+        elif blur_radius % 2 == 0:
             blur_radius += 1
         self.blur_radius = blur_radius
         self.logger.debug(
             "DEM value multiplier is %s, blur radius is %s.", self.multiplier, self.blur_radius
         )
 
-    # pylint: disable=no-member
-    def process(self) -> None:
-        """Reads SRTM file, crops it to map size, normalizes and blurs it,
-        saves to map directory."""
-        north, south, east, west = self.bbox
+        self.auto_process = self.kwargs.get("auto_process", False)
+        self.plateau = self.kwargs.get("plateau", False)
+
+    @property
+    def dem_path(self) -> str:
+        """Returns path to the DEM file.
+
+        Returns:
+            str: Path to the DEM file.
+        """
+        return self._dem_path
+
+    def get_output_resolution(self) -> tuple[int, int]:
+        """Get output resolution for DEM data.
 
+        Returns:
+            tuple[int, int]: Output resolution for DEM data.
+        """
         dem_height = int((self.map_height / 2) * self.game.dem_multipliyer + 1)
         dem_width = int((self.map_width / 2) * self.game.dem_multipliyer + 1)
         self.logger.debug(
@@ -61,7 +78,31 @@ class DEM(Component):
             dem_height,
             dem_width,
         )
-        dem_output_resolution = (dem_width, dem_height)
+        return dem_width, dem_height
+
+    def to_ground(self, data: np.ndarray) -> np.ndarray:
+        """Receives the signed 16-bit integer array and converts it to the ground level.
+        If the min value is negative, it will become zero value and the rest of the values
+        will be shifted accordingly.
+        """
+        # For examlem, min value was -50, it will become 0 and for all values we'll +50.
+
+        if data.min() < 0:
+            self.logger.debug("Array contains negative values, will be shifted to the ground.")
+            data = data + abs(data.min())
+
+        self.logger.debug(
+            "Array was shifted to the ground. Min: %s, max: %s.", data.min(), data.max()
+        )
+        return data
+
+    # pylint: disable=no-member
+    def process(self) -> None:
+        """Reads SRTM file, crops it to map size, normalizes and blurs it,
+        saves to map directory."""
+        north, south, east, west = self.bbox
+
+        dem_output_resolution = self.get_output_resolution()
         self.logger.debug("DEM output resolution: %s.", dem_output_resolution)
 
         tile_path = self._srtm_tile()
@@ -95,26 +136,51 @@ class DEM(Component):
             data.max(),
         )
 
+        data = self.to_ground(data)
+
         resampled_data = cv2.resize(
             data, dem_output_resolution, interpolation=cv2.INTER_LINEAR
         ).astype("uint16")
 
+        size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
+        self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
+
         self.logger.debug(
-            "Maximum value in resampled data: %s, minimum value: %s.",
+            "Maximum value in resampled data: %s, minimum value: %s. Data type: %s.",
             resampled_data.max(),
             resampled_data.min(),
-        )
-
-        resampled_data = resampled_data * self.multiplier
-        self.logger.debug(
-            "DEM data multiplied by %s. Shape: %s, dtype: %s. Min: %s, max: %s.",
-            self.multiplier,
-            resampled_data.shape,
             resampled_data.dtype,
-            resampled_data.min(),
-            resampled_data.max(),
         )
 
+        if self.auto_process:
+            self.logger.debug("Auto processing is enabled, will normalize DEM data.")
+            resampled_data = self._normalize_dem(resampled_data)
+        else:
+            self.logger.debug("Auto processing is disabled, DEM data will not be normalized.")
+            resampled_data = resampled_data * self.multiplier
+
+            self.logger.debug(
+                "DEM data was multiplied by %s. Min: %s, max: %s. Data type: %s.",
+                self.multiplier,
+                resampled_data.min(),
+                resampled_data.max(),
+                resampled_data.dtype,
+            )
+
+            size_of_resampled_data = asizeof.asizeof(resampled_data) / 1024 / 1024
+            self.logger.debug("Size of resampled data: %s MB.", size_of_resampled_data)
+
+            # Clip values to 16-bit unsigned integer range.
+            resampled_data = np.clip(resampled_data, 0, 65535)
+            resampled_data = resampled_data.astype("uint16")
+            self.logger.debug(
+                "DEM data was multiplied by %s and clipped to 16-bit unsigned integer range. "
+                "Min: %s, max: %s.",
+                self.multiplier,
+                resampled_data.min(),
+                resampled_data.max(),
+            )
+
         self.logger.debug(
             "DEM data was resampled. Shape: %s, dtype: %s. Min: %s, max: %s.",
             resampled_data.shape,
@@ -123,11 +189,15 @@ class DEM(Component):
             resampled_data.max(),
         )
 
-        resampled_data = cv2.GaussianBlur(resampled_data, (self.blur_radius, self.blur_radius), 0)
-        self.logger.debug(
-            "Gaussion blur applied to DEM data with kernel size %s.",
-            self.blur_radius,
-        )
+        if self.blur_radius > 0:
+            resampled_data = cv2.GaussianBlur(
+                resampled_data, (self.blur_radius, self.blur_radius), sigmaX=40, sigmaY=40
+            )
+            self.logger.debug(
+                "Gaussion blur applied to DEM data with kernel size %s.",
+                self.blur_radius,
+            )
+
         self.logger.debug(
             "DEM data was blurred. Shape: %s, dtype: %s. Min: %s, max: %s.",
             resampled_data.shape,
@@ -136,14 +206,40 @@ class DEM(Component):
             resampled_data.max(),
         )
 
+        if self.plateau:
+            # Plateau is a flat area with a constant height.
+            # So we just add this value to each pixel of the DEM.
+            # And also need to ensure that there will be no values with height greater than
+            # it's allowed in 16-bit unsigned integer.
+
+            resampled_data += self.plateau
+            resampled_data = np.clip(resampled_data, 0, 65535)
+
+            self.logger.debug(
+                "Plateau with height %s was added to DEM data. Min: %s, max: %s.",
+                self.plateau,
+                resampled_data.min(),
+                resampled_data.max(),
+            )
+
         cv2.imwrite(self._dem_path, resampled_data)
         self.logger.debug("DEM data was saved to %s.", self._dem_path)
 
         if self.game.additional_dem_name is not None:
-            dem_directory = os.path.dirname(self._dem_path)
-            additional_dem_path = os.path.join(dem_directory, self.game.additional_dem_name)
-            shutil.copyfile(self._dem_path, additional_dem_path)
-            self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
+            self.make_copy(self.game.additional_dem_name)
+
+    def make_copy(self, dem_name: str) -> None:
+        """Copies DEM data to additional DEM file.
+
+        Args:
+            dem_name (str): Name of the additional DEM file.
+        """
+        dem_directory = os.path.dirname(self._dem_path)
+
+        additional_dem_path = os.path.join(dem_directory, dem_name)
+
+        shutil.copyfile(self._dem_path, additional_dem_path)
+        self.logger.debug("Additional DEM data was copied to %s.", additional_dem_path)
 
     def _tile_info(self, lat: float, lon: float) -> tuple[str, str]:
         """Returns latitude band and tile name for SRTM tile from coordinates.
@@ -233,14 +329,15 @@ class DEM(Component):
         Returns:
             str: Path to the preview image.
         """
-        rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        # rgb_dem_path = self._dem_path.replace(".png", "_grayscale.png")
+        grayscale_dem_path = os.path.join(self.previews_directory, "dem_grayscale.png")
 
-        self.logger.debug("Creating grayscale preview of DEM data in %s.", rgb_dem_path)
+        self.logger.debug("Creating grayscale preview of DEM data in %s.", grayscale_dem_path)
 
         dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
         dem_data_rgb = cv2.cvtColor(dem_data, cv2.COLOR_GRAY2RGB)
-        cv2.imwrite(rgb_dem_path, dem_data_rgb)
-        return rgb_dem_path
+        cv2.imwrite(grayscale_dem_path, dem_data_rgb)
+        return grayscale_dem_path
 
     def colored_preview(self) -> str:
         """Converts DEM image to colored RGB image and saves it to the map directory.
@@ -250,11 +347,12 @@ class DEM(Component):
             list[str]: List with a single path to the DEM file
         """
 
-        colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        # colored_dem_path = self._dem_path.replace(".png", "_colored.png")
+        colored_dem_path = os.path.join(self.previews_directory, "dem_colored.png")
 
         self.logger.debug("Creating colored preview of DEM data in %s.", colored_dem_path)
 
-        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_UNCHANGED)
+        dem_data = cv2.imread(self._dem_path, cv2.IMREAD_GRAYSCALE)
 
         self.logger.debug(
             "DEM data before normalization. Shape: %s, dtype: %s. Min: %s, max: %s.",
@@ -289,3 +387,51 @@ class DEM(Component):
         """
         self.logger.debug("Starting DEM previews generation.")
         return [self.grayscale_preview(), self.colored_preview()]
+
+    def _get_scaling_factor(self, maximum_deviation: int) -> float:
+        """Calculate scaling factor for DEM data normalization.
+        NOTE: Needs reconsideration for the implementation.
+
+        Args:
+            maximum_deviation (int): Maximum deviation in DEM data.
+
+        Returns:
+            float: Scaling factor for DEM data normalization.
+        """
+        ESTIMATED_MAXIMUM_DEVIATION = 1000  # pylint: disable=C0103
+        scaling_factor = maximum_deviation / ESTIMATED_MAXIMUM_DEVIATION
+        return scaling_factor if scaling_factor < 1 else 1
+
+    def _normalize_dem(self, data: np.ndarray) -> np.ndarray:
+        """Normalize DEM data to 16-bit unsigned integer using max height from settings.
+        Args:
+            data (np.ndarray): DEM data from SRTM file after cropping.
+        Returns:
+            np.ndarray: Normalized DEM data.
+        """
+        self.logger.debug("Starting DEM data normalization.")
+        # Calculate the difference between the maximum and minimum values in the DEM data.
+
+        max_height = data.max()  # 1800
+        min_height = data.min()  # 1700
+        max_dev = max_height - min_height  # 100
+        self.logger.debug(
+            "Maximum deviation: %s with maximum at %s and minimum at %s.",
+            max_dev,
+            max_height,
+            min_height,
+        )
+
+        scaling_factor = self._get_scaling_factor(max_dev)
+        adjusted_max_height = int(65535 * scaling_factor)
+        self.logger.debug(
+            f"Maximum deviation: {max_dev}. Scaling factor: {scaling_factor}. "
+            f"Adjusted max height: {adjusted_max_height}."
+        )
+        normalized_data = (
+            (data - data.min()) / (data.max() - data.min()) * adjusted_max_height
+        ).astype("uint16")
+        self.logger.debug(
+            f"DEM data was normalized to {normalized_data.min()} - {normalized_data.max()}."
+        )
+        return normalized_data

maps4fs/generator/game.py

@@ -6,8 +6,10 @@ from __future__ import annotations
 
 import os
 
+from maps4fs.generator.background import Background
 from maps4fs.generator.config import Config
 from maps4fs.generator.dem import DEM
+from maps4fs.generator.i3d import I3d
 from maps4fs.generator.texture import Texture
 
 working_directory = os.getcwd()
@@ -34,7 +36,7 @@ class Game:
     _map_template_path: str | None = None
     _texture_schema: str | None = None
 
-    components = [Config, Texture, DEM]
+    components = [Config, Texture, DEM, I3d, Background]
 
     def __init__(self, map_template_path: str | None = None):
         if map_template_path:
@@ -113,6 +115,16 @@ class Game:
             str: The path to the weights directory."""
         raise NotImplementedError
 
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        raise NotImplementedError
+
     @property
     def additional_dem_name(self) -> str | None:
         """Returns the name of the additional DEM file.
@@ -122,6 +134,7 @@ class Game:
         return self._additional_dem_name
 
 
+# pylint: disable=W0223
 class FS22(Game):
     """Class used to define the game version FS22."""
 
@@ -167,7 +180,7 @@ class FS25(Game):
 
         Returns:
             str: The path to the DEM file."""
-        return os.path.join(map_directory, "mapUS", "data", "dem.png")
+        return os.path.join(map_directory, "map", "data", "dem.png")
 
     def map_xml_path(self, map_directory: str) -> str:
         """Returns the path to the map.xml file.
@@ -178,7 +191,7 @@ class FS25(Game):
         Returns:
             str: The path to the map.xml file.
         """
-        return os.path.join(map_directory, "mapUS", "mapUS.xml")
+        return os.path.join(map_directory, "map", "map.xml")
 
     def weights_dir_path(self, map_directory: str) -> str:
         """Returns the path to the weights directory.
@@ -188,4 +201,14 @@ class FS25(Game):
 
         Returns:
             str: The path to the weights directory."""
-        return os.path.join(map_directory, "mapUS", "data")
+        return os.path.join(map_directory, "map", "data")
+
+    def i3d_file_path(self, map_directory: str) -> str:
+        """Returns the path to the i3d file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the i3d file."""
+        return os.path.join(map_directory, "map", "map.i3d")

maps4fs/generator/i3d.py

@@ -0,0 +1,89 @@
+"""This module contains the Config class for map settings and configuration."""
+
+from __future__ import annotations
+
+import os
+from xml.etree import ElementTree as ET
+
+from maps4fs.generator.component import Component
+
+DEFAULT_HEIGHT_SCALE = 2000
+DEFAULT_MAX_LOD_DISTANCE = 10000
+DEFAULT_MAX_LOD_OCCLUDER_DISTANCE = 10000
+
+
+# pylint: disable=R0903
+class I3d(Component):
+    """Component for map i3d file settings and configuration.
+
+    Args:
+        coordinates (tuple[float, float]): The latitude and longitude of the center of the map.
+        map_height (int): The height of the map in pixels.
+        map_width (int): The width of the map in pixels.
+        map_directory (str): The directory where the map files are stored.
+        logger (Any, optional): The logger to use. Must have at least three basic methods: debug,
+            info, warning. If not provided, default logging will be used.
+    """
+
+    _map_i3d_path: str | None = None
+
+    def preprocess(self) -> None:
+        """Gets the path to the map I3D file from the game instance and saves it to the instance
+        attribute. If the game does not support I3D files, the attribute is set to None."""
+        try:
+            self._map_i3d_path = self.game.i3d_file_path(self.map_directory)
+            self.logger.debug("Map I3D path: %s.", self._map_i3d_path)
+        except NotImplementedError:
+            self.logger.info("I3D file processing is not implemented for this game.")
+            self._map_i3d_path = None
+
+    def process(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        self._update_i3d_file()
+
+    def _update_i3d_file(self) -> None:
+        """Updates the map I3D file with the default settings."""
+        if not self._map_i3d_path:
+            self.logger.info("I3D is not obtained, skipping the update.")
+            return
+        if not os.path.isfile(self._map_i3d_path):
+            self.logger.warning("I3D file not found: %s.", self._map_i3d_path)
+            return
+
+        tree = ET.parse(self._map_i3d_path)
+
+        self.logger.debug("Map I3D file loaded from: %s.", self._map_i3d_path)
+
+        root = tree.getroot()
+        for map_elem in root.iter("Scene"):
+            for terrain_elem in map_elem.iter("TerrainTransformGroup"):
+                terrain_elem.set("heightScale", str(DEFAULT_HEIGHT_SCALE))
+                self.logger.debug(
+                    "heightScale attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_HEIGHT_SCALE,
+                )
+                terrain_elem.set("maxLODDistance", str(DEFAULT_MAX_LOD_DISTANCE))
+                self.logger.debug(
+                    "maxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_DISTANCE,
+                )
+
+                terrain_elem.set("occMaxLODDistance", str(DEFAULT_MAX_LOD_OCCLUDER_DISTANCE))
+                self.logger.debug(
+                    "occMaxLODDistance attribute set to %s in TerrainTransformGroup element.",
+                    DEFAULT_MAX_LOD_OCCLUDER_DISTANCE,
+                )
+
+                self.logger.debug("TerrainTransformGroup element updated in I3D file.")
+
+        tree.write(self._map_i3d_path)
+        self.logger.debug("Map I3D file saved to: %s.", self._map_i3d_path)
+
+    def previews(self) -> list[str]:
+        """Returns a list of paths to the preview images (empty list).
+        The component does not generate any preview images so it returns an empty list.
+
+        Returns:
+            list[str]: An empty list.
+        """
+        return []

maps4fs/generator/map.py

@@ -1,10 +1,10 @@
 """This module contains Map class, which is used to generate map using all components."""
 
+from __future__ import annotations
+
 import os
 import shutil
-from typing import Any
-
-from tqdm import tqdm
+from typing import Any, Generator
 
 from maps4fs.generator.component import Component
 from maps4fs.generator.game import Game
@@ -42,11 +42,12 @@ class Map:
         self.map_directory = map_directory
 
         if not logger:
-            logger = Logger(__name__, to_stdout=True, to_file=False)
+            logger = Logger(to_stdout=True, to_file=False)
         self.logger = logger
         self.logger.debug("Game was set to %s", game.code)
 
         self.kwargs = kwargs
+        self.logger.debug("Additional arguments: %s", kwargs)
 
         os.makedirs(self.map_directory, exist_ok=True)
         self.logger.debug("Map directory created: %s", self.map_directory)
@@ -57,31 +58,45 @@ class Map:
         except Exception as e:
             raise RuntimeError(f"Can not unpack map template due to error: {e}") from e
 
-    def generate(self) -> None:
-        """Launch map generation using all components."""
-        with tqdm(total=len(self.game.components), desc="Generating map...") as pbar:
-            for game_component in self.game.components:
-                component = game_component(
-                    self.game,
-                    self.coordinates,
-                    self.height,
-                    self.width,
-                    self.map_directory,
-                    self.logger,
-                    **self.kwargs,
+    def generate(self) -> Generator[str, None, None]:
+        """Launch map generation using all components. Yield component names during the process.
+
+        Yields:
+            Generator[str, None, None]: Component names.
+        """
+        for game_component in self.game.components:
+            component = game_component(
+                self.game,
+                self.coordinates,
+                self.height,
+                self.width,
+                self.map_directory,
+                self.logger,
+                **self.kwargs,
+            )
+
+            yield component.__class__.__name__
+
+            try:
+                component.process()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error processing component %s: %s",
+                    component.__class__.__name__,
+                    e,
+                )
+                raise e
+
+            try:
+                component.commit_generation_info()
+            except Exception as e:  # pylint: disable=W0718
+                self.logger.error(
+                    "Error committing generation info for component %s: %s",
+                    component.__class__.__name__,
+                    e,
                 )
-                try:
-                    component.process()
-                except Exception as e:  # pylint: disable=W0718
-                    self.logger.error(
-                        "Error processing component %s: %s",
-                        component.__class__.__name__,
-                        e,
-                    )
-                    raise e
-                self.components.append(component)
-
-                pbar.update(1)
+                raise e
+            self.components.append(component)
 
     def previews(self) -> list[str]:
         """Get list of preview images.
@@ -101,15 +116,19 @@ class Map:
                 )
         return previews
 
-    def pack(self, archive_name: str) -> str:
+    def pack(self, archive_path: str, remove_source: bool = True) -> str:
         """Pack map directory to zip archive.
 
         Args:
-            archive_name (str): Name of the archive.
+            archive_path (str): Path to the archive.
+            remove_source (bool, optional): Remove source directory after packing.
 
         Returns:
             str: Path to the archive.
         """
-        archive_path = shutil.make_archive(archive_name, "zip", self.map_directory)
-        self.logger.info("Map packed to %s.zip", archive_name)
+        archive_path = shutil.make_archive(archive_path, "zip", self.map_directory)
+        self.logger.info("Map packed to %s.zip", archive_path)
+        if remove_source:
+            shutil.rmtree(self.map_directory)
+            self.logger.info("Map directory removed: %s", self.map_directory)
         return archive_path

maps4fs/generator/path_steps.py

@@ -0,0 +1,83 @@
+"""This module contains functions and clas for generating path steps."""
+
+from typing import NamedTuple
+
+from geopy.distance import distance  # type: ignore
+
+DEFAULT_DISTANCE = 2048
+PATH_FULL_NAME = "FULL"
+
+
+class PathStep(NamedTuple):
+    """Represents parameters of one step in the path.
+
+    Attributes:
+        code {str} -- Tile code (N, NE, E, SE, S, SW, W, NW).
+        angle {int} -- Angle in degrees (for example 0 for North, 90 for East).
+            If None, the step is a full map with a center at the same coordinates as the
+            map itself.
+        distance {int} -- Distance in meters from previous step.
+            If None, the step is a full map with a center at the same coordinates as the
+            map itself.
+        size {tuple[int, int]} -- Size of the tile in pixels (width, height).
+    """
+
+    code: str
+    angle: int | None
+    distance: int | None
+    size: tuple[int, int]
+
+    def get_destination(self, origin: tuple[float, float]) -> tuple[float, float]:
+        """Calculate destination coordinates based on origin and step parameters.
+
+        Arguments:
+            origin {tuple[float, float]} -- Origin coordinates (latitude, longitude)
+
+        Returns:
+            tuple[float, float] -- Destination coordinates (latitude, longitude)
+        """
+        destination = distance(meters=self.distance).destination(origin, self.angle)
+        return destination.latitude, destination.longitude
+
+
+def get_steps(map_height: int, map_width: int) -> list[PathStep]:
+    """Return a list of PathStep objects for each tile, which represent a step in the path.
+    Moving from the center of the map to North, then clockwise.
+
+    Arguments:
+        map_height {int} -- Height of the map in pixels
+        map_width {int} -- Width of the map in pixels
+
+    Returns:
+        list[PathStep] -- List of PathStep objects
+    """
+    # Move clockwise from N and calculate coordinates and sizes for each tile.
+    half_width = int(map_width / 2)
+    half_height = int(map_height / 2)
+
+    half_default_distance = int(DEFAULT_DISTANCE / 2)
+
+    return [
+        PathStep("N", 0, half_height + half_default_distance, (map_width, DEFAULT_DISTANCE)),
+        PathStep(
+            "NE", 90, half_width + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("E", 180, half_height + half_default_distance, (DEFAULT_DISTANCE, map_height)),
+        PathStep(
+            "SE", 180, half_height + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("S", 270, half_width + half_default_distance, (map_width, DEFAULT_DISTANCE)),
+        PathStep(
+            "SW", 270, half_width + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep("W", 0, half_height + half_default_distance, (DEFAULT_DISTANCE, map_height)),
+        PathStep(
+            "NW", 0, half_height + half_default_distance, (DEFAULT_DISTANCE, DEFAULT_DISTANCE)
+        ),
+        PathStep(
+            PATH_FULL_NAME,
+            None,
+            None,
+            (map_width + DEFAULT_DISTANCE * 2, map_height + DEFAULT_DISTANCE * 2),
+        ),
+    ]