maps4fs 2.8.3__py3-none-any.whl → 2.8.5__py3-none-any.whl

maps4fs/generator/component/base/component_mesh.py

@@ -241,7 +241,9 @@ class MeshComponent(Component):
         cube_mesh = trimesh.creation.box([remove_size, remove_size, z_size * 4])
 
         return trimesh.boolean.difference(
-            [mesh_copy, cube_mesh], check_volume=False, engine="blender"
+            [mesh_copy, cube_mesh],
+            check_volume=False,
+            engine="blender",
         )
 
     @staticmethod

maps4fs/generator/component/config.py

@@ -5,12 +5,25 @@ from __future__ import annotations
 import os
 
 import cv2
+import numpy as np
 
+import maps4fs.generator.utils as mfsutils
+from maps4fs.generator.component.base.component_image import ImageComponent
 from maps4fs.generator.component.base.component_xml import XMLComponent
+from maps4fs.generator.settings import Parameters
+
+# Defines coordinates for country block on the license plate texture.
+COUNTRY_CODE_TOP = 169
+COUNTRY_CODE_BOTTOM = 252
+COUNTRY_CODE_LEFT = 74
+COUNTRY_CODE_RIGHT = 140
+
+LICENSE_PLATES_XML_FILENAME = "licensePlatesPL.xml"
+LICENSE_PLATES_I3D_FILENAME = "licensePlatesPL.i3d"
 
 
 # pylint: disable=R0903
-class Config(XMLComponent):
+class Config(XMLComponent, ImageComponent):
     """Component for map settings and configuration.
 
     Arguments:
@@ -36,6 +49,10 @@ class Config(XMLComponent):
         if self.game.fog_processing:
             self._adjust_fog()
 
+        self._set_overview()
+
+        self.update_license_plates()
+
     def _set_map_size(self) -> None:
         """Edits map.xml file to set correct map size."""
         tree = self.get_tree()
@@ -213,3 +230,579 @@ class Config(XMLComponent):
         )
 
         return dem_maximum_meter, dem_minimum_meter
+
+    def _set_overview(self) -> None:
+        """Generates and sets the overview image for the map."""
+        try:
+            overview_image_path = self.game.overview_file_path(self.map_directory)
+        except NotImplementedError:
+            self.logger.warning(
+                "Game does not support overview image file, overview generation will be skipped."
+            )
+            return
+
+        satellite_component = self.map.get_satellite_component()
+        if not satellite_component:
+            self.logger.warning(
+                "Satellite component not found, overview generation will be skipped."
+            )
+            return
+
+        if not satellite_component.assets.overview or not os.path.isfile(
+            satellite_component.assets.overview
+        ):
+            self.logger.warning(
+                "Satellite overview image not found, overview generation will be skipped."
+            )
+            return
+
+        satellite_images_directory = os.path.dirname(satellite_component.assets.overview)
+        overview_image = cv2.imread(satellite_component.assets.overview, cv2.IMREAD_UNCHANGED)
+
+        if overview_image is None:
+            self.logger.warning(
+                "Failed to read satellite overview image, overview generation will be skipped."
+            )
+            return
+
+        resized_overview_image = cv2.resize(
+            overview_image,
+            (Parameters.OVERVIEW_IMAGE_SIZE, Parameters.OVERVIEW_IMAGE_SIZE),
+            interpolation=cv2.INTER_LINEAR,
+        )
+
+        resized_overview_path = os.path.join(
+            satellite_images_directory,
+            f"{Parameters.OVERVIEW_IMAGE_FILENAME}.png",
+        )
+
+        cv2.imwrite(resized_overview_path, resized_overview_image)
+        self.logger.info("Overview image saved to: %s", resized_overview_path)
+
+        if os.path.isfile(overview_image_path):
+            try:
+                os.remove(overview_image_path)
+                self.logger.debug("Old overview image removed: %s", overview_image_path)
+            except Exception as e:
+                self.logger.warning("Failed to remove old overview image: %s", e)
+                return
+
+        self.convert_png_to_dds(resized_overview_path, overview_image_path)
+        self.logger.info("Overview image converted and saved to: %s", overview_image_path)
+
+    @property
+    def supported_countries(self) -> dict[str, str]:
+        """Returns a dictionary of supported countries and their corresponding country codes.
+
+        Returns:
+            dict[str, str]: Supported countries and their country codes.
+        """
+        return {
+            "germany": "DE",
+            "austria": "A",
+            "switzerland": "CH",
+            "france": "F",
+            "italy": "I",
+            "spain": "E",
+            "portugal": "P",
+            "netherlands": "NL",
+            "belgium": "B",
+            "luxembourg": "L",
+            "poland": "PL",
+            "czech republic": "CZ",
+            "slovakia": "SK",
+            "hungary": "H",
+            "slovenia": "SLO",
+            "croatia": "HR",
+            "bosnia and herzegovina": "BIH",
+            "serbia": "SRB",
+            "north macedonia": "MKD",
+            "greece": "GR",
+            "turkey": "TR",
+        }
+
+    @property
+    def eu_countries(self) -> set[str]:
+        """Returns a set of country codes that are in the European Union.
+
+        Returns:
+            set[str]: Set of country codes in the EU.
+        """
+        return {
+            "DE",
+            "A",
+            "CH",
+            "F",
+            "I",
+            "E",
+            "P",
+            "NL",
+            "B",
+            "L",
+            "PL",
+            "CZ",
+            "SK",
+            "H",
+            "SLO",
+            "HR",
+        }
+
+    def update_license_plates(self):
+        """Updates license plates for the specified country."""
+        try:
+            license_plates_directory = self.game.license_plates_dir_path(self.map_directory)
+        except NotImplementedError:
+            self.logger.warning("Game does not support license plates processing.")
+            return
+
+        country_name = mfsutils.get_country_by_coordinates(self.map.coordinates).lower()
+        if country_name not in self.supported_countries:
+            self.logger.warning(
+                "License plates processing is not supported for country: %s.", country_name
+            )
+            return
+
+        # Get license plate country code and EU format.
+        country_code = self.supported_countries[country_name]
+        eu_format = country_code in self.eu_countries
+
+        self.logger.info(
+            "Updating license plates for country: %s, EU format: %s",
+        )
+
+        license_plates_prefix = self.map.i3d_settings.license_plate_prefix
+        if len(license_plates_prefix) < 1 or len(license_plates_prefix) > 3:
+            self.logger.error(
+                "Invalid license plate prefix: %s. It must be 1 to 3 characters long.",
+                license_plates_prefix,
+            )
+            return
+
+        try:
+            # 1. Update licensePlatesPL.xml with license plate prefix.
+            self._update_license_plates_xml(license_plates_directory, license_plates_prefix)
+
+            # 2. Update licensePlatesPL.i3d texture reference depending on EU format.
+            self._update_license_plates_i3d(license_plates_directory, eu_format)
+
+            # 3. Generate texture with country code.
+            self._generate_license_plate_texture(
+                license_plates_directory,
+                country_code,
+                eu_format,
+                COUNTRY_CODE_LEFT,
+                COUNTRY_CODE_TOP,
+                COUNTRY_CODE_RIGHT,
+                COUNTRY_CODE_BOTTOM,
+            )
+
+            self.logger.info("License plates updated successfully")
+        except Exception as e:
+            self.logger.error("Failed to update license plates: %s", e)
+            return
+
+        # Edit the map.xml only if all previous steps succeeded.
+        self._update_map_xml_license_plates()
+
+    def _update_map_xml_license_plates(self) -> None:
+        """Update map.xml to reference PL license plates.
+
+        Raises:
+            FileNotFoundError: If the map XML file is not found.
+            ValueError: If the map XML root element is None.
+        """
+        tree = self.get_tree()
+        if not tree:
+            raise FileNotFoundError(f"Map XML file not found: {self.xml_path}")
+
+        root = tree.getroot()
+
+        if root is None:
+            raise ValueError("Map XML root element is None.")
+
+        # Find or create licensePlates element
+        license_plates_element = root.find(".//licensePlates")
+        if license_plates_element is not None:
+            license_plates_element.set("filename", "map/licensePlates/licensePlatesPL.xml")
+        else:
+            # Create new licensePlates element if it doesn't exist
+            license_plates_element = root.makeelement(
+                "licensePlates", {"filename": "map/licensePlates/licensePlatesPL.xml"}
+            )
+            root.append(license_plates_element)
+
+        self.save_tree(tree)
+        self.logger.debug("Updated map.xml to use PL license plates")
+
+    def _update_license_plates_xml(
+        self, license_plates_directory: str, license_plate_prefix: str
+    ) -> None:
+        """Update licensePlatesPL.xml with license plate prefix.
+
+        Arguments:
+            license_plates_directory (str): Directory where license plates XML is located.
+            license_plate_prefix (str): The prefix to set on the license plates.
+
+        Raises:
+            FileNotFoundError: If the license plates XML file is not found.
+            ValueError: If required XML elements are not found.
+        """
+        xml_path = os.path.join(license_plates_directory, LICENSE_PLATES_XML_FILENAME)
+        if not os.path.isfile(xml_path):
+            raise FileNotFoundError(f"License plates XML file not found: {xml_path}.")
+
+        tree = self.get_tree(xml_path=xml_path)
+        root = tree.getroot()
+        if root is None:
+            raise ValueError("License plates XML root element is None.")
+
+        # Find licensePlate with node="0"
+        license_plate = None
+        for plate in root.findall(".//licensePlate"):
+            if plate.get("node") == "0":
+                license_plate = plate
+                break
+
+        if license_plate is None:
+            raise ValueError("Could not find licensePlate element with node='0'")
+
+        # Find first variations/variation element
+        variations = license_plate.find("variations")
+        if variations is None:
+            raise ValueError("Could not find variations element")
+
+        variation = variations.find("variation")
+        if variation is None:
+            raise ValueError("Could not find first variation element")
+
+        # 1. Update license plate prefix to ensure max 3 letters, uppercase.
+        license_plate_prefix = license_plate_prefix.upper()[:3]
+
+        # 2. Position X values for the letters.
+        pos_x_values = ["-0.1712", "-0.1172", "-0.0632"]  # ? DO WE REALLY NEED THEM?
+
+        # 3. Update only the first 3 values (prefix letters), leave others intact.
+        # Find and update nodes 0|0, 0|1, 0|2 specifically.
+        for i, letter in enumerate(license_plate_prefix):
+            target_node = f"0|{i}"
+            # Find existing value with this node ID.
+            existing_value = None
+            for value in variation.findall("value"):
+                if value.get("node") == target_node:
+                    existing_value = value
+                    break
+
+            if existing_value is not None:
+                # Update existing value.
+                existing_value.set("character", letter)
+                existing_value.set("posX", pos_x_values[i])
+                existing_value.set("numerical", "false")
+                existing_value.set("alphabetical", "true")
+            else:
+                # Create new value if it doesn't exist.
+                value_elem = root.makeelement(
+                    "value",
+                    {
+                        "node": target_node,
+                        "character": letter,
+                        "posX": pos_x_values[i],
+                        "numerical": "false",
+                        "alphabetical": "true",
+                    },
+                )
+                # Insert at the beginning to maintain order.
+                variation.insert(i, value_elem)
+
+        # 5. Save the updated XML.
+        self.save_tree(tree, xml_path=xml_path)
+        self.logger.debug(
+            "Updated licensePlatesPL.xml with license plate prefix: %s", license_plate_prefix
+        )
+
+    def _update_license_plates_i3d(self, license_plates_directory: str, eu_format: bool) -> None:
+        """Update licensePlatesPL.i3d texture reference.
+
+        Arguments:
+            license_plates_directory (str): Directory where license plates i3d is located.
+            eu_format (bool): Whether to use EU format texture.
+
+        Raises:
+            FileNotFoundError: If the license plates i3d file is not found.
+            ValueError: If required XML elements are not found.
+        """
+        i3d_path = os.path.join(license_plates_directory, LICENSE_PLATES_I3D_FILENAME)
+        if not os.path.isfile(i3d_path):
+            raise FileNotFoundError(f"License plates i3d file not found: {i3d_path}")
+
+        # 1. Load the i3d XML.
+        tree = self.get_tree(xml_path=i3d_path)
+        root = tree.getroot()
+
+        if root is None:
+            raise ValueError("License plates i3d XML root element is None.")
+
+        # 2. Find File element with fileId="12"
+        file_element = None
+        for file_elem in root.findall(".//File"):
+            if file_elem.get("fileId") == "12":
+                file_element = file_elem
+                break
+
+        if file_element is None:
+            raise ValueError("Could not find File element with fileId='12'")
+
+        # 3. Update filename to point to local map directory (relative path).
+        if eu_format:
+            filename = "licensePlates_diffuseEU.png"
+        else:
+            filename = "licensePlates_diffuse.png"
+
+        file_element.set("filename", filename)
+
+        # 4. Save the updated i3d XML.
+        self.save_tree(tree, xml_path=i3d_path)
+        self.logger.debug("Updated licensePlatesPL.i3d texture reference to: %s", filename)
+
+    def _generate_license_plate_texture(
+        self,
+        license_plates_directory: str,
+        country_code: str,
+        eu_format: bool,
+        left: int,
+        top: int,
+        right: int,
+        bottom: int,
+    ) -> None:
+        """Generate license plate texture with country code.
+
+        Arguments:
+            license_plates_directory (str): Directory where license plates textures are located.
+            country_code (str): The country code to render on the license plate.
+            eu_format (bool): Whether to use EU format texture.
+            left (int): Left coordinate of the country code box.
+            top (int): Top coordinate of the country code box.
+            right (int): Right coordinate of the country code box.
+            bottom (int): Bottom coordinate of the country code box.
+
+        Raises:
+            FileNotFoundError: If the base texture file is not found.
+            ValueError: If there is an error generating the texture.
+        """
+        # 1. Define the path to the base texture depending on EU format.
+        if eu_format:
+            texture_filename = "licensePlates_diffuseEU.png"
+        else:
+            texture_filename = "licensePlates_diffuse.png"
+
+        # 2. Check if the base texture file exists.
+        texture_path = os.path.join(license_plates_directory, texture_filename)
+        if not os.path.isfile(texture_path):
+            self.logger.warning("Base texture file not found: %s.", texture_path)
+            raise FileNotFoundError(f"Base texture file not found: {texture_path}")
+
+        # 3. Load the base texture.
+        texture = cv2.imread(texture_path, cv2.IMREAD_UNCHANGED)
+        if texture is None:
+            raise ValueError(f"Could not load base texture: {texture_path}")
+
+        # 4. Calculate text box dimensions.
+        box_width = right - left
+        box_height = bottom - top
+
+        # 5. Define font and fit text in rotated box.
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        thickness = 3
+        font_scale, large_canvas_size = self.fit_text_in_rotated_box(
+            country_code,
+            box_width,
+            box_height,
+            font,
+            thickness,
+        )
+
+        # 6. Create the actual text image (black background for white text).
+        text_img = np.zeros((large_canvas_size, large_canvas_size, 3), dtype=np.uint8)
+        text_size = cv2.getTextSize(country_code, font, font_scale, thickness)[0]
+
+        # 7. Center text on canvas.
+        text_x = (large_canvas_size - text_size[0]) // 2
+        text_y = (large_canvas_size + text_size[1]) // 2
+
+        # 8. Use white text on black background with anti-aliasing.
+        cv2.putText(
+            text_img,
+            country_code,
+            (text_x, text_y),
+            font,
+            font_scale,
+            (255, 255, 255),
+            thickness,
+            lineType=cv2.LINE_AA,
+        )
+
+        # 9. Rotate the text image 90 degrees clockwise.
+        rotated_text_rgb = cv2.rotate(text_img, cv2.ROTATE_90_CLOCKWISE)
+
+        # 10. Find bounding box and crop to content (looking for white pixels).
+        gray = cv2.cvtColor(rotated_text_rgb, cv2.COLOR_BGR2GRAY)
+        coords = np.column_stack(np.where(gray > 0))
+
+        # 11. Crop the rotated text image to the bounding box of the text.
+        if len(coords) > 0:
+            y_min, x_min = coords.min(axis=0)
+            y_max, x_max = coords.max(axis=0)
+
+            # Crop to content with small padding
+            padding = 2
+            y_min = max(0, y_min - padding)
+            x_min = max(0, x_min - padding)
+            y_max = min(rotated_text_rgb.shape[0], y_max + padding)
+            x_max = min(rotated_text_rgb.shape[1], x_max + padding)
+
+            cropped_text_rgb = rotated_text_rgb[y_min:y_max, x_min:x_max]
+
+            # Convert to RGBA with proper alpha
+            cropped_height, cropped_width = cropped_text_rgb.shape[:2]
+            rotated_text = np.zeros((cropped_height, cropped_width, 4), dtype=np.uint8)
+            rotated_text[:, :, :3] = cropped_text_rgb
+
+            # Set alpha: opaque for text (white pixels), transparent for background
+            text_mask = np.any(cropped_text_rgb > 0, axis=2)
+            rotated_text[text_mask, 3] = 255  # Opaque text
+            rotated_text[~text_mask, 3] = 0  # Transparent background
+        else:
+            raise ValueError("No text found in the generated image.")
+
+        # 12. Ensure the texture is RGBA.
+        if texture.shape[2] == 3:
+            # Convert RGB to RGBA
+            texture_rgba = np.zeros((texture.shape[0], texture.shape[1], 4), dtype=np.uint8)
+            texture_rgba[:, :, :3] = texture
+            texture_rgba[:, :, 3] = 255  # Fully opaque
+            texture = texture_rgba
+
+        # 13. Place the rotated text in the texture.
+        h, w = rotated_text.shape[:2]
+
+        # 14. Center the text within the target box.
+        center_x = left + (box_width - w) // 2
+        center_y = top + (box_height - h) // 2
+
+        # 15. Ensure the centered text fits within texture bounds.
+        if (
+            center_y >= 0
+            and center_x >= 0
+            and center_y + h <= texture.shape[0]
+            and center_x + w <= texture.shape[1]
+        ):
+            # Extract the region where text will be placed
+            texture_region = texture[center_y : center_y + h, center_x : center_x + w]
+
+            # Alpha blend the text onto the texture
+            alpha = rotated_text[:, :, 3:4] / 255.0
+
+            # Blend only the RGB channels
+            texture[center_y : center_y + h, center_x : center_x + w, :3] = (
+                rotated_text[:, :, :3] * alpha + texture_region[:, :, :3] * (1 - alpha)
+            ).astype(np.uint8)
+
+            # Update alpha channel where text is present
+            texture[center_y : center_y + h, center_x : center_x + w, 3] = np.maximum(
+                texture_region[:, :, 3], rotated_text[:, :, 3]
+            )
+
+            self.logger.debug(
+                "Text placed at centered position: (%s,%s) size: %sx%s",
+                center_x,
+                center_y,
+                w,
+                h,
+            )
+        else:
+            self.logger.warning(
+                "Centered text position (%s,%s) with size %sx%s would exceed texture bounds",
+                center_x,
+                center_y,
+                w,
+                h,
+            )
+
+        # 16. Save the modified texture.
+        cv2.imwrite(texture_path, texture)
+        self.logger.debug(
+            "Generated license plate texture with country code %s at: %s",
+            country_code,
+            texture_path,
+        )
+
+    def fit_text_in_rotated_box(
+        self,
+        text: str,
+        box_width: int,
+        box_height: int,
+        font: int,
+        thickness: int,
+    ) -> tuple[float, int]:
+        """Fits text into a rotated box by adjusting font size.
+
+        Arguments:
+            text (str): The text to fit.
+            box_width (int): The width of the box.
+            box_height (int): The height of the box.
+            font (int): The OpenCV font to use.
+            thickness (int): The thickness of the text.
+
+        Returns:
+            tuple[float, int]: The calculated font scale and the size of the large canvas used.
+        """
+        font_scale = min(box_height / (len(text) * 10), box_width / 22)
+
+        # Create a large canvas to render text without clipping
+        large_canvas_size = max(box_width, box_height) * 2
+
+        # Iteratively reduce font size until rotated text fits
+        for _ in range(15):  # More iterations for better fitting
+            # Test on a large canvas first (black background for white text)
+            test_img = np.zeros((large_canvas_size, large_canvas_size, 3), dtype=np.uint8)
+            text_size = cv2.getTextSize(text, font, font_scale, thickness)[0]
+
+            # Center text on large canvas
+            text_x = (large_canvas_size - text_size[0]) // 2
+            text_y = (large_canvas_size + text_size[1]) // 2
+
+            # Use white text for testing with anti-aliasing
+            cv2.putText(
+                test_img,
+                text,
+                (text_x, text_y),
+                font,
+                font_scale,
+                (255, 255, 255),
+                thickness,
+                lineType=cv2.LINE_AA,  # Anti-aliasing for smooth edges
+            )
+
+            # Rotate the test image
+            rotated_test = cv2.rotate(test_img, cv2.ROTATE_90_CLOCKWISE)
+
+            # Find the bounding box of non-black pixels
+            gray = cv2.cvtColor(rotated_test, cv2.COLOR_BGR2GRAY)
+            coords = np.column_stack(np.where(gray > 0))
+
+            if len(coords) > 0:
+                y_min, x_min = coords.min(axis=0)
+                y_max, x_max = coords.max(axis=0)
+                rotated_width = x_max - x_min + 1
+                rotated_height = y_max - y_min + 1
+
+                # Check if the rotated text fits in our target box with good margin
+                if rotated_width <= box_width * 0.90 and rotated_height <= box_height * 0.90:
+                    break
+
+            font_scale *= 0.93  # Reduce by 7% each iteration
+
+        self.logger.debug("Final font scale: %s, Original text size: %s", font_scale, text_size)
+        if len(coords) > 0:
+            self.logger.debug("Rotated text dimensions: %sx%s", rotated_width, rotated_height)
+
+        return font_scale, large_canvas_size

maps4fs/generator/game.py

@@ -180,6 +180,16 @@ class Game:
             str: The path to the weights directory."""
         raise NotImplementedError
 
+    def license_plates_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the license plates directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the license plates directory."""
+        raise NotImplementedError
+
     def get_density_map_fruits_path(self, map_directory: str) -> str:
         """Returns the path to the density map fruits file.
 
@@ -254,6 +264,16 @@ class Game:
             str: The path to the i3d file."""
         raise NotImplementedError
 
+    def overview_file_path(self, map_directory: str) -> str:
+        """Returns the path to the overview image file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the overview image file."""
+        raise NotImplementedError
+
     @property
     def i3d_processing(self) -> bool:
         """Returns whether the i3d file should be processed.
@@ -408,6 +428,16 @@ class FS25(Game):
             str: The path to the weights directory."""
         return os.path.join(map_directory, "map", "data")
 
+    def license_plates_dir_path(self, map_directory: str) -> str:
+        """Returns the path to the license plates directory.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the license plates directory."""
+        return os.path.join(map_directory, "map", "licensePlates")
+
     def i3d_file_path(self, map_directory: str) -> str:
         """Returns the path to the i3d file.
 
@@ -437,3 +467,13 @@ class FS25(Game):
         Returns:
             str: The path to the environment xml file."""
         return os.path.join(map_directory, "map", "config", "environment.xml")
+
+    def overview_file_path(self, map_directory: str) -> str:
+        """Returns the path to the overview image file.
+
+        Arguments:
+            map_directory (str): The path to the map directory.
+
+        Returns:
+            str: The path to the overview image file."""
+        return os.path.join(map_directory, "map", "overview.dds")

maps4fs/generator/settings.py

@@ -55,6 +55,9 @@ class Parameters:
 
     HEIGHT_SCALE = "heightScale"
 
+    OVERVIEW_IMAGE_SIZE = 4096
+    OVERVIEW_IMAGE_FILENAME = "overview"
+
 
 class SharedSettings(BaseModel):
     """Represents the shared settings for all components."""
@@ -233,6 +236,7 @@ class I3DSettings(SettingsModel):
             existing points.
         add_reversed_splines (bool): if True, reversed splines will be added to the map.
         field_splines (bool): if True, splines will be added to the fields.
+        license_plate_prefix (str): prefix for the license plates.
     """
 
     add_trees: bool = True
@@ -244,6 +248,8 @@ class I3DSettings(SettingsModel):
     add_reversed_splines: bool = False
     field_splines: bool = False
 
+    license_plate_prefix: str = "M4S"
+
 
 class TextureSettings(SettingsModel):
     """Represents the advanced settings for texture component.

{maps4fs-2.8.3.dist-info → maps4fs-2.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maps4fs
-Version: 2.8.3
+Version: 2.8.5
 Summary: Generate map templates for Farming Simulator from real places.
 Author-email: iwatkot <iwatkot@gmail.com>
 License: GNU Affero General Public License v3.0

{maps4fs-2.8.3.dist-info → maps4fs-2.8.5.dist-info}/RECORD

@@ -2,15 +2,15 @@ maps4fs/__init__.py,sha256=5ixsCA5vgcIV0OrF9EJBm91Mmc_KfMiDRM-QyifMAvo,386
 maps4fs/logger.py,sha256=6sem0aFKQqtVjQ_yNu9iGcc-hqzLQUhfxco05K6nqow,763
 maps4fs/generator/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/config.py,sha256=KwYYWM5wrMB_tKn3Fls6WpEurZJxmrBH5AgAXPGHTJE,7122
-maps4fs/generator/game.py,sha256=sNyPNHGd5bEi7-00l5_MVp62KnBmH-OIIabeDwFEepc,14767
+maps4fs/generator/game.py,sha256=_LNiH__7FeSGsPKsuvAGiktt5GcJQVqcQYtsFZNWGyM,16106
 maps4fs/generator/map.py,sha256=ZZRU8x0feGbgeJgxc0D3N-mfiasyFXxj6gbGyl-WRzE,14528
 maps4fs/generator/qgis.py,sha256=Es8hLuqN_KH8lDfnJE6He2rWYbAKJ3RGPn-o87S6CPI,6116
-maps4fs/generator/settings.py,sha256=4CDyJdKthVAT5I78_1gcruZVK4TYD1ctklAZBwvFwCM,13226
+maps4fs/generator/settings.py,sha256=_QJL4ikQYLFOIB1zWqXjYvyLfoh3cr2RYb2IzsunMJg,13405
 maps4fs/generator/statistics.py,sha256=Dp1-NS-DWv0l0UdmhOoXeQs_N-Hs7svYUnmziSW5Z9I,2098
 maps4fs/generator/utils.py,sha256=ugdQ8C22NeiZLIlldLoEKCc7ioOefz4W-8qF2eOy9qU,4834
 maps4fs/generator/component/__init__.py,sha256=s01yVVVi8R2xxNvflu2D6wTd9I_g73AMM2x7vAC7GX4,490
 maps4fs/generator/component/background.py,sha256=tFWdYASUUZsJ8QiQrxxba-6aMECD3hvpd0pMm_UdrH8,46151
-maps4fs/generator/component/config.py,sha256=uL76h9UwyhZKZmbxz0mBmWtEPN6qYay4epTEqqtej60,8601
+maps4fs/generator/component/config.py,sha256=oDA0UWrf2ZPxjJgbZHFJuBTp2DZJq2IROj7lzT9ePwE,31078
 maps4fs/generator/component/dem.py,sha256=FPqcXmFQg5MPaGuy4g5kxzvY1wbhozeCf-aNMCj5eaU,11687
 maps4fs/generator/component/grle.py,sha256=0PC1K829wjD4y4d9qfIbnU29ebjflIPBbwIZx8FXwc8,27242
 maps4fs/generator/component/i3d.py,sha256=RvpiW9skkZ6McyahC-AeIdPuSQjpXiFs1l0xOioJAu4,26638
@@ -20,10 +20,10 @@ maps4fs/generator/component/texture.py,sha256=gXZgr73ehT3_qjuIku0j7N7exloywtmmEQ
 maps4fs/generator/component/base/__init__.py,sha256=zZMLEkGzb4z0xql650gOtGSvcgX58DnJ2yN3vC2daRk,43
 maps4fs/generator/component/base/component.py,sha256=-7H3donrH19f0_rivNyI3fgLsiZkntXfGywEx4tOnM4,23924
 maps4fs/generator/component/base/component_image.py,sha256=GXFkEFARNRkWkDiGSjvU4WX6f_8s6R1t2ZYqZflv1jk,9626
-maps4fs/generator/component/base/component_mesh.py,sha256=plCLS4O8XsVzAtaRi9lm7a8LnS1dcJ7-mqUpVMvCPAg,24704
+maps4fs/generator/component/base/component_mesh.py,sha256=S5M_SU-FZz17-LgzTIM935ms1Vc4O06UQNTEN4e0INU,24729
 maps4fs/generator/component/base/component_xml.py,sha256=MT-VhU2dEckLFxAgmxg6V3gnv11di_94Qq6atfpOLdc,5342
-maps4fs-2.8.3.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
-maps4fs-2.8.3.dist-info/METADATA,sha256=R4Nh5jeZ3nPZUSZ2KQEG73Sh6mC-MI_jv2_GN7FJw0A,10042
-maps4fs-2.8.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-maps4fs-2.8.3.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
-maps4fs-2.8.3.dist-info/RECORD,,
+maps4fs-2.8.5.dist-info/licenses/LICENSE.md,sha256=Ptw8AkqJ60c4tRts6yuqGP_8B0dxwOGmJsp6YJ8dKqM,34328
+maps4fs-2.8.5.dist-info/METADATA,sha256=spNUf5QNjPOszSmK34GWb6ek7Vt0jlwc6MUUe0p1k3g,10042
+maps4fs-2.8.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+maps4fs-2.8.5.dist-info/top_level.txt,sha256=Ue9DSRlejRQRCaJueB0uLcKrWwsEq9zezfv5dI5mV1M,8
+maps4fs-2.8.5.dist-info/RECORD,,