v1.7.4

hotfixes

v1.7.3

easier preset making

v1.7.2

Share a map area and its settings as a file or a link, plus two offline checks on the compiler: three golden maps compared hash by hash, and a 51x48 cell run.

v1.7.1

Small additions: the settings that are only ever on or off are real switches now, not sliders.

v1.7

Custom map maker/editor. Now you can mske your presets for each building and have them generated.

new in app editor

• Edit the map KnoxMap made (generator/edits.py, new; app.py,
  static/js/app.js, templates/index.html). A generated map is a reading of
  OpenStreetMap, and a reading is sometimes wrong: a shed the survey calls a
  house, a road running through where a square should be, a building that is
  simply not wanted. Until now the only answer was to accept it. Open a map,
  load what it was built from, and its roads, buildings, water and woods come
  back as shapes: click one to remove it or say what it really is, drag its
  corners to move it, then generate the map again and the change is in.

  The download is left exactly as it came. What is changed about it is kept
  beside the map as a short list of changes keyed by each feature's own OSM id

  • removed, moved, retagged - so a town of a hundred thousand features costs
    a few lines where a copy would be megabytes, a re-download does not throw
    the editing away, and any change can be taken back by dropping its line.
    Only what is being looked at is sent, biggest first and capped, because a
    page handed a city's features stops responding and nobody edits a hundred
    thousand things by hand.

  Tags a page may set are a fixed list, since they reach classify and the
  renderer. An area whose ring is dragged open is closed again before it is
  used, or a house would be painted as a stripe. And the one place that works
  out which file a map's download lives in is now shared by the editor and the
  generator, so the two cannot look in different ones.

• Draw your own map (generator/sketch.py, new; app.py,
  static/js/app.js, templates/index.html). A town that is not on
  OpenStreetMap could not be built at all: one never surveyed, one behind a
  licence, or one that only exists in somebody's head. There is a palette in
  the window now - 34 things, from a motorway to a hedge to a single tree -
  and whatever is drawn on the map goes in with whatever was downloaded.
  Tick "Only what I draw" and Overpass is not asked at all.

  Nothing downstream knows the difference, which is the point of doing it this
  way. A drawn shape becomes an ordinary OSMFeature carrying real
  OpenStreetMap tags, so classify sorts it, the renderer paints it, the
  building generator furnishes it and the compiler writes it, with no second
  path through any of them. Draw a street and it gets a street's width, its
  pavement, its kerbs, its lamps and its parked cars, because by the time
  anything looks at it, it is one. Draw a school and the rooms inside are a
  school's. A hand-drawn town of 14 shapes came out as 900x900 tiles with
  2,393 tiles of tarmac, 4,110 of pavement it was never told to add, a lake,
  woods, 8 buildings furnished by kind and 720 residents estimated to haunt
  them.

  The palette's tags live on the server and the page builds itself from them,
  so the two cannot drift; a test checks every entry against classify
  rather than against the comment beside it, because a tag that classifies as
  nothing draws a shape on the page that is silently missing from the
  finished map. The drawing is kept beside the map as GeoJSON, so opening one
  brings it back to be added to, and regenerating does not lose it.

---

Install

New to this? tutorial.txt in the download walks through it.

System	Download	Then
Windows 10/11	KnoxMap-v1.6.2-editor-windows.zip	unzip it and double-click KnoxMap.exe
Linux	KnoxMap-v1.6.2-editor-linux.tar.gz	tar -xzf it, then ./setup.sh and ./knoxmap.sh
macOS	KnoxMap-v1.6.2-editor-macos.tar.gz	tar -xzf it, then ./setup.sh and ./knoxmap.sh

Linux and macOS need 64-bit Python 3.10+ of your own; see LINUX.md.

KnoxMap.exe finds Python, runs setup the first time and opens
the window. KnoxMap.bat is still in the folder and does the same,
for anyone who would rather read what they are running. Windows may
warn about an unsigned program the first time: More info, Run anyway.

1.6 rust

• No red question marks from Erika's paintings and posters (knoxbuild/catalog.py,
  tools/make_catalog.py). Eight tiles of Erika's Tiles 1.0.7 are blank - paintings
  74 to 79 and posters 22 and 23 of their sheets are empty and not in the mod's pack - and
  the catalogue had four wall-art pieces made of them, so the game logged
  "CellLoader> missing tile ..." and drew red question marks on the wall. Those four
  pieces are left out (and by make_catalog.py when it is run again).

• A building is no longer built on the road (knoxbuild/footprint.py,
  build.py). Since 1.6 a building that fronted a pavement stood "on the least
  road it can" when there was no clear spot, and on a real 5100 x 2700 map 63 of
  957 buildings had room squares on a road and 25 were mostly on it - houses
  and apartments in the middle of an intersection. A building may now stand on at
  most 10% road. It is moved out of the road as far as twelve tiles to get
  there, whatever road squares are left are cut away, and one that cannot be got
  under that share is left out ("on the road" in the build summary: 21 of the
  same 957, none left on a road). Pavement is still something a building may
  front.

• A wall is no longer lost under a neighbour's roof (knoxbuild/world.py,
  build.py). Where a taller building stood beside a lower one, the lower one's
  ceiling and roof tiles landed on the squares its upper-floor wall stands on, and WorldEd
  lays lots down in the order the project lists them, with a tile of that kind taking the
  whole square: the wall vanished, leaving a gap in the side of the taller building. On a
  real map 89 wall edges were missing this way (80 under a roof). Lots are now listed
  lowest building first, so the taller building is laid last and its wall is added to what
  is there; none were missing on the same map afterwards.

• No tree, bush or fence stands in a doorway (knoxbuild/yards.py,
  fences.py, build.py). The ground and the fences are drawn from OpenStreetMap
  before anyone knows where a door is, so on a real map 19 of 19,796 doors had a
  fence or a tree on the square in front of them and 53 had a bush. The two squares
  in front of every ground-floor outside door are now cleared of vegetation, and a
  fence edge that touches them is left out, which makes a gap in the fence where the
  door is. None were blocked afterwards on the same map.

• A map compiler of our own: no size limit, minutes become seconds
  (rust/knoxlots, knoxbuild/terrain.py, blends.py, buildtiles.py,
  buildroofs.py, buildheader.py, tools/map_source.py, tools/compile_map.py).
  Compiling no longer needs WorldEd. KnoxMap now makes the tile stack of every square
  itself - ground and edge blends from Rules.txt / Blends.txt, then the buildings
  from their .tbx files (floors, walls, doors, windows, curtains, furniture, stairs,
  ceilings, roofs, porch lights and signs), then the room and building tables of the
  header - and a small Rust program, knoxlots, writes the .lotheader, .lotpack and
  chunkdata files. On a 1,500 m town of 1,177 buildings it took 60 s against WorldEd's
  271 s, and 2,020,709 of 2,020,734 squares are identical to WorldEd's (the rest are a few
  window, door and wall details and the order of tiles within a square). A map built this
  way was played in Build 42. The bitmap size limit does not apply.

  It is used whenever knoxlots is found - next to KnoxMap.exe in a release, or in
  rust/knoxlots/target/release after cargo build --release, or named by KNOXLOTS -
  and WorldEd is used otherwise; KNOXMAP_BACKEND=worlded or rust chooses outright, and
  python tools/compile_map.py <map> --backend rust does it from a terminal. Releases
  carry the binary for their system (built and tested by .github/workflows/knoxlots.yml).
  Written without WorldEd's source: from the file formats and from running WorldEd on
  small inputs and comparing what it wrote (see rust/knoxlots/README.md); the work and
  its test maps are also kept at github.com/thehorseofcourse45/worlded-rusted.

• A map too big for WorldEd is refused before it is made (app.py,
  tools/compile_map.py). WorldEd's BMP to TMX cannot load a landscape bitmap past
  about 268 million pixels (2^28): 16200 x 16500 compiles, 16500 x 16500 fails with
  "The image file couldn't be loaded", on every batch. A 17700 x 19500 map took
  most of an hour to make and then failed all 255 batches. Generate now says so
  at once, with the smallest scale that fits; a compile that fails this way says
  why. Every other size limit is still only a warning.

• The compile eases off when WorldEd starts failing, and says how long is
  left (tools/compile_map.py). Six WorldEd processes at once on 8 cores and
  32 GB made it fail with "Error Loading Image". A failure while others are
  running now takes one slot (never below one, and not again for 90 s). The
  window shows the time left once a few batches have set the pace, and when it
  eased off. Generate buildings shows its stage as it goes.

---

Install

New to this? tutorial.txt in the download walks through it.

System	Download	Then
Windows 10/11	KnoxMap-v1.6-rust-windows.zip	unzip it and double-click KnoxMap.exe
Linux	KnoxMap-v1.6-rust-linux.tar.gz	tar -xzf it, then ./setup.sh and ./knoxmap.sh
macOS	KnoxMap-v1.6-rust-macos.tar.gz	tar -xzf it, then ./setup.sh and ./knoxmap.sh

Linux and macOS need 64-bit Python 3.10+ of your own; see LINUX.md.

KnoxMap.exe finds Python, runs setup the first time and opens
the window. KnoxMap.bat is still in the folder and does the same,
for anyone who would rather read what they are running. Windows may
warn about an unsigned program the first time: More info, Run anyway.

hotfix

What's Changed

• Refuse a map WorldEd cannot compile, and say why when one fails by @thehorseofcourse45 in #25

Full Changelog: v1.6...1.6.1

app overhaul

What's Changed

• Refactor building layout and enhance rendering features by @kadeneli2002-ux in #24
• Incremental builds and compiles, a health check, and a round of robustness fixes by @thehorseofcourse45 in #22
• Build Chinese maps the Chinese way, plus footprint-based storey infer… by @43aquarius in #23

New Contributors

• @kadeneli2002-ux made their first contribution in #24
• @43aquarius made their first contribution in #23

Full Changelog: v1.5.2...v1.6

1.5.2 update update

What's Changed

• Fix big-map build failure, cut build memory and time, stop compile popup flood by @thehorseofcourse45 in #21

Full Changelog: v1.5.1...v1.5.2