finland2mc 0.1.0__tar.gz

finland2mc-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,44 @@
+name: publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: astral-sh/setup-uv@v10.3.2
+      - name: Check that the tag matches the version
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          grep -qxF "version = \"$version\"" pyproject.toml \
+            || { echo "::error::pyproject.toml doesn't have version $version"; exit 1; }
+          grep -qxF "__version__ = \"$version\"" finland2mc/__init__.py \
+            || { echo "::error::finland2mc/__init__.py doesn't have version $version"; exit 1; }
+      - run: uv run --python 3.13 pytest -q
+      - run: uv build
+      - uses: actions/upload-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/finland2mc
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

finland2mc-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,13 @@
+name: test
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv run --python 3.13 pytest -q

finland2mc-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.egg-info/
+build/
+dist/
+.pytest_cache/
+# generated worlds and their preview maps
+worlds/

finland2mc-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

finland2mc-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Topi Autio
+
+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.

finland2mc-0.1.0/PKG-INFO

@@ -0,0 +1,169 @@
+Metadata-Version: 2.5
+Name: finland2mc
+Version: 0.1.0
+Summary: Turn any place in Finland into a 1:1 Minecraft Java Edition world from National Land Survey open data
+Project-URL: Homepage, https://github.com/topiautio/finland2mc
+Author: Topi Autio
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: <3.14,>=3.12
+Requires-Dist: laspy[lazrs]
+Requires-Dist: nbtlib
+Requires-Dist: numpy
+Requires-Dist: pillow
+Requires-Dist: pyogrio
+Requires-Dist: pyproj
+Requires-Dist: rasterio
+Requires-Dist: scipy
+Requires-Dist: shapely>=2
+Description-Content-Type: text/markdown
+
+# finland2mc
+
+Give it a place in Finland and it builds a 1:1 Minecraft Java Edition world of it: one block is one metre,
+horizontally and vertically. Everything comes from the National Land Survey of Finland's open data: terrain,
+lakes and sea, roads, bridges, buildings, fields, and trees placed where laser scans found them.
+
+| Jyväskylä | Naantali | Keuruu |
+|---|---|---|
+| ![Jyväskylä](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/jyvaskyla.jpg) | ![Naantali](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/naantali.jpg) | ![Keuruu](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/keuruu.jpg) |
+
+*Top-down maps drawn from the generated world files.*
+
+## Getting started
+
+You need [uv](https://docs.astral.sh/uv/) and Minecraft Java Edition 26.3 or newer.
+
+```bash
+uvx finland2mc "Jyväskylä"
+```
+
+uvx downloads finland2mc and the Python packages it needs on the first run. After that it keeps using the
+version it downloaded; `uvx finland2mc@latest` gets the newest one. To get a plain `finland2mc` command, run
+`uv tool install finland2mc`.
+
+Run like that, it asks a few questions, each with a default you can accept with Enter:
+
+1. Which match you meant, if the name fits several places.
+2. How big an area to build (default 4 × 4 km).
+3. Whether to use laser scans for real tree and building heights. This is usually most of the download.
+4. Whether to install the world into Prism Launcher.
+
+Then it prints the download size and a time estimate, and asks before starting.
+
+To skip the questions, give the answers as options:
+
+```bash
+uvx finland2mc "Porvoo" --size 2 --yes                # defaults, no questions
+uvx finland2mc "Kallio, Helsinki" --size 3 --prism    # also install into Prism Launcher
+uvx finland2mc --at 61.4981,23.7608 --name "Tampere centre"
+```
+
+The finished world goes to `worlds/<name> 1-1/`, with a top-down map next to it (`<name> 1-1.png`).
+It needs Minecraft **26.3** or newer.
+
+## Options
+
+| Option | What it does |
+|---|---|
+| `place` | Town, district or address in Finland. Looked up with OpenStreetMap's Nominatim. |
+| `--at LAT,LON` | Use an exact centre point instead of a name. ETRS-TM35FIN also works: `--at E381000,N6905000`. |
+| `--size KM` | Side of the square area, 0.5–10 km. Default 4. |
+| `--name NAME` | World name shown in Minecraft. Default: `<place> 1:1`. |
+| `--out DIR` | Where the world goes. Default `./worlds`. |
+| `--no-lidar` | Skip laser scans. The download is much smaller, but trees are placed at random in forests and building heights are guessed from the building type. |
+| `--prism [INSTANCE]` | Copy the world into a Prism Launcher instance. The default is `Finland 1:1`, which is created if it doesn't exist. It copies its Minecraft and Java setup from an instance you already have with 26.3, if there is one. |
+| `--zip` | Also make a .zip of the world. |
+| `--jobs N` | CPU cores to use. Default: all but one. |
+| `-y`, `--yes` | Don't ask anything; use the defaults. |
+
+## How long it takes
+
+Measured on 11 cores, with the data already downloaded:
+
+| Place | Area | Time |
+|---|---|---|
+| Naantali (town and sea) | 2 × 2 km | 0.9 min |
+| Jyväskylä (city centre) | 3 × 3 km | 1.3 min |
+| Keuruu (mostly forest) | 6 × 6 km | about 25 min |
+
+Dense forest is by far the slowest part. The program prints an estimate before it starts.
+
+Downloads are cached in `~/.cache/finland2mc`, which you can change with the `FINLAND2MC_CACHE` environment
+variable. Neighbouring or repeated areas reuse the cache. Laser scans are the big part of a download: older
+scans (about 1 point/m²) are about 50 MB per 3 × 3 km tile, and newer ones (5 points/m²) can be several
+hundred MB per tile.
+
+## In the world
+
+- You start in creative mode on peaceful difficulty, on a street near the middle of the area.
+- A world border keeps you inside the area. There is only void beyond it.
+- x = 0, z = 0 is the centre point. +x is east and +z is south.
+- The most common water level (the sea, or the biggest lake) is at y = 62. The program prints how y relates
+  to height above sea level.
+- Far views look best with a level-of-detail mod such as Distant Horizons.
+
+## Where the data comes from
+
+All map data is open data from the National Land Survey of Finland (Maanmittauslaitos), downloaded from the
+[Funet mirror](https://www.nic.funet.fi/index/geodata/mml/):
+
+| Data | Used for |
+|---|---|
+| Elevation model 2 m | Terrain height |
+| Topographic database 2025 | Sea, lakes, streams, roads, railways, bridges, buildings, fields, bogs, rock, parks |
+| Depth contours | Lake depths, interpolated between the contours |
+| Laser scanning (newest available per tile) | Individual trees and their heights, and building heights |
+
+Some things are guesses, because the data doesn't say:
+
+- Tree species are chosen from the terrain: pine on ridges, rock and bogs; spruce in hollows; birch near open land.
+- Building colours and roof materials are picked at random from typical Finnish choices.
+- Roofs are hip roofs on houses and flat roofs on large buildings. Interiors are empty floors with no doors.
+- Sea depth isn't in the open data, so the sea gets deeper with distance from the shore, down to 10 m.
+- Laser scans can be several years old, so newer clear-cuts and buildings won't match.
+
+The biome is birch forest everywhere. In a superflat world the game thinks sea level is y = −63, so colder
+biomes such as taiga would freeze the lakes.
+
+## How it works
+
+| File | What it does |
+|---|---|
+| `cli.py` | Asks the questions and runs the steps. |
+| `geocode.py` | Turns a place name into coordinates. |
+| `nls.py` | Works out the map sheet and tile names for the area (TM35 sheet division) and downloads them into the cache. |
+| `prepare.py` | Turns the data into 1 m grids: ground and water heights, land cover, roads, bridge decks, building footprints and the tree list. |
+| `generate.py` | Builds the chunks in parallel. |
+| `mcformat.py` | Writes the 26.3 chunk and region format. Block names are checked against `data/blocks_26.3.json`, the official server's block report. |
+| `world.py` | Adds `level.dat` and the other world files from `data/template/` (an empty world saved by the 26.3 server), then sets the spawn point and the world border. |
+| `render.py` | Draws the preview map from the finished world files. |
+| `prism.py` | Installs the world into Prism Launcher. |
+
+The world is written directly in the 26.3 format. Newer Minecraft versions upgrade it when they open it.
+`data/blocks_26.3.json` and `data/template/` were produced by the official 26.3 server: its data generator's
+block report (trimmed to names, properties and default states), and an empty world it saved.
+
+To work on the code, clone the repository and use `uv run finland2mc` in it. Run the tests with
+`uv run pytest`.
+
+## Limits
+
+- Finland only, because the data is Finnish.
+- Areas up to 10 × 10 km. Memory use grows with area. 3 × 3 km measured about 1 GB, so expect roughly
+  4 GB for 6 × 6 km and 11 GB for 10 × 10 km.
+- Places with more than about 370 m height difference within the area (some Lapland fells) don't fit
+  Minecraft's 384-block world height. Use a smaller area there.
+
+## Credit and licence
+
+The code is under the MIT licence (see `LICENSE`).
+
+Worlds made with it contain data from the National Land Survey of Finland: Topographic Database, Elevation
+model 2 m, and Laser scanning data. Licence: CC BY 4.0. If you share a world, keep this credit with it.
+
+Place search uses OpenStreetMap Nominatim (© OpenStreetMap contributors). Please keep to its
+[usage policy](https://operations.osmfoundation.org/policies/nominatim/); the program searches once per place
+name you enter.
+
+NOT AN OFFICIAL MINECRAFT PRODUCT. NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT.

finland2mc-0.1.0/README.md

@@ -0,0 +1,149 @@
+# finland2mc
+
+Give it a place in Finland and it builds a 1:1 Minecraft Java Edition world of it: one block is one metre,
+horizontally and vertically. Everything comes from the National Land Survey of Finland's open data: terrain,
+lakes and sea, roads, bridges, buildings, fields, and trees placed where laser scans found them.
+
+| Jyväskylä | Naantali | Keuruu |
+|---|---|---|
+| ![Jyväskylä](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/jyvaskyla.jpg) | ![Naantali](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/naantali.jpg) | ![Keuruu](https://raw.githubusercontent.com/topiautio/finland2mc/main/docs/keuruu.jpg) |
+
+*Top-down maps drawn from the generated world files.*
+
+## Getting started
+
+You need [uv](https://docs.astral.sh/uv/) and Minecraft Java Edition 26.3 or newer.
+
+```bash
+uvx finland2mc "Jyväskylä"
+```
+
+uvx downloads finland2mc and the Python packages it needs on the first run. After that it keeps using the
+version it downloaded; `uvx finland2mc@latest` gets the newest one. To get a plain `finland2mc` command, run
+`uv tool install finland2mc`.
+
+Run like that, it asks a few questions, each with a default you can accept with Enter:
+
+1. Which match you meant, if the name fits several places.
+2. How big an area to build (default 4 × 4 km).
+3. Whether to use laser scans for real tree and building heights. This is usually most of the download.
+4. Whether to install the world into Prism Launcher.
+
+Then it prints the download size and a time estimate, and asks before starting.
+
+To skip the questions, give the answers as options:
+
+```bash
+uvx finland2mc "Porvoo" --size 2 --yes                # defaults, no questions
+uvx finland2mc "Kallio, Helsinki" --size 3 --prism    # also install into Prism Launcher
+uvx finland2mc --at 61.4981,23.7608 --name "Tampere centre"
+```
+
+The finished world goes to `worlds/<name> 1-1/`, with a top-down map next to it (`<name> 1-1.png`).
+It needs Minecraft **26.3** or newer.
+
+## Options
+
+| Option | What it does |
+|---|---|
+| `place` | Town, district or address in Finland. Looked up with OpenStreetMap's Nominatim. |
+| `--at LAT,LON` | Use an exact centre point instead of a name. ETRS-TM35FIN also works: `--at E381000,N6905000`. |
+| `--size KM` | Side of the square area, 0.5–10 km. Default 4. |
+| `--name NAME` | World name shown in Minecraft. Default: `<place> 1:1`. |
+| `--out DIR` | Where the world goes. Default `./worlds`. |
+| `--no-lidar` | Skip laser scans. The download is much smaller, but trees are placed at random in forests and building heights are guessed from the building type. |
+| `--prism [INSTANCE]` | Copy the world into a Prism Launcher instance. The default is `Finland 1:1`, which is created if it doesn't exist. It copies its Minecraft and Java setup from an instance you already have with 26.3, if there is one. |
+| `--zip` | Also make a .zip of the world. |
+| `--jobs N` | CPU cores to use. Default: all but one. |
+| `-y`, `--yes` | Don't ask anything; use the defaults. |
+
+## How long it takes
+
+Measured on 11 cores, with the data already downloaded:
+
+| Place | Area | Time |
+|---|---|---|
+| Naantali (town and sea) | 2 × 2 km | 0.9 min |
+| Jyväskylä (city centre) | 3 × 3 km | 1.3 min |
+| Keuruu (mostly forest) | 6 × 6 km | about 25 min |
+
+Dense forest is by far the slowest part. The program prints an estimate before it starts.
+
+Downloads are cached in `~/.cache/finland2mc`, which you can change with the `FINLAND2MC_CACHE` environment
+variable. Neighbouring or repeated areas reuse the cache. Laser scans are the big part of a download: older
+scans (about 1 point/m²) are about 50 MB per 3 × 3 km tile, and newer ones (5 points/m²) can be several
+hundred MB per tile.
+
+## In the world
+
+- You start in creative mode on peaceful difficulty, on a street near the middle of the area.
+- A world border keeps you inside the area. There is only void beyond it.
+- x = 0, z = 0 is the centre point. +x is east and +z is south.
+- The most common water level (the sea, or the biggest lake) is at y = 62. The program prints how y relates
+  to height above sea level.
+- Far views look best with a level-of-detail mod such as Distant Horizons.
+
+## Where the data comes from
+
+All map data is open data from the National Land Survey of Finland (Maanmittauslaitos), downloaded from the
+[Funet mirror](https://www.nic.funet.fi/index/geodata/mml/):
+
+| Data | Used for |
+|---|---|
+| Elevation model 2 m | Terrain height |
+| Topographic database 2025 | Sea, lakes, streams, roads, railways, bridges, buildings, fields, bogs, rock, parks |
+| Depth contours | Lake depths, interpolated between the contours |
+| Laser scanning (newest available per tile) | Individual trees and their heights, and building heights |
+
+Some things are guesses, because the data doesn't say:
+
+- Tree species are chosen from the terrain: pine on ridges, rock and bogs; spruce in hollows; birch near open land.
+- Building colours and roof materials are picked at random from typical Finnish choices.
+- Roofs are hip roofs on houses and flat roofs on large buildings. Interiors are empty floors with no doors.
+- Sea depth isn't in the open data, so the sea gets deeper with distance from the shore, down to 10 m.
+- Laser scans can be several years old, so newer clear-cuts and buildings won't match.
+
+The biome is birch forest everywhere. In a superflat world the game thinks sea level is y = −63, so colder
+biomes such as taiga would freeze the lakes.
+
+## How it works
+
+| File | What it does |
+|---|---|
+| `cli.py` | Asks the questions and runs the steps. |
+| `geocode.py` | Turns a place name into coordinates. |
+| `nls.py` | Works out the map sheet and tile names for the area (TM35 sheet division) and downloads them into the cache. |
+| `prepare.py` | Turns the data into 1 m grids: ground and water heights, land cover, roads, bridge decks, building footprints and the tree list. |
+| `generate.py` | Builds the chunks in parallel. |
+| `mcformat.py` | Writes the 26.3 chunk and region format. Block names are checked against `data/blocks_26.3.json`, the official server's block report. |
+| `world.py` | Adds `level.dat` and the other world files from `data/template/` (an empty world saved by the 26.3 server), then sets the spawn point and the world border. |
+| `render.py` | Draws the preview map from the finished world files. |
+| `prism.py` | Installs the world into Prism Launcher. |
+
+The world is written directly in the 26.3 format. Newer Minecraft versions upgrade it when they open it.
+`data/blocks_26.3.json` and `data/template/` were produced by the official 26.3 server: its data generator's
+block report (trimmed to names, properties and default states), and an empty world it saved.
+
+To work on the code, clone the repository and use `uv run finland2mc` in it. Run the tests with
+`uv run pytest`.
+
+## Limits
+
+- Finland only, because the data is Finnish.
+- Areas up to 10 × 10 km. Memory use grows with area. 3 × 3 km measured about 1 GB, so expect roughly
+  4 GB for 6 × 6 km and 11 GB for 10 × 10 km.
+- Places with more than about 370 m height difference within the area (some Lapland fells) don't fit
+  Minecraft's 384-block world height. Use a smaller area there.
+
+## Credit and licence
+
+The code is under the MIT licence (see `LICENSE`).
+
+Worlds made with it contain data from the National Land Survey of Finland: Topographic Database, Elevation
+model 2 m, and Laser scanning data. Licence: CC BY 4.0. If you share a world, keep this credit with it.
+
+Place search uses OpenStreetMap Nominatim (© OpenStreetMap contributors). Please keep to its
+[usage policy](https://operations.osmfoundation.org/policies/nominatim/); the program searches once per place
+name you enter.
+
+NOT AN OFFICIAL MINECRAFT PRODUCT. NOT APPROVED BY OR ASSOCIATED WITH MOJANG OR MICROSOFT.

finland2mc-0.1.0/finland2mc/__init__.py

@@ -0,0 +1,4 @@
+"""finland2mc: 1:1 Minecraft worlds of places in Finland, from National Land Survey open data."""
+
+__version__ = "0.1.0"
+MINECRAFT_VERSION = "26.3"

finland2mc-0.1.0/finland2mc/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

finland2mc-0.1.0/finland2mc/area.py

@@ -0,0 +1,45 @@
+"""The square of land being turned into a world, and the grid it is sampled on."""
+from dataclasses import dataclass
+
+from rasterio.transform import from_origin
+
+MARGIN = 16  # extra metres sampled around the playable area
+
+
+@dataclass(frozen=True)
+class Area:
+    """A square centred on ETRS-TM35FIN point (ce, cn).
+
+    Minecraft x = x0 + col, z = x0 + row (1 block = 1 m). E = ce + x + 0.5, N = cn - z - 0.5.
+    """
+    ce: int
+    cn: int
+    half: int  # half the side length in metres
+
+    @property
+    def x0(self):
+        return -(self.half + MARGIN)
+
+    @property
+    def size(self):
+        return 2 * (self.half + MARGIN)
+
+    @property
+    def west(self):
+        return self.ce + self.x0
+
+    @property
+    def north(self):
+        return self.cn - self.x0
+
+    @property
+    def bounds(self):
+        """(minE, minN, maxE, maxN) of the sampled grid."""
+        return (self.west, self.north - self.size, self.west + self.size, self.north)
+
+    @property
+    def transform(self):
+        return from_origin(self.west, self.north, 1, 1)
+
+    def to_dict(self):
+        return dict(ce=self.ce, cn=self.cn, half=self.half)

finland2mc-0.1.0/finland2mc/cli.py

@@ -0,0 +1,194 @@
+"""finland2mc: give it a place in Finland, get a 1:1 Minecraft world of it.
+
+    finland2mc "Jyväskylä"                 # asks a few questions, everything has a default
+    finland2mc "Porvoo" --size 2 --yes     # no questions
+    finland2mc --at 62.2416,25.7496        # exact centre point (lat,lon or E...,N... in ETRS-TM35FIN)
+"""
+import argparse
+import os
+import re
+import shutil
+import sys
+import time
+from pathlib import Path
+
+from . import MINECRAFT_VERSION, __version__, geocode, nls, prism
+from .area import Area
+
+SECONDS_PER_CHUNK = (0.025, 0.12)  # per CPU core: town centre, dense forest
+DEFAULT_INSTANCE = "Finland 1:1"
+
+
+def say(*a):
+    print(*a, flush=True)
+
+
+def ask(question, default, interactive):
+    if not interactive:
+        return default
+    ans = input(f"{question} [{default}]: ").strip()
+    return ans or default
+
+
+def ask_yes(question, default, interactive):
+    if not interactive:
+        return default
+    while True:
+        ans = input(f"{question} [{'Y/n' if default else 'y/N'}]: ").strip().lower()
+        if not ans:
+            return default
+        if ans in ("y", "yes", "k", "kyllä"):
+            return True
+        if ans in ("n", "no", "e", "ei"):
+            return False
+        say("Please answer y or n.")
+
+
+def choose_place(args, interactive):
+    if args.at:
+        return geocode.from_coordinates(args.at)
+    query = args.place
+    while True:
+        if not query:
+            if not interactive:
+                raise SystemExit("Give a place name, e.g. finland2mc \"Jyväskylä\"")
+            query = input("Place in Finland (town, district or address): ").strip()
+            continue
+        try:
+            found = geocode.search(query)
+        except OSError as e:
+            raise SystemExit(f"Place search failed ({e}). Use --at LAT,LON instead.")
+        if not found:
+            say(f"Nothing found in Finland for '{query}'.")
+            if not interactive:
+                raise SystemExit(1)
+            query = None
+            continue
+        if len(found) == 1 or not interactive:
+            return found[0]
+        for i, p in enumerate(found, 1):
+            say(f"  {i}. {p.description}")
+        while True:
+            pick = ask("Which one", "1", interactive)
+            if pick.isdigit() and 1 <= int(pick) <= len(found):
+                return found[int(pick) - 1]
+            say(f"Pick a number from 1 to {len(found)}.")
+
+
+def folder_name(name):
+    return re.sub(r'[<>"/\\|?*]', "", name.replace(":", "-")).strip() or "world"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="finland2mc", description="1:1 Minecraft worlds of places in Finland, "
+                                 "from National Land Survey of Finland open data.")
+    ap.add_argument("place", nargs="?", help="town, district or address in Finland")
+    ap.add_argument("--at", metavar="LAT,LON", help="centre point instead of a place name "
+                    "(or E381000,N6905000 in ETRS-TM35FIN)")
+    ap.add_argument("--size", type=float, help="side of the square area in km (default 4, max 10)")
+    ap.add_argument("--name", help="world name shown in Minecraft (default: '<place> 1:1')")
+    ap.add_argument("--out", default="worlds", help="folder for the finished world (default: ./worlds)")
+    ap.add_argument("--no-lidar", action="store_true",
+                    help="skip laser scans: smaller download, but made-up tree and building heights")
+    ap.add_argument("--prism", nargs="?", const=DEFAULT_INSTANCE, metavar="INSTANCE",
+                    help=f"copy the world into a Prism Launcher instance (default '{DEFAULT_INSTANCE}', "
+                         "created if missing)")
+    ap.add_argument("--zip", action="store_true", help="also make a .zip of the world")
+    ap.add_argument("--jobs", type=int, help="CPU cores to use (default: all but one)")
+    ap.add_argument("--keep-work", action="store_true", help="keep the intermediate grids")
+    ap.add_argument("-y", "--yes", action="store_true", help="don't ask anything, use defaults")
+    ap.add_argument("--version", action="version", version=f"finland2mc {__version__} (Minecraft {MINECRAFT_VERSION})")
+    args = ap.parse_args(argv)
+    interactive = sys.stdin.isatty() and not args.yes
+
+    place = choose_place(args, interactive)
+    e, n = place.etrs
+    say(f"Place: {place.description}\n  ETRS-TM35FIN E {e} N {n}")
+    size = args.size
+    while size is None:
+        try:
+            size = float(ask("Area size in km (one side of the square)", "4", interactive).replace(",", "."))
+        except ValueError:
+            say("Please give a number, e.g. 3 or 2.5")
+    if not 0.5 <= size <= 10:
+        raise SystemExit("Area size must be between 0.5 and 10 km.")
+    name = args.name or f"{place.name} 1:1"
+    area = Area(e, n, int(round(size * 500)))
+    jobs = args.jobs or max(1, (os.cpu_count() or 2) - 1)
+
+    say("Checking which map data is needed...")
+    try:
+        files, todo = nls.plan(area.bounds, lidar=not args.no_lidar)
+    except ValueError as err:
+        raise SystemExit(f"That point is outside Finland's map sheets ({err}).")
+    if not files["dem"] and not files["mtk"]:
+        raise SystemExit("No map data here. Is the place in Finland?")
+    lidar_bytes = sum(nls.remote_size(p) or 0 for p in files["lidar"] if not nls.local(p).exists())
+    if files["lidar"] and lidar_bytes > 0 and interactive:
+        if not ask_yes(f"Use laser scans for real tree and building heights? ({lidar_bytes / 1e6:.0f} MB of the "
+                       "download)", True, interactive):
+            todo -= lidar_bytes
+            files["lidar"] = []
+    chunks = ((area.half - 1) // 16 + (area.half + 15) // 16 + 1) ** 2
+    lo, hi = (chunks * s / jobs / 60 + size * size * 0.05 for s in SECONDS_PER_CHUNK)
+    lo, hi = max(1, round(lo)), max(1, round(hi))
+    say(f"World: '{name}', {size:g} x {size:g} km, {chunks} chunks, about {lo if lo == hi else f'{lo}-{hi}'} min "
+        f"on {jobs} cores (forest is slower than town)")
+    if not files["lidar"]:
+        say("  (no laser scans: tree positions and building heights will be guesses)")
+    say(f"Download: {todo / 1e6:.0f} MB (cached in {nls.CACHE}, reused next time)")
+
+    install_to = args.prism
+    root = prism.find_root()
+    if install_to is None and root and interactive:
+        if ask_yes(f"Install into Prism Launcher instance '{DEFAULT_INSTANCE}'?", True, interactive):
+            install_to = DEFAULT_INSTANCE
+    if not ask_yes("Start?", True, interactive):
+        return 0
+
+    t0 = time.time()
+    if todo:
+        say("Downloading National Land Survey data...")
+    local = nls.download(files, progress=lambda m: print(f"\r{m}", end="", flush=True))
+    print()
+
+    out = Path(args.out).resolve()
+    world = out / folder_name(name)
+    if world.exists():
+        raise SystemExit(f"{world} already exists. Remove it or use --name / --out.")
+    work = nls.CACHE / "work" / f"{e}_{n}_{area.half}"
+    from . import generate, prepare, render, world as world_mod  # heavy imports after the questions
+
+    say("Preparing map data...")
+    meta = prepare.Prep(area, local, work, log=lambda m: say("  " + m)).run()
+    say("Building the world...")
+    generate.run(str(work), str(world), jobs=jobs, progress=lambda m: print(f"\r{m}   ", end="", flush=True))
+    print()
+    spawn = world_mod.finalize(str(world), str(work), name)
+    preview = Path(str(world) + ".png")
+    render.render(str(world), str(preview), area.half)
+    if args.zip:
+        shutil.make_archive(str(world), "zip", out, world.name)
+    if not args.keep_work:
+        shutil.rmtree(work, ignore_errors=True)
+
+    say(f"\nDone in {(time.time() - t0) / 60:.1f} min.")
+    say(f"  World:   {world}")
+    say(f"  Map:     {preview}")
+    say(f"  Spawn:   {spawn[0]} {spawn[1]} {spawn[2]}  (y = {prepare.height_rule(meta['offset'])})")
+    if install_to:
+        try:
+            inst, dest, created = prism.install(world, install_to)
+            say(f"  Prism:   {'created instance' if created else 'added to instance'} '{install_to}' ({inst})")
+            if created and prism.prism_running():
+                say("           Prism is running; restart it if the new instance doesn't show up.")
+        except (RuntimeError, OSError) as err:
+            say(f"  Prism:   not installed ({err})")
+    else:
+        say(f"  Open it with Minecraft {MINECRAFT_VERSION} or newer: copy the world folder into your saves folder.")
+    say("Contains data from the National Land Survey of Finland (CC BY 4.0).")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())