Initial commit.

Maps can be downloaded from Dynmap using Minecraft coordinates.

Author: ryanbester

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+.idea/
+build/
+venv/
+dist/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ryan Bester
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,3 @@
+# Minecraft Map Tools
+
+A tool to download maps from Dynmap and JourneyMap.

build.bat

@@ -0,0 +1,2 @@
+call .\venv\Scripts\activate
+start pyinstaller main.spec

controllers/about.py

@@ -0,0 +1,15 @@
+import webbrowser
+
+from controllers.controller import Controller
+
+
+class AboutController(Controller):
+    base_url = 'https://github.com/ryanbester/minecraft-map-tools'
+
+    @staticmethod
+    def open_github_link():
+        webbrowser.open_new(AboutController.base_url)
+
+    @staticmethod
+    def open_issues_link():
+        webbrowser.open_new('{}/issues'.format(AboutController.base_url))

controllers/configprovider.py

@@ -0,0 +1,35 @@
+import json
+import os
+
+from models.config import Config
+from models.server import Server
+
+
+class ConfigProvider:
+    def __init__(self, config: Config, config_dir: str, filename: str):
+        self.config = config
+        self.config_dir = config_dir
+        self.filename = filename
+
+    def ensure_dir_exists(self):
+        os.makedirs(self.config_dir, exist_ok=True)
+
+    def read_config(self):
+        self.ensure_dir_exists()
+
+        try:
+            with open(os.path.join(self.config_dir, self.filename), 'r') as f:
+                config = json.load(f)
+                self.config.servers = []
+                for server in config['servers']:
+                    self.config.servers.append(Server(
+                        server['name'], server['dynmap_url'], server['journeymap_url'], server['ignore_ssl_cert']
+                    ))
+        except (OSError, json.JSONDecodeError, KeyError):
+            self.config.servers = []
+
+    def save_config(self):
+        self.ensure_dir_exists()
+
+        with open(os.path.join(self.config_dir, self.filename), 'w') as f:
+            json.dump(self.config, f, default=vars)

controllers/controller.py

@@ -0,0 +1,14 @@
+from models.config import Config
+from core.state import State
+from views.view import View
+
+
+class Controller:
+    def __init__(self, base_dir: str, config: Config, state: State, view: View):
+        self.base_dir = base_dir
+        self.config = config
+        self.state = state
+        self.view = view
+
+    def build_view(self, parent):
+        self.view.build_view(parent, self)

controllers/download.py

@@ -0,0 +1,107 @@
+import os.path
+from threading import Thread
+from typing import Optional
+
+from controllers.controller import Controller
+from core.dynmap import Dynmap
+from core.dynmapcoords import DynmapCoords
+from core.map import Map
+from core.state import State
+from models.config import Config
+from views.view import View
+
+
+class DownloadMcCoordsController(Controller):
+    pass
+
+
+class DownloadGridRefController(Controller):
+    pass
+
+
+class DownloadDynmapTileController(Controller):
+    pass
+
+
+class DownloadController(Controller):
+    progress: int
+    progress_msg: str
+    download_thread: Optional[Thread]
+
+    def __init__(self, base_dir: str, config: Config, state: State, view: View,
+                 mc_coords_controller: DownloadMcCoordsController,
+                 grid_ref_controller: DownloadGridRefController,
+                 dynmap_tile_controller: DownloadDynmapTileController):
+        super().__init__(base_dir, config, state, view)
+        self.mc_coords_controller = mc_coords_controller
+        self.grid_ref_controller = grid_ref_controller
+        self.dynmap_tile_controller = dynmap_tile_controller
+
+        self.download_thread = None
+
+    def server_change(self):
+        self.view.server_change()
+
+    def start_download(self):
+        self.progress_msg = ''
+        self.progress = 0
+        self.download_thread = Thread(target=self.download)
+        self.download_thread.start()
+        self.view.poll_progress()
+
+    # noinspection PyBroadException
+    def download(self):
+        try:
+            user_input = self.view.get_input()
+        except ValueError as e:
+            self.view.display_error(str(e))
+            return
+
+        tiles_dir = os.path.join(user_input['output_dir'], 'tiles')
+
+        try:
+            if not os.path.isdir(tiles_dir):
+                os.makedirs(tiles_dir)
+        except OSError:
+            self.view.display_error('Failed to create tiles directory')
+            return
+
+        input_range = user_input['range']
+
+        if user_input['source'] == 'Dynmap':
+            dynmap_config = Dynmap.get_config(self.state.selected_server)
+            map_obj = Dynmap.get_map_obj(dynmap_config, user_input['map_id'])
+
+            if user_input['coord_mode'] == 'mc':
+                from_tile_x, from_tile_y = DynmapCoords.mc_to_tile(map_obj, input_range['zoom'],
+                                                                   input_range['from_x'], input_range['from_y'],
+                                                                   input_range['from_z']
+                                                                   )
+                to_tile_x, to_tile_y = DynmapCoords.mc_to_tile(map_obj, input_range['zoom'],
+                                                               input_range['to_x'], input_range['to_y'],
+                                                               input_range['to_z']
+                                                               )
+
+                map_id = user_input['map_id'].split(' - ')
+                world_name, map_name = map_id[0], map_id[1]
+
+                try:
+                    stitch_args = Dynmap.download_tiles(tiles_dir, self.state.selected_server.dynmap_url, world_name,
+                                                        map_name,
+                                                        input_range['zoom'], from_tile_x, from_tile_y,
+                                                        to_tile_x, to_tile_y, self.update_progress)
+                except Exception:
+                    self.view.display_error('Failed to download tiles')
+                    return
+
+                try:
+                    Map.stitch(tiles_dir, user_input['output_dir'], stitch_args, self.update_progress)
+                except Exception:
+                    self.view.display_error('Failed to stitch tiles')
+                    return
+
+            self.update_progress('Idle', 0, 1)
+
+    def update_progress(self, message: str, i, total):
+        self.progress_msg = message
+        self.progress = int((i / total) * 100)

controllers/main.py

@@ -0,0 +1,20 @@
+from controllers.about import AboutController
+from controllers.controller import Controller
+from controllers.download import DownloadController
+from controllers.servers import ServersController
+from controllers.utilities import UtilitiesController
+from core.state import State
+from models.config import Config
+from views.view import View
+
+
+class MainController(Controller):
+    def __init__(self, base_dir: str, config: Config, state: State, view: View, servers_controller: ServersController,
+                 download_controller: DownloadController, utilities_controller: UtilitiesController,
+                 about_controller: AboutController):
+        super().__init__(base_dir, config, state, view)
+
+        self.servers_controller = servers_controller
+        self.download_controller = download_controller
+        self.utilities_controller = utilities_controller
+        self.about_controller = about_controller

controllers/servers.py

@@ -0,0 +1,110 @@
+import tkinter.messagebox
+from typing import Callable
+
+import validators
+
+from controllers.configprovider import ConfigProvider
+from controllers.controller import Controller
+from core.state import State
+from models.config import Config
+from models.server import Server
+from views.view import View
+
+
+class EditServerController(Controller):
+    update_servers_dropdown: Callable
+    title: str
+    server: Server
+
+    def __init__(self, base_dir: str, config: Config, state: State, view: View, config_provider: ConfigProvider):
+        super().__init__(base_dir, config, state, view)
+        self.config_provider = config_provider
+
+    def build_view(self, parent, update_servers_dropdown: Callable = None, title='Edit Server', server: Server = None):
+        self.update_servers_dropdown = update_servers_dropdown
+        self.title = title
+        self.server = server
+        super().build_view(parent)
+
+    def save(self):
+        try:
+            input_server: Server = self.view.get_input()
+        except ValueError as e:
+            self.view.display_error(str(e))
+            return
+
+        if len(input_server.name) < 1:
+            self.view.display_error('Server name cannot be blank')
+            return
+
+        if len(input_server.dynmap_url) > 0 and validators.url(input_server.dynmap_url) is not True:
+            self.view.display_error('Dynmap URL is not valid')
+            return
+
+        if len(input_server.journeymap_url) > 0 and validators.url(input_server.journeymap_url) is not True:
+            self.view.display_error('JourneyMap URL is not valid')
+            return
+
+        if self.server is not None:
+            # Edit existing
+            to_update = None
+            for config_server in self.config.servers:
+                if config_server.name == self.server.name:
+                    to_update = config_server
+
+            if to_update is not None:
+                to_update.name = input_server.name
+                to_update.dynmap_url = input_server.dynmap_url
+                to_update.journeymap_url = input_server.journeymap_url
+                to_update.ignore_ssl_cert = input_server.ignore_ssl_cert
+        else:
+            # Add new
+            self.config.servers.append(input_server)
+
+        try:
+            self.config_provider.save_config()
+        except (OSError, ValueError):
+            self.view.display_error('Failed to save server details')
+            return
+
+        if self.update_servers_dropdown is not None:
+            self.update_servers_dropdown()
+
+        self.state.call_server_change_callbacks()
+
+        self.view.edit_server_win.destroy()
+
+
+class ServersController(Controller):
+    def __init__(self, base_dir: str, config: Config, state: State, view: View, config_provider: ConfigProvider,
+                 edit_server_controller: EditServerController):
+        super().__init__(base_dir, config, state, view)
+        self.config_provider = config_provider
+        self.edit_server_controller = edit_server_controller
+
+    def select_server(self, server_name):
+        for config_server in self.config.servers:
+            if config_server.name == server_name:
+                self.state.selected_server = config_server
+        self.state.call_server_change_callbacks()
+
+    def add_server(self):
+        self.edit_server_controller.build_view(self.state.main_win, self.view.update_servers_dropdown, 'Add server')
+
+    def edit_server(self):
+        self.edit_server_controller.build_view(self.state.main_win, self.view.update_servers_dropdown,
+                                               server=self.state.selected_server)
+
+    def delete_server(self):
+        for config_server in self.config.servers:
+            if config_server.name == self.state.selected_server.name:
+                self.config.servers.remove(config_server)
+
+        try:
+            self.config_provider.save_config()
+        except (OSError, ValueError):
+            tkinter.messagebox.showerror(self.state.main_win.title(), 'Failed to save servers')
+            return
+
+        self.view.update_servers_dropdown()
+        self.state.call_server_change_callbacks()