The World Editor

The World Editor is where you build a campaign. You paint a heightmap, draw rivers, place settlements, carve out provinces, assign factions and characters, and let the editor bake everything the game needs to run the scenario. When you're done you export a package and it appears in the game's main menu.

This page covers running it, every mode it has, how it connects to a real game build for preview, and how the export ends up in your mod.

The three published example projects - tutorial, campaign, and Lords of Sicily - are World Editor projects. Clone one and open it to follow along with a real scenario instead of a blank page.

Running the editor

The editor ships with the game, under ModdingTools/:

The editor with a project loaded. The mode switcher runs along the top; the map fills the canvas; per-feature panels open on the side.

Projects

A World Editor project is a folder of source files - the editable inputs - plus an export folder for the baked output. The source is what you keep in version control (it's what the example repos contain).

Roughly, the workflow is always the same, and each step maps to a mode in the editor. You lay down the heightmap for the shape of the terrain, then paint the surface layers over it - forest, rock, desert and so on - and draw in the rivers. After that you place the settlements and build provinces around them, assign factions, populations and characters, and generate and edit the routes, both roads and sea lanes. Finally you place any scenario actors, fill in the Info panel with the name and content-pack profile, and export, at which point the campaign shows up in the game. You don't have to work strictly in that order, but it's the natural flow, and the rest of this page follows it mode by mode.

Heightmap and terrain

Everything starts with the shape of the land. The heightmap is a greyscale image where brightness is elevation - you can import one (a real DEM of Europe, a fantasy map, whatever you like), paint it from scratch with the built-in brushes, or import and then touch it up.

Heightmap mode. Bright is high, dark is low. Brushes on the side raise, lower, smooth, and flatten terrain.

Height feeds into gameplay as well as visuals. Mountains are impassable, slopes affect movement, and the generated road network routes around terrain it can't cross. So it's worth getting the shape roughly right before you place anything on top of it.

At export the editor also bakes some visual niceties from the heightmap, like normal maps, that add a lot to how the finished map looks in-game.

Surface layers

On top of the height, you paint surface layers: the material of the ground. Forests, rocky ground, desert, farmland, and so on. These are painted like any other layer and they matter mechanically as well as visually - the Rock mask, for example, is terrain the road generator treats as off-limits.

The surface layer view. Terrain types are painted directly onto the map and can be reviewed together before export.

Rivers

Rivers get their own mode. You draw the river network, and the baker does the clever part: it flood-fills flow direction outward from the river pixels and works out flow speed and coverage, packing all of that into the textures the game's water material reads. The river footprint is also folded into the terrain mask so the ground reacts to it.

Rivers drawn over the height layer. At close zoom you can see the height, river network, settlements, and ports together.

Rivers also matter for the road network - generated roads only cross water using explicit short bridge spans, which the editor shows you separately so you can see exactly where a crossing is being made.

Provinces and settlements

This is the heart of a scenario. You place settlements - cities, towns, ports - and build provinces around them. Each settlement and province carries the data that drives the campaign: ownership, corruption, IDs, map position, ports, and so on.

Province and settlement editing in context - ownership, corruption, province IDs, and map position all in one panel.

The province view, with settlements, ports, and geography editing available in one place.

Provinces are stored and baked as provinces.bin; the editor writes it and the game reads it using the same shared code, so the two stay in lockstep.

Factions, populations, and characters

With settlements in place you set who owns what. You define factions, assign settlements to them, and populate the world with pops and characters - the rulers, courtiers, and notables who'll be running things when the campaign begins.

Assigning factions, populations, and characters to the settlements on the map.

Routes - roads and sea lanes

Movement in the game runs on precomputed routing data, and the editor bakes both networks for you. Roads come first. In Routes mode you can generate a whole road network straight from the heightmap; the generator keeps clear of impassable mountains and the Rock mask, and only crosses water with explicit short bridge spans. Once it's generated, the roads become editable data like anything else, so you can select them and edit them point by point, place your own roads by hand, and choose bridge spans wherever you need a crossing.

Naval movement works from a separate open-water navigation grid. You edit that sea grid in the editor, and export bakes it into a deterministic grid that the game's navy pathfinding reads.

Generated land and sea routing data, including the editable sea grid used for movement and pathfinding.

Editable routes live in the project source (TransportRoutes.edit.bin and SeaNavigationGrid.edit.bin) and export writes the runtime versions (TransportRoutes.bin, SeaNavigation.bin) into the map package, so the transport network travels with the map.

Actors

Some scenarios need specific things placed in the world - set-piece objects, decorative or gameplay actors that belong to the starting state. You author these visually in Actors mode, and they're exported as placedActors in the scenario data.

Placing scenario actors directly on the map in Actors mode.

The Info panel and content-pack profile

The Info panel is where you set the scenario's identity: how the campaign relates to the rest of the game's content. Four fields get written into the exported Info.json from here. contentProfileId is an identifier for the campaign's content profile. requiredContentPacks lists the packs that have to be enabled for the campaign to work, which matters when the scenario depends on script content shipped in the same mod. disabledContentGroups and disabledContentKeys switch base-game content off, the first by whole groups and the second by individual type and key.

Those last two are how you make a campaign that leaves out the base game's buildings or units - a scenario, say, that shouldn't be offering content from a completely different setting. Disabling content is a topic in its own right. Disabling & Overriding Content covers exactly how the groups and keys work.

The Info panel: scenario name, content profile, required packs, and disabled content groups and keys.

Linking to a game build

To preview your campaign - to actually see it running rather than just baked - the editor links to a real build of the game and uses your linked-game mod selection as its preview content-pack set. In other words, the mods you've enabled in the linked game are the content the editor previews the campaign against.

This matters because of the profile fields above: if your scenario's requiredContentPacks names a pack that isn't enabled in the linked build, export validation will warn you, because the campaign would be missing content it declares it needs. Wiring the linked build up correctly means the editor can catch that kind of mismatch before your players do.

Selecting the linked game build and the mods that make up the preview content set.

Exporting

When the scenario is ready, you export. The editor bakes everything - provinces, rivers, terrain caches, routes, sea navigation, actors, and the Info.json profile - into a single map package:

Getting the campaign into your mod

The exported package goes into your mod's Data/Maps/ folder, and you point mod.json at it with a campaigns entry:

"campaigns": [
  { "id": "SicilySouthernItaly827", "path": "Data/Maps" }
]

The id must match the exported map's folder name under path, and that folder must contain the Info.json the editor wrote. The editor already checks the important parts for you: it warns at export if a requiredContentPack isn't enabled in your linked-build preview set, and the game reports any leftover problems in the Mods manager when it loads the pack.

Once the campaign is in place, it shows up in the game's main menu. From here you'll likely want to add gameplay content on top of the map (AngelScript) or a custom screen for it (Mod Screens) - but a map on its own is already a complete, playable mod.