From c2c8103490d11bc14e1d54d685aa268a30595927 Mon Sep 17 00:00:00 2001
From: Luan Santos <github@luan.sh>
Date: Mon, 9 Oct 2023 19:18:57 -0700
Subject: [PATCH] feat: zones

---
 .gitignore                     |   2 +
 CMakePresets.json              | 238 +++++----
 data/creatures/monsters.xml    |  14 +-
 data/menubar.xml               |   2 +
 source/CMakeLists.txt          |   8 +-
 source/application.cpp         |  31 +-
 source/brush.cpp               |   2 +
 source/brush.h                 | 349 ++++--------
 source/common.cpp              | 171 +++---
 source/common.h                |   2 +-
 source/common_windows.cpp      | 679 +++++++++++++-----------
 source/common_windows.h        | 171 +++---
 source/complexitem.h           |  18 +-
 source/editor.cpp              | 943 ++++++++++++++++-----------------
 source/graphics.h              |   1 +
 source/gui.h                   |   2 +
 source/gui_ids.h               |   7 +
 source/iomap_otbm.cpp          | 116 +++-
 source/iomap_otbm.h            |  81 +--
 source/main_menubar.cpp        |  34 +-
 source/main_menubar.h          |   4 +
 source/map.cpp                 | 489 +++++++++--------
 source/map.h                   | 165 +++---
 source/map_display.cpp         |   6 +-
 source/map_drawer.cpp          | 345 +++++-------
 source/monster_brush.cpp       |  52 +-
 source/monster_brush.h         |   1 +
 source/numbertextctrl.cpp      |  70 ++-
 source/palette_common.cpp      | 568 ++++++++++----------
 source/palette_monster.cpp     | 161 ++++--
 source/palette_monster.h       |  18 +-
 source/palette_window.cpp      | 224 ++++----
 source/palette_window.h        |  32 +-
 source/palette_zones.cpp       | 231 ++++++++
 source/palette_zones.h         |  67 +++
 source/preferences.cpp         | 247 +++++----
 source/preferences.h           |   1 +
 source/settings.cpp            |   2 +
 source/settings.h              |   2 +
 source/spawn_monster_brush.cpp |  47 +-
 source/spawn_monster_brush.h   |  30 +-
 source/tile.cpp                |   3 +
 source/tile.h                  |  13 +
 source/tileset.h               |   1 +
 source/zone_brush.cpp          |  56 ++
 source/zone_brush.h            |  51 ++
 source/zones.cpp               |  70 +++
 source/zones.h                 |  55 ++
 vcproj/Project/RME.vcxproj     |  17 +-
 49 files changed, 3368 insertions(+), 2531 deletions(-)
 create mode 100644 source/palette_zones.cpp
 create mode 100644 source/palette_zones.h
 create mode 100644 source/zone_brush.cpp
 create mode 100644 source/zone_brush.h
 create mode 100644 source/zones.cpp
 create mode 100644 source/zones.h

diff --git a/.gitignore b/.gitignore
index 46f6ceff..dfa2825e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,9 +10,11 @@ build-release
 CMakeLists.txt.user*
 
 # RME
+remeres
 rme
 rme.cfg
 data/user
+world
 
 # Visual Studio
 *.MAP
diff --git a/CMakePresets.json b/CMakePresets.json
index d7894fef..d67b075a 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -1,102 +1,140 @@
 {
-  "version": 3,
-  "cmakeMinimumRequired": {
-    "major": 3,
-    "minor": 22,
-    "patch": 0
-  },
-  "configurePresets": [
-    {
-      "name": "windows-release",
-      "displayName": "Windows - Release",
-      "description": "Sets Ninja generator, compilers, build and install directory and set build type as release",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build/${presetName}",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": {
-          "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
-          "type": "FILEPATH"
-        },
-        "VCPKG_TARGET_TRIPLET": "x64-windows-static",
-        "CMAKE_BUILD_TYPE": "Release",
-        "OPTIONS_ENABLE_SCCACHE": "ON"
-      },
-      "architecture": {
-        "value": "x64",
-        "strategy": "external"
-      },
-      "vendor": {
-        "microsoft.com/VisualStudioSettings/CMake/1.0": {
-          "hostOS": [ "Windows" ]
-        }
-      },
-      "condition": {
-        "type": "equals",
-        "lhs": "${hostSystemName}",
-        "rhs": "Windows"
-      }
-    },
-    {
-      "name": "linux-release",
-      "displayName": "Linux - Release",
-      "description": "Sets Ninja generator, compilers, build and install directory and set build type as release",
-      "generator": "Ninja",
-      "binaryDir": "${sourceDir}/build/${presetName}",
-      "cacheVariables": {
-        "CMAKE_TOOLCHAIN_FILE": {
-          "value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
-          "type": "FILEPATH"
-        },
-        "CMAKE_BUILD_TYPE": "Release",
-        "OPTIONS_ENABLE_CCACHE": "ON"
-      },
-      "condition": {
-        "type": "equals",
-        "lhs": "${hostSystemName}",
-        "rhs": "Linux"
-      }
-    },
-    {
-      "name": "windows-debug",
-      "inherits": "windows-release",
-      "displayName": "Windows - Debug",
-      "description": "Build Debug Mode",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "DEBUG_LOG": "ON"
-      },
-      "architecture": {
-        "value": "x64",
-        "strategy": "external"
-      }
-    },
-    {
-      "name": "linux-debug",
-      "inherits": "linux-release",
-      "displayName": "Linux - Debug Build",
-      "description": "Build Debug Mode",
-      "cacheVariables": {
-        "CMAKE_BUILD_TYPE": "Debug",
-        "DEBUG_LOG": "ON"
-      }
-    }
-  ],
-  "buildPresets": [
-    {
-      "name": "linux-release",
-      "configurePreset": "linux-release"
-    },
-    {
-      "name": "linux-debug",
-      "configurePreset": "linux-debug"
-    },
-    {
-      "name": "windows-release",
-      "configurePreset": "windows-release"
-    },
-    {
-      "name": "windows-Xdebug",
-      "configurePreset": "windows-debug"
-    }
-  ]
+	"version": 3,
+	"cmakeMinimumRequired": {
+		"major": 3,
+		"minor": 22,
+		"patch": 0
+	},
+	"configurePresets": [
+		{
+			"name": "windows-release",
+			"displayName": "Windows - Release",
+			"description": "Sets Ninja generator, compilers, build and install directory and set build type as release",
+			"generator": "Ninja",
+			"binaryDir": "${sourceDir}/build/${presetName}",
+			"cacheVariables": {
+				"CMAKE_TOOLCHAIN_FILE": {
+					"value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+					"type": "FILEPATH"
+				},
+				"VCPKG_TARGET_TRIPLET": "x64-windows-static",
+				"CMAKE_BUILD_TYPE": "Release",
+				"OPTIONS_ENABLE_SCCACHE": "ON"
+			},
+			"architecture": {
+				"value": "x64",
+				"strategy": "external"
+			},
+			"vendor": {
+				"microsoft.com/VisualStudioSettings/CMake/1.0": {
+					"hostOS": ["Windows"]
+				}
+			},
+			"condition": {
+				"type": "equals",
+				"lhs": "${hostSystemName}",
+				"rhs": "Windows"
+			}
+		},
+		{
+			"name": "linux-release",
+			"displayName": "Linux - Release",
+			"description": "Sets Ninja generator, compilers, build and install directory and set build type as release",
+			"generator": "Ninja",
+			"binaryDir": "${sourceDir}/build/${presetName}",
+			"cacheVariables": {
+				"CMAKE_TOOLCHAIN_FILE": {
+					"value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+					"type": "FILEPATH"
+				},
+				"CMAKE_BUILD_TYPE": "Release",
+				"OPTIONS_ENABLE_CCACHE": "ON"
+			},
+			"condition": {
+				"type": "equals",
+				"lhs": "${hostSystemName}",
+				"rhs": "Linux"
+			}
+		},
+		{
+			"name": "macos-release",
+			"displayName": "macOS - Release",
+			"description": "Sets Ninja generator, compilers, build and install directory and set build type as release",
+			"generator": "Ninja",
+			"binaryDir": "${sourceDir}/build/${presetName}",
+			"cacheVariables": {
+				"CMAKE_TOOLCHAIN_FILE": {
+					"value": "$env{VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake",
+					"type": "FILEPATH"
+				},
+				"CMAKE_BUILD_TYPE": "Release",
+				"OPTIONS_ENABLE_CCACHE": "ON"
+			},
+			"condition": {
+				"type": "equals",
+				"lhs": "${hostSystemName}",
+				"rhs": "Darwin"
+			}
+		},
+		{
+			"name": "windows-debug",
+			"inherits": "windows-release",
+			"displayName": "Windows - Debug",
+			"description": "Build Debug Mode",
+			"cacheVariables": {
+				"CMAKE_BUILD_TYPE": "Debug",
+				"DEBUG_LOG": "ON"
+			},
+			"architecture": {
+				"value": "x64",
+				"strategy": "external"
+			}
+		},
+		{
+			"name": "linux-debug",
+			"inherits": "linux-release",
+			"displayName": "Linux - Debug Build",
+			"description": "Build Debug Mode",
+			"cacheVariables": {
+				"CMAKE_BUILD_TYPE": "Debug",
+				"DEBUG_LOG": "ON"
+			}
+		},
+		{
+			"name": "macos-debug",
+			"inherits": "macos-release",
+			"displayName": "macOS - Debug Build",
+			"description": "Build Debug Mode",
+			"cacheVariables": {
+				"CMAKE_BUILD_TYPE": "Debug",
+				"DEBUG_LOG": "ON"
+			}
+		}
+	],
+	"buildPresets": [
+		{
+			"name": "linux-release",
+			"configurePreset": "linux-release"
+		},
+		{
+			"name": "linux-debug",
+			"configurePreset": "linux-debug"
+		},
+		{
+			"name": "windows-release",
+			"configurePreset": "windows-release"
+		},
+		{
+			"name": "windows-Xdebug",
+			"configurePreset": "windows-debug"
+		},
+		{
+			"name": "macos-release",
+			"configurePreset": "macos-release"
+		},
+		{
+			"name": "macos-debug",
+			"configurePreset": "macos-debug"
+		}
+	]
 }
diff --git a/data/creatures/monsters.xml b/data/creatures/monsters.xml
index ae000a97..3c35be71 100644
--- a/data/creatures/monsters.xml
+++ b/data/creatures/monsters.xml
@@ -5,7 +5,7 @@
     <monster name="Abyssador" looktype="495" />
     <monster name="Abyssal Calamary" looktype="451" />
     <monster name="Achad" looktype="146" lookhead="93" lookbody="93" looklegs="57" lookfeet="97" lookaddons="3" />
-    <monster name="Acid Blob" looktype="314" />
+    <monster name="Acid Blob" looktype="315" />
     <monster name="Acolyte Of Darkness" looktype="9" />
     <monster name="Acolyte Of The Cult" looktype="194" lookhead="114" lookbody="121" looklegs="121" lookfeet="57" lookaddons="0" />
     <monster name="Adept Of The Cult" looktype="194" lookhead="114" lookbody="94" looklegs="94" lookfeet="57" lookaddons="0" />
@@ -228,7 +228,7 @@
     <monster name="Cult Believer" looktype="132" lookhead="98" lookbody="77" looklegs="39" lookfeet="57" lookaddons="1" />
     <monster name="Cult Enforcer" looktype="134" lookhead="114" lookbody="19" looklegs="76" lookfeet="76" lookaddons="1" />
     <monster name="Cult Scholar" looktype="145" />
-    <monster name="Cursed Ape" looktype="1592" />
+    <monster name="Cursed Ape" looktype="1506" />
     <monster name="Cursed Book" looktype="1061" lookhead="79" lookbody="83" looklegs="113" lookfeet="0" lookaddons="0" />
     <monster name="Cursed Gladiator" looktype="100" />
     <monster name="Cursed Prospector" looktype="1268" />
@@ -616,11 +616,10 @@
     <monster name="Ice Witch" looktype="149" />
     <monster name="Icecold Book" looktype="1061" lookhead="87" lookbody="85" looklegs="79" lookfeet="0" lookaddons="0" />
     <monster name="Icicle" looktype="904" />
-    <monster name="Iks Ahpututu" looktype="1590" />
-    <monster name="Iks Aucar" looktype="1587" />
-    <monster name="Iks Chuka" looktype="1588" />
-    <monster name="Iks Churrascan" looktype="1587" />
-    <monster name="Iks Pututu" looktype="1589" />
+    <monster name="Iks Ahpututu" looktype="1509" />
+    <monster name="Iks Aucar" looktype="1507" />
+    <monster name="Iks Chuka" looktype="1508" />
+    <monster name="Iks Pututu" looktype="1508" />
     <monster name="Imp Intruder" looktype="237" />
     <monster name="Incineron" looktype="243" />
     <monster name="Incredibly Old Witch" looktype="54" />
@@ -1408,4 +1407,5 @@
     <monster name="Zugurosh" looktype="12" lookhead="2" lookbody="35" looklegs="57" lookfeet="91" lookaddons="0" />
     <monster name="Zulazza The Corruptor" looktype="334" />
     <monster name="Zushuka" looktype="149" lookhead="86" lookbody="12" looklegs="31" lookfeet="60" lookaddons="0" />
+    <monster name="Elf Overseer" looktype="159" lookhead="57" lookbody="95" looklegs="114" lookfeet="116" lookaddons="0" />
 </monsters>
diff --git a/data/menubar.xml b/data/menubar.xml
index 2d1eb472..391960ed 100644
--- a/data/menubar.xml
+++ b/data/menubar.xml
@@ -80,6 +80,7 @@
         <item name="Replace Items on Selection" action="REPLACE_ON_SELECTION_ITEMS" help="Replace items on selected area."/>
         <item name="Find Item on Selection" action="SEARCH_ON_SELECTION_ITEM" help="Find items on selected area."/>
         <item name="Remove Item on Selection" action="REMOVE_ON_SELECTION_ITEM" help="Remove item on selected area."/>
+        <item name="Remove Monsters on Selection" action="REMOVE_ON_SELECTION_MONSTER" help="Remove monsters on selected area."/>
         <separator/>
         <menu name="$Find on Selection">
             <item name="Find $Everything" action="SEARCH_ON_SELECTION_EVERYTHING" help="Find all unique/action/text/container items."/>
@@ -157,6 +158,7 @@
         <item name="$Creature Palette" hotkey="C" action="SELECT_MONSTER" help="Select the Creature palette."/>
         <item name="$Npc Palette" hotkey="N" action="SELECT_NPC" help="Select the Npc palette."/>
         <item name="$Waypoint Palette" hotkey="W" action="SELECT_WAYPOINT" help="Select the Waypoint palette."/>
+        <item name="$Zones Palette" hotkey="Z" action="SELECT_ZONES" help="Select the Zones palette."/>
         <item name="$RAW Palette" hotkey="R" action="SELECT_RAW" help="Select the RAW palette."/>
     </menu>
     <!--
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index d2c37971..70db7a5f 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -6,7 +6,7 @@ project(remeres)
 
 find_package(asio CONFIG REQUIRED)
 find_package(fmt CONFIG REQUIRED)
-find_package(GLUT REQUIRED)
+find_package(glfw3 CONFIG REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)
 find_package(OpenGL REQUIRED)
 find_package(Threads REQUIRED)
@@ -171,6 +171,7 @@ target_sources(${PROJECT_NAME}
 	palette_house.cpp
 	palette_npc.cpp
 	palette_waypoints.cpp
+	palette_zones.cpp
 	palette_window.cpp
 	pngfiles.cpp
 	preferences.cpp
@@ -199,20 +200,21 @@ target_sources(${PROJECT_NAME}
 	waypoint_brush.cpp
 	waypoints.cpp
 	welcome_dialog.cpp
+	zone_brush.cpp
+	zones.cpp
 )
 
 target_include_directories(${PROJECT_NAME}
 	PRIVATE
 	${CMAKE_SOURCE_DIR}/source
 	${OPENGL_INCLUDE_DIR}
-	${GLUT_INCLUDE_DIRS}
 	${ZLIB_INCLUDE_DIR}
 )
 
 target_link_libraries(${PROJECT_NAME}
 	PRIVATE
 	${OPENGL_LIBRARIES}
-	${GLUT_LIBRARIES}
+	glfw
 	${ZLIB_LIBRARIES}
 	fmt::fmt
 	asio::asio
diff --git a/source/application.cpp b/source/application.cpp
index dd53650b..d95c7dff 100644
--- a/source/application.cpp
+++ b/source/application.cpp
@@ -276,15 +276,13 @@ bool Application::OnInit() {
 void Application::OnEventLoopEnter(wxEventLoopBase* loop) {
 
 	// First startup?
-	if (!m_startup) {
+	if (!m_startup)
 		return;
-	}
 	m_startup = false;
 
 	// Don't try to create a map if we didn't load the client map.
-	if (ClientVersion::getLatestVersion() == nullptr) {
+	if (ClientVersion::getLatestVersion() == nullptr)
 		return;
-	}
 
 	// Open a map.
 	if (m_file_to_open != wxEmptyString) {
@@ -373,9 +371,8 @@ MainFrame::MainFrame(const wxString &title, const wxPoint &pos, const wxSize &si
 
 	wxFileName filename;
 	filename.Assign(g_gui.getFoundDataDirectory() + "menubar.xml");
-	if (!filename.FileExists()) {
+	if (!filename.FileExists())
 		filename = FileName(GUI::GetDataDirectory() + "menubar.xml");
-	}
 
 	if (!menu_bar->Load(filename, warnings, error)) {
 		wxLogError(wxString() + "Could not load menubar.xml, editor will NOT be able to show its menu.\n");
@@ -410,9 +407,8 @@ void MainFrame::OnUpdateReceived(wxCommandEvent &event) {
 	size_t first_colon = data.find(':');
 	size_t second_colon = data.find(':', first_colon + 1);
 
-	if (first_colon == std::string::npos || second_colon == std::string::npos) {
+	if (first_colon == std::string::npos || second_colon == std::string::npos)
 		return;
-	}
 
 	std::string update = data.substr(0, first_colon);
 	std::string verstr = data.substr(first_colon + 1, second_colon - first_colon - 1);
@@ -426,9 +422,8 @@ void MainFrame::OnUpdateReceived(wxCommandEvent &event) {
 			"I don't want any update notices",
 			Config::AUTOCHECK_FOR_UPDATES
 		);
-		if (ret == wxID_YES) {
+		if (ret == wxID_YES)
 			::wxLaunchDefaultBrowser(wxstr(url), wxBROWSER_NEW_WINDOW);
-		}
 	}
 }
 #endif
@@ -447,13 +442,11 @@ void MainFrame::OnUpdateActions(wxCommandEvent &) {
 #ifdef __WINDOWS__
 bool MainFrame::MSWTranslateMessage(WXMSG* msg) {
 	if (g_gui.AreHotkeysEnabled()) {
-		if (wxFrame::MSWTranslateMessage(msg)) {
+		if (wxFrame::MSWTranslateMessage(msg))
 			return true;
-		}
 	} else {
-		if (wxWindow::MSWTranslateMessage(msg)) {
+		if (wxWindow::MSWTranslateMessage(msg))
 			return true;
-		}
 	}
 	return false;
 }
@@ -561,11 +554,10 @@ bool MainFrame::DoQueryImportCreatures() {
 						wxString error;
 						wxArrayString warnings;
 						bool ok = g_monsters.importXMLFromOT(FileName(paths[i]), error, warnings);
-						if (ok) {
+						if (ok)
 							g_gui.ListDialog("Monster loader errors", warnings);
-						} else {
+						else
 							wxMessageBox("Error OT data file \"" + paths[i] + "\".\n" + error, "Error", wxOK | wxICON_INFORMATION, g_gui.root);
-						}
 					}
 				} else {
 					break;
@@ -586,11 +578,10 @@ bool MainFrame::DoQueryImportCreatures() {
 						wxString error;
 						wxArrayString warnings;
 						bool ok = g_npcs.importXMLFromOT(FileName(paths[i]), error, warnings);
-						if (ok) {
+						if (ok)
 							g_gui.ListDialog("Npc loader errors", warnings);
-						} else {
+						else
 							wxMessageBox("Error OT data file \"" + paths[i] + "\".\n" + error, "Error", wxOK | wxICON_INFORMATION, g_gui.root);
-						}
 					}
 				} else {
 					break;
diff --git a/source/brush.cpp b/source/brush.cpp
index 391ddbc5..949a24cf 100644
--- a/source/brush.cpp
+++ b/source/brush.cpp
@@ -31,6 +31,7 @@
 #include "table_brush.h"
 #include "wall_brush.h"
 #include "waypoint_brush.h"
+#include "zone_brush.h"
 
 #include "settings.h"
 
@@ -87,6 +88,7 @@ void Brushes::init() {
 	addBrush(g_gui.rook_brush = newd FlagBrush(TILESTATE_NOPVP));
 	addBrush(g_gui.nolog_brush = newd FlagBrush(TILESTATE_NOLOGOUT));
 	addBrush(g_gui.pvp_brush = newd FlagBrush(TILESTATE_PVPZONE));
+	addBrush(g_gui.zone_brush = newd ZoneBrush());
 
 	GroundBrush::init();
 	WallBrush::init();
diff --git a/source/brush.h b/source/brush.h
index b58454b4..6d79d6ca 100644
--- a/source/brush.h
+++ b/source/brush.h
@@ -54,13 +54,15 @@ class HouseExitBrush;
 class WaypointBrush;
 class FlagBrush;
 class EraserBrush;
+class ZoneBrush;
 
 //=============================================================================
 // Brushes, holds all brushes
 
 typedef std::multimap<std::string, Brush*> BrushMap;
 
-class Brushes {
+class Brushes
+{
 public:
 	Brushes();
 	~Brushes();
@@ -68,16 +70,14 @@ class Brushes {
 	void init();
 	void clear();
 
-	Brush* getBrush(const std::string &name) const;
+	Brush* getBrush(const std::string& name) const;
 
 	void addBrush(Brush* brush);
 
-	bool unserializeBorder(pugi::xml_node node, wxArrayString &warnings);
-	bool unserializeBrush(pugi::xml_node node, wxArrayString &warnings);
+	bool unserializeBorder(pugi::xml_node node, wxArrayString& warnings);
+	bool unserializeBrush(pugi::xml_node node, wxArrayString& warnings);
 
-	const BrushMap &getMap() const noexcept {
-		return brushes;
-	}
+	const BrushMap& getMap() const noexcept { return brushes; }
 
 protected:
 	typedef std::map<uint32_t, AutoBorder*> BorderMap;
@@ -93,172 +93,83 @@ extern Brushes g_brushes;
 //=============================================================================
 // Common brush interface
 
-class Brush {
+class Brush
+{
 public:
 	Brush();
 	virtual ~Brush();
 
-	virtual bool load(pugi::xml_node node, wxArrayString &warnings) {
+	virtual bool load(pugi::xml_node node, wxArrayString& warnings) {
 		return true;
 	}
 
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter = nullptr) = 0;
 	virtual void undraw(BaseMap* map, Tile* tile) = 0;
-	virtual bool canDraw(BaseMap* map, const Position &position) const = 0;
+	virtual bool canDraw(BaseMap* map, const Position& position) const = 0;
 
 	//
-	uint32_t getID() const noexcept {
-		return id;
-	}
+	uint32_t getID() const noexcept { return id; }
 
 	virtual std::string getName() const = 0;
-	virtual void setName(const std::string &newName) {
+	virtual void setName(const std::string& newName) {
 		ASSERT(_MSG("setName attempted on nameless brush!"));
 	}
 
 	virtual int getLookID() const = 0;
 
-	virtual bool needBorders() const {
-		return false;
-	}
-
-	virtual bool canDrag() const {
-		return false;
-	}
-	virtual bool canSmear() const {
-		return true;
-	}
-
-	virtual bool oneSizeFitsAll() const {
-		return false;
-	}
-
-	virtual int32_t getMaxVariation() const {
-		return 0;
-	}
-
-	virtual bool isRaw() const {
-		return false;
-	}
-	virtual bool isDoodad() const {
-		return false;
-	}
-	virtual bool isTerrain() const {
-		return false;
-	}
-	virtual bool isGround() const {
-		return false;
-	}
-	virtual bool isWall() const {
-		return false;
-	}
-	virtual bool isWallDecoration() const {
-		return false;
-	}
-	virtual bool isTable() const {
-		return false;
-	}
-	virtual bool isCarpet() const {
-		return false;
-	}
-	virtual bool isDoor() const {
-		return false;
-	}
-	virtual bool isOptionalBorder() const {
-		return false;
-	}
-	virtual bool isMonster() const {
-		return false;
-	}
-	virtual bool isSpawnMonster() const {
-		return false;
-	}
-	virtual bool isNpc() const {
-		return false;
-	}
-	virtual bool isSpawnNpc() const {
-		return false;
-	}
-	virtual bool isHouse() const {
-		return false;
-	}
-	virtual bool isHouseExit() const {
-		return false;
-	}
-	virtual bool isWaypoint() const {
-		return false;
-	}
-	virtual bool isFlag() const {
-		return false;
-	}
-	virtual bool isEraser() const {
-		return false;
-	}
-
-	virtual RAWBrush* asRaw() {
-		return nullptr;
-	}
-	virtual DoodadBrush* asDoodad() {
-		return nullptr;
-	}
-	virtual TerrainBrush* asTerrain() {
-		return nullptr;
-	}
-	virtual GroundBrush* asGround() {
-		return nullptr;
-	}
-	virtual WallBrush* asWall() {
-		return nullptr;
-	}
-	virtual WallDecorationBrush* asWallDecoration() {
-		return nullptr;
-	}
-	virtual TableBrush* asTable() {
-		return nullptr;
-	}
-	virtual CarpetBrush* asCarpet() {
-		return nullptr;
-	}
-	virtual DoorBrush* asDoor() {
-		return nullptr;
-	}
-	virtual OptionalBorderBrush* asOptionalBorder() {
-		return nullptr;
-	}
-	virtual MonsterBrush* asMonster() {
-		return nullptr;
-	}
-	virtual SpawnMonsterBrush* asSpawnMonster() {
-		return nullptr;
-	}
-	virtual NpcBrush* asNpc() {
-		return nullptr;
-	}
-	virtual SpawnNpcBrush* asSpawnNpc() {
-		return nullptr;
-	}
-	virtual HouseBrush* asHouse() {
-		return nullptr;
-	}
-	virtual HouseExitBrush* asHouseExit() {
-		return nullptr;
-	}
-	virtual WaypointBrush* asWaypoint() {
-		return nullptr;
-	}
-	virtual FlagBrush* asFlag() {
-		return nullptr;
-	}
-	virtual EraserBrush* asEraser() {
-		return nullptr;
-	}
-
-	bool visibleInPalette() const {
-		return visible;
-	}
-	void flagAsVisible() {
-		visible = true;
-	}
+	virtual bool needBorders() const { return false; }
+
+	virtual bool canDrag() const { return false; }
+	virtual bool canSmear() const { return true; }
+
+	virtual bool oneSizeFitsAll() const { return false; }
+
+	virtual int32_t getMaxVariation() const { return 0; }
+
+	virtual bool isRaw() const { return false; }
+	virtual bool isDoodad() const { return false; }
+	virtual bool isTerrain() const { return false; }
+	virtual bool isGround() const { return false; }
+	virtual bool isWall() const { return false; }
+	virtual bool isWallDecoration() const { return false; }
+	virtual bool isTable() const { return false; }
+	virtual bool isCarpet() const { return false; }
+	virtual bool isDoor() const { return false; }
+	virtual bool isOptionalBorder() const { return false; }
+	virtual bool isMonster() const { return false; }
+	virtual bool isSpawnMonster() const { return false; }
+	virtual bool isNpc() const { return false; }
+	virtual bool isSpawnNpc() const { return false; }
+	virtual bool isHouse() const { return false; }
+	virtual bool isHouseExit() const { return false; }
+	virtual bool isWaypoint() const { return false; }
+	virtual bool isZone() const { return false; }
+	virtual bool isFlag() const { return false; }
+	virtual bool isEraser() const { return false; }
+
+	virtual RAWBrush* asRaw() { return nullptr; }
+	virtual DoodadBrush* asDoodad() { return nullptr; }
+	virtual TerrainBrush* asTerrain() { return nullptr; }
+	virtual GroundBrush* asGround() { return nullptr; }
+	virtual WallBrush* asWall() { return nullptr; }
+	virtual WallDecorationBrush* asWallDecoration() { return nullptr; }
+	virtual TableBrush* asTable() { return nullptr; }
+	virtual CarpetBrush* asCarpet() { return nullptr; }
+	virtual DoorBrush* asDoor() { return nullptr; }
+	virtual OptionalBorderBrush* asOptionalBorder() { return nullptr; }
+	virtual MonsterBrush* asMonster() { return nullptr; }
+	virtual SpawnMonsterBrush* asSpawnMonster() { return nullptr; }
+	virtual NpcBrush* asNpc() { return nullptr; }
+	virtual SpawnNpcBrush* asSpawnNpc() { return nullptr; }
+	virtual HouseBrush* asHouse() { return nullptr; }
+	virtual HouseExitBrush* asHouseExit() { return nullptr; }
+	virtual WaypointBrush* asWaypoint() { return nullptr; }
+	virtual FlagBrush* asFlag() { return nullptr; }
+	virtual EraserBrush* asEraser() { return nullptr; }
+	virtual ZoneBrush* asZone() { return nullptr; }
+
+	bool visibleInPalette() const { return visible; }
+	void flagAsVisible() { visible = true; }
 
 protected:
 	static uint32_t id_counter;
@@ -269,42 +180,25 @@ class Brush {
 //=============================================================================
 // Terrain brush interface
 
-class TerrainBrush : public Brush {
+class TerrainBrush : public Brush
+{
 public:
 	TerrainBrush();
 	virtual ~TerrainBrush();
 
-	bool isTerrain() const {
-		return true;
-	}
-	TerrainBrush* asTerrain() {
-		return static_cast<TerrainBrush*>(this);
-	}
+	bool isTerrain() const { return true; }
+	TerrainBrush* asTerrain() { return static_cast<TerrainBrush*>(this); }
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const {
-		return true;
-	}
+	virtual bool canDraw(BaseMap* map, const Position& position) const { return true; }
 
-	virtual std::string getName() const {
-		return name;
-	}
-	virtual void setName(const std::string &newName) {
-		name = newName;
-	}
+	virtual std::string getName() const { return name; }
+	virtual void setName(const std::string& newName) { name = newName; }
 
-	virtual int32_t getZ() const {
-		return 0;
-	}
-	virtual int32_t getLookID() const {
-		return look_id;
-	}
+	virtual int32_t getZ() const { return 0; }
+	virtual int32_t getLookID() const { return look_id; }
 
-	virtual bool needBorders() const {
-		return true;
-	}
-	virtual bool canDrag() const {
-		return true;
-	}
+	virtual bool needBorders() const { return true; }
+	virtual bool canDrag() const { return true; }
 
 	bool friendOf(TerrainBrush* other);
 
@@ -318,25 +212,20 @@ class TerrainBrush : public Brush {
 //=============================================================================
 // FlagBrush, draw PZ etc.
 
-class FlagBrush : public Brush {
+class FlagBrush : public Brush
+{
 public:
 	FlagBrush(uint32_t _flag);
 	virtual ~FlagBrush();
 
-	bool isFlag() const {
-		return true;
-	}
-	FlagBrush* asFlag() {
-		return static_cast<FlagBrush*>(this);
-	}
+	bool isFlag() const { return true; }
+	FlagBrush* asFlag() { return static_cast<FlagBrush*>(this); }
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const;
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
 	virtual void undraw(BaseMap* map, Tile* tile);
 
-	virtual bool canDrag() const {
-		return true;
-	}
+	virtual bool canDrag() const {return true;}
 	virtual int getLookID() const;
 	virtual std::string getName() const;
 
@@ -347,29 +236,24 @@ class FlagBrush : public Brush {
 //=============================================================================
 // Doorbrush, add doors, windows etc.
 
-class DoorBrush : public Brush {
+class DoorBrush : public Brush
+{
 public:
 	DoorBrush(DoorType _doortype);
 	virtual ~DoorBrush();
 
-	bool isDoor() const {
-		return true;
-	}
-	DoorBrush* asDoor() {
-		return static_cast<DoorBrush*>(this);
-	}
+	bool isDoor() const { return true; }
+	DoorBrush* asDoor() { return static_cast<DoorBrush*>(this); }
 
 	static void switchDoor(Item* door);
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const;
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
 	virtual void undraw(BaseMap* map, Tile* tile);
 
 	virtual int getLookID() const;
 	virtual std::string getName() const;
-	virtual bool oneSizeFitsAll() const {
-		return true;
-	}
+	virtual bool oneSizeFitsAll() const { return true; }
 
 protected:
 	DoorType doortype;
@@ -378,25 +262,20 @@ class DoorBrush : public Brush {
 //=============================================================================
 // OptionalBorderBrush, add gravel 'round mountains.
 
-class OptionalBorderBrush : public Brush {
+class OptionalBorderBrush : public Brush
+{
 public:
 	OptionalBorderBrush();
 	virtual ~OptionalBorderBrush();
 
-	bool isOptionalBorder() const {
-		return true;
-	}
-	OptionalBorderBrush* asOptionalBorder() {
-		return static_cast<OptionalBorderBrush*>(this);
-	}
+	bool isOptionalBorder() const { return true; }
+	OptionalBorderBrush* asOptionalBorder() { return static_cast<OptionalBorderBrush*>(this); }
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const;
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
 	virtual void undraw(BaseMap* map, Tile* tile);
 
-	virtual bool canDrag() const {
-		return true;
-	}
+	virtual bool canDrag() const { return true; }
 	virtual int getLookID() const;
 	virtual std::string getName() const;
 };
@@ -404,28 +283,21 @@ class OptionalBorderBrush : public Brush {
 //=============================================================================
 // Rampbrush, add ramps to mountains.
 
-class EraserBrush : public Brush {
+class EraserBrush : public Brush
+{
 public:
 	EraserBrush();
 	virtual ~EraserBrush();
 
-	bool isEraser() const {
-		return true;
-	}
-	EraserBrush* asEraser() {
-		return static_cast<EraserBrush*>(this);
-	}
+	bool isEraser() const { return true; }
+	EraserBrush* asEraser() { return static_cast<EraserBrush*>(this); }
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const;
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
 	virtual void undraw(BaseMap* map, Tile* tile);
 
-	virtual bool needBorders() const {
-		return true;
-	}
-	virtual bool canDrag() const {
-		return true;
-	}
+	virtual bool needBorders() const { return true; }
+	virtual bool canDrag() const { return true; }
 	virtual int getLookID() const;
 	virtual std::string getName() const;
 };
@@ -433,18 +305,16 @@ class EraserBrush : public Brush {
 //=============================================================================
 // Autoborder, used by GroundBrush, should be transparent to users
 
-class AutoBorder {
+class AutoBorder
+{
 public:
-	AutoBorder(int _id) :
-		id(_id), group(0), ground(false) {
-		for (int i = 0; i < 13; i++) {
-			tiles[i] = 0;
-		}
+	AutoBorder(int _id) : id(_id), group(0), ground(false) {
+		for(int i = 0; i < 13; i++) tiles[i] = 0;
 	}
-	~AutoBorder() { }
+	~AutoBorder() {}
 
-	static int edgeNameToID(const std::string &edgename);
-	bool load(pugi::xml_node node, wxArrayString &warnings, GroundBrush* owner = nullptr, uint16_t ground_equivalent = 0);
+	static int edgeNameToID(const std::string& edgename);
+	bool load(pugi::xml_node node, wxArrayString& warnings, GroundBrush* owner = nullptr, uint16_t ground_equivalent = 0);
 
 	uint32_t tiles[13];
 	uint32_t id;
@@ -453,3 +323,4 @@ class AutoBorder {
 };
 
 #endif
+
diff --git a/source/common.cpp b/source/common.cpp
index fe88f6f7..f3a676b4 100644
--- a/source/common.cpp
+++ b/source/common.cpp
@@ -21,141 +21,162 @@
 #include "math.h"
 
 // random generator
-std::mt19937 &getRandomGenerator() {
+std::mt19937& getRandomGenerator()
+{
 	static std::random_device rd;
 	static std::mt19937 generator(rd());
 	return generator;
 }
 
-int32_t uniform_random(int32_t minNumber, int32_t maxNumber) {
+int32_t uniform_random(int32_t minNumber, int32_t maxNumber)
+{
 	static std::uniform_int_distribution<int32_t> uniformRand;
-	if (minNumber == maxNumber) {
+	if(minNumber == maxNumber) {
 		return minNumber;
-	} else if (minNumber > maxNumber) {
+	} else if(minNumber > maxNumber) {
 		std::swap(minNumber, maxNumber);
 	}
 	return uniformRand(getRandomGenerator(), std::uniform_int_distribution<int32_t>::param_type(minNumber, maxNumber));
 }
 
-int32_t uniform_random(int32_t maxNumber) {
+int32_t uniform_random(int32_t maxNumber)
+{
 	return uniform_random(0, maxNumber);
 }
 
 //
-std::string i2s(const int _i) {
+std::string i2s(const int _i)
+{
 	static std::stringstream ss;
 	ss.str("");
 	ss << _i;
 	return ss.str();
 }
 
-std::string f2s(const double _d) {
+std::string f2s(const double _d)
+{
 	static std::stringstream ss;
 	ss.str("");
 	ss << _d;
 	return ss.str();
 }
 
-int s2i(const std::string s) {
+int s2i(const std::string s)
+{
 	return atoi(s.c_str());
 }
 
-double s2f(const std::string s) {
+double s2f(const std::string s)
+{
 	return atof(s.c_str());
 }
 
-wxString i2ws(const int _i) {
+wxString i2ws(const int _i)
+{
 	wxString str;
 	str << _i;
 	return str;
 }
 
-wxString f2ws(const double _d) {
+wxString f2ws(const double _d)
+{
 	wxString str;
 	str << _d;
 	return str;
 }
 
-int ws2i(const wxString s) {
+int ws2i(const wxString s)
+{
 	long _i;
-	if (s.ToLong(&_i)) {
+	if(s.ToLong(&_i))
 		return int(_i);
-	}
 	return 0;
 }
 
-double ws2f(const wxString s) {
+double ws2f(const wxString s)
+{
 	double _d;
-	if (s.ToDouble(&_d)) {
+	if(s.ToDouble(&_d))
 		return _d;
-	}
 	return 0.0;
 }
 
-void replaceString(std::string &str, const std::string sought, const std::string replacement) {
+void replaceString(std::string& str, const std::string sought, const std::string replacement)
+{
 	size_t pos = 0;
 	size_t start = 0;
 	size_t soughtLen = sought.length();
 	size_t replaceLen = replacement.length();
-	while ((pos = str.find(sought, start)) != std::string::npos) {
+	while((pos = str.find(sought, start)) != std::string::npos) {
 		str = str.substr(0, pos) + replacement + str.substr(pos + soughtLen);
 		start = pos + replaceLen;
 	}
 }
 
-void trim_right(std::string &source, const std::string &t) {
-	source.erase(source.find_last_not_of(t) + 1);
+void trim_right(std::string& source, const std::string& t)
+{
+	source.erase(source.find_last_not_of(t)+1);
 }
 
-void trim_left(std::string &source, const std::string &t) {
+void trim_left(std::string& source, const std::string& t)
+{
 	source.erase(0, source.find_first_not_of(t));
 }
 
-void trim(std::string &str) {
+void trim(std::string& str) {
 	// Trim from start
-	str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](int ch) { return !std::isspace(ch); }));
+	str.erase(str.begin(), std::find_if(str.begin(), str.end(),
+		[](int ch) { return !std::isspace(ch); }));
 
 	// Trim from end
-	str.erase(std::find_if(str.rbegin(), str.rend(), [](int ch) { return !std::isspace(ch); }).base(), str.end());
+	str.erase(std::find_if(str.rbegin(), str.rend(),
+		[](int ch) { return !std::isspace(ch); }).base(), str.end());
 }
 
-void to_lower_str(std::string &source) {
+void to_lower_str(std::string& source)
+{
 	std::transform(source.begin(), source.end(), source.begin(), tolower);
 }
 
-void to_upper_str(std::string &source) {
+void to_upper_str(std::string& source)
+{
 	std::transform(source.begin(), source.end(), source.begin(), toupper);
 }
 
-std::string as_lower_str(const std::string &other) {
+std::string as_lower_str(const std::string& other)
+{
 	std::string ret = other;
 	to_lower_str(ret);
 	return ret;
 }
 
-std::string as_upper_str(const std::string &other) {
+std::string as_upper_str(const std::string& other)
+{
 	std::string ret = other;
 	to_upper_str(ret);
 	return ret;
 }
 
-bool isFalseString(std::string &str) {
-	if (str == "false" || str == "0" || str == "" || str == "no" || str == "not") {
+bool isFalseString(std::string& str)
+{
+	if(str == "false" || str == "0" || str == "" || str == "no" || str == "not") {
 		return true;
 	}
 	return false;
 }
 
-bool isTrueString(std::string &str) {
+bool isTrueString(std::string& str)
+{
 	return !isFalseString(str);
 }
 
-int random(int low, int high) {
-	if (low == high) {
+int random(int low, int high)
+{
+	if(low == high) {
 		return low;
 	}
 
-	if (low > high) {
+	if(low > high) {
 		return low;
 	}
 
@@ -165,51 +186,54 @@ int random(int low, int high) {
 	return low + std::min(range, int((1 + range) * dist));
 }
 
-int random(int high) {
-	return random(0, high);
+int random(int high)
+{
+	return random(0,high);
 }
 
-std::wstring string2wstring(const std::string &utf8string) {
+std::wstring string2wstring(const std::string& utf8string)
+{
 	wxString s(utf8string.c_str(), wxConvUTF8);
 	return std::wstring((const wchar_t*)s.c_str());
 }
 
-std::string wstring2string(const std::wstring &widestring) {
+std::string wstring2string(const std::wstring& widestring)
+{
 	wxString s(widestring.c_str());
 	return std::string((const char*)s.mb_str(wxConvUTF8));
 }
 
-bool posFromClipboard(int &x, int &y, int &z) {
+bool posFromClipboard(int& x, int& y, int& z)
+{
 	bool done = false;
 
-	if (wxTheClipboard->Open()) {
-		if (wxTheClipboard->IsSupported(wxDF_TEXT)) {
+	if(wxTheClipboard->Open()) {
+		if(wxTheClipboard->IsSupported(wxDF_TEXT)) {
 			std::vector<int> values;
 			wxTextDataObject data;
 			wxTheClipboard->GetData(data);
-			wxString text = data.GetText();
+			auto text = data.GetText().ToStdString();
 
-			if (text.size() < 50) {
+			if(text.size() < 50) {
 				bool r = false;
 				wxString sv;
 
-				for (size_t s = 0; s < text.size(); ++s) {
-					if (text[s] >= '0' && text[s] <= '9') {
+				for(size_t s = 0; s < text.size(); ++s) {
+					if(text[s] >= '0' && text[s] <= '9') {
 						sv << text[s];
 						r = true;
-					} else if (r) {
+					} else if(r) {
 						values.push_back(ws2i(sv));
 						sv.Clear();
 						r = false;
 
-						if (values.size() >= 3) {
+						if(values.size() >= 3)
 							break;
-						}
 					}
 				}
 			}
 
-			if (values.size() == 3) {
+			if(values.size() == 3) {
 				x = values[0];
 				y = values[1];
 				z = values[2];
@@ -221,10 +245,10 @@ bool posFromClipboard(int &x, int &y, int &z) {
 	return done;
 }
 
-bool posToClipboard(int x, int y, int z, int format) {
-	if (!wxTheClipboard->Open()) {
+bool posToClipboard(int x, int y, int z, int format)
+{
+	if (!wxTheClipboard->Open())
 		return false;
-	}
 
 	wxTextDataObject* data = new wxTextDataObject();
 
@@ -254,38 +278,39 @@ bool posToClipboard(int x, int y, int z, int format) {
 	return true;
 }
 
-bool posToClipboard(int fromx, int fromy, int fromz, int tox, int toy, int toz) {
-	if (!wxTheClipboard->Open()) {
+bool posToClipboard(int fromx, int fromy, int fromz, int tox, int toy, int toz, int format)
+{
+	if (!wxTheClipboard->Open())
 		return false;
-	}
 
-	std::ostringstream clip;
-	clip << "{";
-	clip << "fromx = " << fromx << ", ";
-	clip << "tox = " << tox << ", ";
-	clip << "fromy = " << fromy << ", ";
-	clip << "toy = " << toy << ", ";
-	if (fromz != toz) {
-		clip << "fromz = " << fromz << ", ";
-		clip << "toz = " << toz;
-	} else {
-		clip << "z = " << fromz;
+	wxTextDataObject* data = new wxTextDataObject();
+
+	switch (format) {
+		case 0:
+			data->SetText(wxString::Format("{fromx = %d, tox = %d, fromy = %d, toy = %d, fromz = %d, toz = %d}", fromx, tox, fromy, toy, fromz, toz));
+			break;
+		case 1:
+			data->SetText(wxString::Format("{ x = %d, y = %d, z = %d }, { x = %d, y = %d, z = %d }", fromx, fromy, fromz, tox, toy, toz));
+			break;
+		case 2:
+			data->SetText(wxString::Format("Position(%d, %d, %d), Position(%d, %d, %d)", fromx, fromy, fromz, tox, toy, toz));
+			break;
 	}
-	clip << "}";
 
-	wxTheClipboard->SetData(new wxTextDataObject(clip.str()));
+	wxTheClipboard->SetData(data);
 	wxTheClipboard->Close();
 	return true;
 }
 
-wxString b2yn(bool value) {
+wxString b2yn(bool value)
+{
 	return value ? "Yes" : "No";
 }
 
-wxColor colorFromEightBit(int color) {
-	if (color <= 0 || color >= 216) {
+wxColor colorFromEightBit(int color)
+{
+	if(color <= 0 || color >= 216)
 		return wxColor(0, 0, 0);
-	}
 	const uint8_t red = (uint8_t)(int(color / 36) % 6 * 51);
 	const uint8_t green = (uint8_t)(int(color / 6) % 6 * 51);
 	const uint8_t blue = (uint8_t)(color % 6 * 51);
diff --git a/source/common.h b/source/common.h
index b0a1bbf4..1b0474f7 100644
--- a/source/common.h
+++ b/source/common.h
@@ -68,7 +68,7 @@ std::string wstring2string(const std::wstring &widestring);
 // Gets position values from ClipBoard
 bool posFromClipboard(int &x, int &y, int &z);
 bool posToClipboard(int x, int y, int z, int format);
-bool posToClipboard(int fromx, int fromy, int fromz, int tox, int toy, int toz);
+bool posToClipboard(int fromx, int fromy, int fromz, int tox, int toy, int toz, int format);
 
 // Returns 'yes' if the defined value is true or 'no' if it is false.
 wxString b2yn(bool v);
diff --git a/source/common_windows.cpp b/source/common_windows.cpp
index 2f205f5d..a843bef0 100644
--- a/source/common_windows.cpp
+++ b/source/common_windows.cpp
@@ -36,24 +36,25 @@
 #include "iominimap.h"
 
 #ifdef _MSC_VER
-	#pragma warning(disable : 4018) // signed/unsigned mismatch
+	#pragma warning(disable:4018) // signed/unsigned mismatch
 #endif
 
 // ============================================================================
 // Map Properties Window
 
 BEGIN_EVENT_TABLE(MapPropertiesWindow, wxDialog)
-EVT_CHOICE(MAP_PROPERTIES_VERSION, MapPropertiesWindow::OnChangeVersion)
-EVT_BUTTON(wxID_OK, MapPropertiesWindow::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, MapPropertiesWindow::OnClickCancel)
+	EVT_CHOICE(MAP_PROPERTIES_VERSION, MapPropertiesWindow::OnChangeVersion)
+	EVT_BUTTON(wxID_OK, MapPropertiesWindow::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, MapPropertiesWindow::OnClickCancel)
 END_EVENT_TABLE()
 
-MapPropertiesWindow::MapPropertiesWindow(wxWindow* parent, MapTab* view, Editor &editor) :
+MapPropertiesWindow::MapPropertiesWindow(wxWindow* parent, MapTab* view, Editor& editor) :
 	wxDialog(parent, wxID_ANY, "Map Properties", wxDefaultPosition, wxSize(300, 200), wxRESIZE_BORDER | wxCAPTION),
 	view(view),
-	editor(editor) {
+	editor(editor)
+{
 	// Setup data variabels
-	const Map &map = editor.getMap();
+	const Map& map = editor.getMap();
 
 	wxSizer* topsizer = newd wxBoxSizer(wxVERTICAL);
 
@@ -73,7 +74,7 @@ MapPropertiesWindow::MapPropertiesWindow(wxWindow* parent, MapTab* view, Editor
 	version_choice->Append("OTServ 0.6.1");
 	version_choice->Append("OTServ 0.7.0 (revscriptsys)");
 
-	switch (map.getVersion().otbm) {
+	switch(map.getVersion().otbm) {
 		case MAP_OTBM_1:
 			version_choice->SetSelection(0);
 			break;
@@ -105,38 +106,50 @@ MapPropertiesWindow::MapPropertiesWindow(wxWindow* parent, MapTab* view, Editor
 	{
 		wxSizer* subsizer = newd wxBoxSizer(wxHORIZONTAL);
 		subsizer->Add(
-			width_spin = newd wxSpinCtrl(this, wxID_ANY, wxstr(i2s(map.getWidth())), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, rme::MapMinWidth, rme::MapMaxWidth), wxSizerFlags(1).Expand()
-		);
+			width_spin =
+				newd wxSpinCtrl(this, wxID_ANY, wxstr(i2s(map.getWidth())),
+				wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, rme::MapMinWidth, rme::MapMaxWidth), wxSizerFlags(1).Expand()
+			);
 		subsizer->Add(
-			height_spin = newd wxSpinCtrl(this, wxID_ANY, wxstr(i2s(map.getHeight())), wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, rme::MapMinHeight, rme::MapMaxHeight), wxSizerFlags(1).Expand()
-		);
+			height_spin =
+				newd wxSpinCtrl(this, wxID_ANY, wxstr(i2s(map.getHeight())),
+				wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, rme::MapMinHeight, rme::MapMaxHeight), wxSizerFlags(1).Expand()
+			);
 		grid_sizer->Add(subsizer, 1, wxEXPAND);
 	}
 
 	// External files
 	grid_sizer->Add(
 		newd wxStaticText(this, wxID_ANY, "External house file")
-	);
+		);
 
 	grid_sizer->Add(
-		house_filename_ctrl = newd wxTextCtrl(this, wxID_ANY, wxstr(map.getHouseFilename())), 1, wxEXPAND
-	);
+		house_filename_ctrl =
+			newd wxTextCtrl(this, wxID_ANY, wxstr(map.getHouseFilename())), 1, wxEXPAND
+		);
+
+	grid_sizer->Add(
+		zone_filename_ctrl =
+			newd wxTextCtrl(this, wxID_ANY, wxstr(map.getZoneFilename())), 1, wxEXPAND
+		);
 
 	grid_sizer->Add(
 		newd wxStaticText(this, wxID_ANY, "External monster file")
-	);
+		);
 
 	grid_sizer->Add(
-		spawn_filename_ctrl = newd wxTextCtrl(this, wxID_ANY, wxstr(map.getSpawnFilename())), 1, wxEXPAND
-	);
+		spawn_filename_ctrl =
+			newd wxTextCtrl(this, wxID_ANY, wxstr(map.getSpawnFilename())), 1, wxEXPAND
+		);
 
 	grid_sizer->Add(
 		newd wxStaticText(this, wxID_ANY, "External npc file")
-	);
+		);
 
 	grid_sizer->Add(
-		spawn_npc_filename_ctrl = newd wxTextCtrl(this, wxID_ANY, wxstr(map.getSpawnNpcFilename())), 1, wxEXPAND
-	);
+		spawn_npc_filename_ctrl =
+			newd wxTextCtrl(this, wxID_ANY, wxstr(map.getSpawnNpcFilename())), 1, wxEXPAND
+		);
 
 	topsizer->Add(grid_sizer, wxSizerFlags(1).Expand().Border(wxALL, 20));
 
@@ -153,59 +166,63 @@ MapPropertiesWindow::MapPropertiesWindow(wxWindow* parent, MapTab* view, Editor
 	protocol_choice->SetStringSelection(wxstr(current_version->getName()));
 }
 
-void MapPropertiesWindow::UpdateProtocolList() {
+void MapPropertiesWindow::UpdateProtocolList()
+{
 	wxString ver = version_choice->GetStringSelection();
 	wxString client = protocol_choice->GetStringSelection();
 
 	protocol_choice->Clear();
 
 	ClientVersionList versions;
-	if (g_settings.getInteger(Config::USE_OTBM_4_FOR_ALL_MAPS)) {
+	if(g_settings.getInteger(Config::USE_OTBM_4_FOR_ALL_MAPS)) {
 		versions = ClientVersion::getAllVisible();
 	} else {
 		MapVersionID map_version = MAP_OTBM_1;
-		if (ver.Contains("0.5.0")) {
+		if(ver.Contains("0.5.0"))
 			map_version = MAP_OTBM_1;
-		} else if (ver.Contains("0.6.0")) {
+		else if(ver.Contains("0.6.0"))
 			map_version = MAP_OTBM_2;
-		} else if (ver.Contains("0.6.1")) {
+		else if(ver.Contains("0.6.1"))
 			map_version = MAP_OTBM_3;
-		} else if (ver.Contains("0.7.0")) {
+		else if(ver.Contains("0.7.0"))
 			map_version = MAP_OTBM_4;
-		}
 
 		ClientVersionList protocols = ClientVersion::getAllForOTBMVersion(map_version);
-		for (ClientVersionList::const_iterator p = protocols.begin(); p != protocols.end(); ++p) {
+		for(ClientVersionList::const_iterator p = protocols.begin(); p != protocols.end(); ++p)
 			protocol_choice->Append(wxstr((*p)->getName()));
-		}
 	}
 	protocol_choice->SetSelection(0);
 	protocol_choice->SetStringSelection(client);
 }
 
-void MapPropertiesWindow::OnChangeVersion(wxCommandEvent &) {
+void MapPropertiesWindow::OnChangeVersion(wxCommandEvent&)
+{
 	UpdateProtocolList();
 }
 
-struct MapConversionContext {
-	struct MonsterInfo {
+struct MapConversionContext
+{
+	struct MonsterInfo
+	{
 		std::string name;
 		Outfit outfit;
 	};
 	typedef std::map<std::string, MonsterInfo> MonsterMap;
 	MonsterMap monsterType;
 
-	struct NpcInfo {
+	struct NpcInfo
+	{
 		std::string name;
 		Outfit outfit;
 	};
 	typedef std::map<std::string, NpcInfo> NpcMap;
 	NpcMap npcType;
 
-	void operator()(Map &map, Tile* tile, long long done) {
-		if (tile->monster) {
+	void operator()(Map& map, Tile* tile, long long done)
+	{
+		if(tile->monster) {
 			MonsterMap::iterator f = monsterType.find(tile->monster->getName());
-			if (f == monsterType.end()) {
+			if(f == monsterType.end()) {
 				MonsterInfo info = {
 					tile->monster->getName(),
 					tile->monster->getLookType()
@@ -213,9 +230,9 @@ struct MapConversionContext {
 				monsterType[tile->monster->getName()] = info;
 			}
 		}
-		if (tile->npc) {
+		if(tile->npc) {
 			NpcMap::iterator f = npcType.find(tile->npc->getName());
-			if (f == npcType.end()) {
+			if(f == npcType.end()) {
 				NpcInfo info = {
 					tile->npc->getName(),
 					tile->npc->getLookType()
@@ -226,27 +243,29 @@ struct MapConversionContext {
 	}
 };
 
-void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
-	Map &map = editor.getMap();
+void MapPropertiesWindow::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
+	Map& map = editor.getMap();
 	MapVersion old_ver = map.getVersion();
 	MapVersion new_ver;
 
 	wxString ver = version_choice->GetStringSelection();
 
 	new_ver.client = ClientVersion::get(nstr(protocol_choice->GetStringSelection()))->getID();
-	if (ver.Contains("0.5.0")) {
+	if(ver.Contains("0.5.0")) {
 		new_ver.otbm = MAP_OTBM_1;
-	} else if (ver.Contains("0.6.0")) {
+	} else if(ver.Contains("0.6.0")) {
 		new_ver.otbm = MAP_OTBM_2;
-	} else if (ver.Contains("0.6.1")) {
+	} else if(ver.Contains("0.6.1")) {
 		new_ver.otbm = MAP_OTBM_3;
-	} else if (ver.Contains("0.7.0")) {
+	} else if(ver.Contains("0.7.0")) {
 		new_ver.otbm = MAP_OTBM_4;
 	}
 
-	if (new_ver.client != old_ver.client) {
-		if (g_gui.GetOpenMapCount() > 1) {
-			g_gui.PopupDialog(this, "Error", "You can not change editor version with multiple maps open", wxOK);
+	if(new_ver.client != old_ver.client) {
+		if(g_gui.GetOpenMapCount() > 1) {
+			g_gui.PopupDialog(this, "Error",
+				"You can not change editor version with multiple maps open", wxOK);
 			return;
 		}
 		wxString error;
@@ -256,9 +275,10 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 		g_gui.GetCurrentEditor()->getSelection().clear();
 		g_gui.GetCurrentEditor()->clearActions();
 
-		if (new_ver.client < old_ver.client) {
-			int ret = g_gui.PopupDialog(this, "Notice", "Converting to a previous version may have serious side-effects, are you sure you want to do this?", wxYES | wxNO);
-			if (ret != wxID_YES) {
+		if(new_ver.client < old_ver.client) {
+			int ret = g_gui.PopupDialog(this, "Notice",
+				"Converting to a previous version may have serious side-effects, are you sure you want to do this?", wxYES | wxNO);
+			if(ret != wxID_YES) {
 				return;
 			}
 			UnnamedRenderingLock();
@@ -271,7 +291,7 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 			map.convert(new_ver, true);
 
 			// Load the new version
-			if (!g_gui.LoadVersion(new_ver.client, error, warnings)) {
+			if(!g_gui.LoadVersion(new_ver.client, error, warnings)) {
 				g_gui.ListDialog(this, "Warnings", warnings);
 				g_gui.PopupDialog(this, "Map Loader Error", error, wxOK);
 				g_gui.PopupDialog(this, "Conversion Error", "Could not convert map. The map will now be closed.", wxOK);
@@ -282,18 +302,17 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 
 			// Monsters
 			// Remove all monsters that were present are present in the new version
-			for (MapConversionContext::MonsterMap::iterator cs = conversion_context.monsterType.begin(); cs != conversion_context.monsterType.end();) {
-				if (g_monsters[cs->first]) {
+			for(MapConversionContext::MonsterMap::iterator cs = conversion_context.monsterType.begin(); cs != conversion_context.monsterType.end();) {
+				if(g_monsters[cs->first])
 					cs = conversion_context.monsterType.erase(cs);
-				} else {
+				else
 					++cs;
-				}
 			}
 
-			if (conversion_context.monsterType.size() > 0) {
+			if(conversion_context.monsterType.size() > 0) {
 				int add = g_gui.PopupDialog(this, "Unrecognized monsters", "There were monsters on the old version that are not present in this and were on the map, do you want to add them to this version as well?", wxYES | wxNO);
-				if (add == wxID_YES) {
-					for (MapConversionContext::MonsterMap::iterator cs = conversion_context.monsterType.begin(); cs != conversion_context.monsterType.end(); ++cs) {
+				if(add == wxID_YES) {
+					for(MapConversionContext::MonsterMap::iterator cs = conversion_context.monsterType.begin(); cs != conversion_context.monsterType.end(); ++cs) {
 						MapConversionContext::MonsterInfo info = cs->second;
 						g_monsters.addMonsterType(info.name, info.outfit);
 					}
@@ -302,18 +321,17 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 
 			// Npcs
 			// Remove all npcs that were present are present in the new version
-			for (MapConversionContext::NpcMap::iterator cs = conversion_context.npcType.begin(); cs != conversion_context.npcType.end();) {
-				if (g_npcs[cs->first]) {
+			for(MapConversionContext::NpcMap::iterator cs = conversion_context.npcType.begin(); cs != conversion_context.npcType.end();) {
+				if(g_npcs[cs->first])
 					cs = conversion_context.npcType.erase(cs);
-				} else {
+				else
 					++cs;
-				}
 			}
 
-			if (conversion_context.npcType.size() > 0) {
+			if(conversion_context.npcType.size() > 0) {
 				int add = g_gui.PopupDialog(this, "Unrecognized npcs", "There were npcs on the old version that are not present in this and were on the map, do you want to add them to this version as well?", wxYES | wxNO);
-				if (add == wxID_YES) {
-					for (MapConversionContext::NpcMap::iterator cs = conversion_context.npcType.begin(); cs != conversion_context.npcType.end(); ++cs) {
+				if(add == wxID_YES) {
+					for(MapConversionContext::NpcMap::iterator cs = conversion_context.npcType.begin(); cs != conversion_context.npcType.end(); ++cs) {
 						MapConversionContext::NpcInfo info = cs->second;
 						g_npcs.addNpcType(info.name, info.outfit);
 					}
@@ -321,9 +339,9 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 			}
 
 			map.cleanInvalidTiles(true);
-		} else {
+		} else  {
 			UnnamedRenderingLock();
-			if (!g_gui.LoadVersion(new_ver.client, error, warnings)) {
+			if(!g_gui.LoadVersion(new_ver.client, error, warnings)) {
 				g_gui.ListDialog(this, "Warnings", warnings);
 				g_gui.PopupDialog(this, "Map Loader Error", error, wxOK);
 				g_gui.PopupDialog(this, "Conversion Error", "Could not convert map. The map will now be closed.", wxOK);
@@ -341,11 +359,12 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 	map.setHouseFilename(nstr(house_filename_ctrl->GetValue()));
 	map.setSpawnMonsterFilename(nstr(spawn_filename_ctrl->GetValue()));
 	map.setSpawnNpcFilename(nstr(spawn_npc_filename_ctrl->GetValue()));
+	map.setZoneFilename(nstr(zone_filename_ctrl->GetValue()));
 
 	// Only resize if we have to
 	int new_map_width = width_spin->GetValue();
 	int new_map_height = height_spin->GetValue();
-	if (new_map_width != map.getWidth() || new_map_height != map.getHeight()) {
+	if(new_map_width != map.getWidth() || new_map_height != map.getHeight()) {
 		map.setWidth(new_map_width);
 		map.setHeight(new_map_height);
 		g_gui.FitViewToMap(view);
@@ -355,7 +374,8 @@ void MapPropertiesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 	EndModal(1);
 }
 
-void MapPropertiesWindow::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void MapPropertiesWindow::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	// Just close this window
 	EndModal(1);
 }
@@ -366,14 +386,15 @@ MapPropertiesWindow::~MapPropertiesWindow() = default;
 // Map Import Window
 
 BEGIN_EVENT_TABLE(ImportMapWindow, wxDialog)
-EVT_BUTTON(MAP_WINDOW_FILE_BUTTON, ImportMapWindow::OnClickBrowse)
-EVT_BUTTON(wxID_OK, ImportMapWindow::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, ImportMapWindow::OnClickCancel)
+	EVT_BUTTON(MAP_WINDOW_FILE_BUTTON, ImportMapWindow::OnClickBrowse)
+	EVT_BUTTON(wxID_OK, ImportMapWindow::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, ImportMapWindow::OnClickCancel)
 END_EVENT_TABLE()
 
-ImportMapWindow::ImportMapWindow(wxWindow* parent, Editor &editor) :
+ImportMapWindow::ImportMapWindow(wxWindow* parent, Editor& editor) :
 	wxDialog(parent, wxID_ANY, "Import Map", wxDefaultPosition, wxSize(420, 350)),
-	editor(editor) {
+	editor(editor)
+{
 	wxBoxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 	wxStaticBoxSizer* tmpsizer;
 
@@ -444,19 +465,20 @@ ImportMapWindow::ImportMapWindow(wxWindow* parent, Editor &editor) :
 
 ImportMapWindow::~ImportMapWindow() = default;
 
-void ImportMapWindow::OnClickBrowse(wxCommandEvent &WXUNUSED(event)) {
+void ImportMapWindow::OnClickBrowse(wxCommandEvent& WXUNUSED(event))
+{
 	wxFileDialog dialog(this, "Import...", "", "", "*.otbm", wxFD_OPEN | wxFD_FILE_MUST_EXIST);
 	int ok = dialog.ShowModal();
 
-	if (ok == wxID_OK) {
+	if (ok == wxID_OK)
 		file_text_field->ChangeValue(dialog.GetPath());
-	}
 }
 
-void ImportMapWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
-	if (Validate() && TransferDataFromWindow()) {
+void ImportMapWindow::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
+	if(Validate() && TransferDataFromWindow()) {
 		wxFileName fn = file_text_field->GetValue();
-		if (!fn.FileExists()) {
+		if(!fn.FileExists()) {
 			g_gui.PopupDialog(this, "Error", "The specified map file doesn't exist", wxOK);
 			return;
 		}
@@ -465,37 +487,21 @@ void ImportMapWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 		ImportType spawn_npc_import_type = IMPORT_DONT;
 		ImportType house_import_type = IMPORT_DONT;
 
-		switch (spawn_monster_options->GetSelection()) {
-			case 0:
-				spawn_import_type = IMPORT_MERGE;
-				break;
-			case 1:
-				spawn_import_type = IMPORT_DONT;
-				break;
+		switch(spawn_monster_options->GetSelection()) {
+			case 0: spawn_import_type = IMPORT_MERGE; break;
+			case 1: spawn_import_type = IMPORT_DONT; break;
 		}
 
-		switch (spawn_npc_options->GetSelection()) {
-			case 0:
-				spawn_npc_import_type = IMPORT_MERGE;
-				break;
-			case 1:
-				spawn_npc_import_type = IMPORT_DONT;
-				break;
+		switch(spawn_npc_options->GetSelection()) {
+			case 0: spawn_npc_import_type = IMPORT_MERGE; break;
+			case 1: spawn_npc_import_type = IMPORT_DONT; break;
 		}
 
-		switch (house_options->GetSelection()) {
-			case 0:
-				house_import_type = IMPORT_SMART_MERGE;
-				break;
-			case 1:
-				house_import_type = IMPORT_MERGE;
-				break;
-			case 2:
-				house_import_type = IMPORT_INSERT;
-				break;
-			case 3:
-				house_import_type = IMPORT_DONT;
-				break;
+		switch(house_options->GetSelection()) {
+			case 0: house_import_type = IMPORT_SMART_MERGE; break;
+			case 1: house_import_type = IMPORT_MERGE; break;
+			case 2: house_import_type = IMPORT_INSERT; break;
+			case 3: house_import_type = IMPORT_DONT; break;
 		}
 
 		EndModal(1);
@@ -504,24 +510,27 @@ void ImportMapWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 	}
 }
 
-void ImportMapWindow::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void ImportMapWindow::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	// Just close this window
 	EndModal(0);
 }
 
+
 // ============================================================================
 // Export Minimap window
 
 BEGIN_EVENT_TABLE(ExportMiniMapWindow, wxDialog)
-EVT_BUTTON(MAP_WINDOW_FILE_BUTTON, ExportMiniMapWindow::OnClickBrowse)
-EVT_BUTTON(wxID_OK, ExportMiniMapWindow::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, ExportMiniMapWindow::OnClickCancel)
-EVT_CHOICE(wxID_ANY, ExportMiniMapWindow::OnExportTypeChange)
+	EVT_BUTTON(MAP_WINDOW_FILE_BUTTON, ExportMiniMapWindow::OnClickBrowse)
+	EVT_BUTTON(wxID_OK, ExportMiniMapWindow::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, ExportMiniMapWindow::OnClickCancel)
+	EVT_CHOICE(wxID_ANY, ExportMiniMapWindow::OnExportTypeChange)
 END_EVENT_TABLE()
 
-ExportMiniMapWindow::ExportMiniMapWindow(wxWindow* parent, Editor &editor) :
+ExportMiniMapWindow::ExportMiniMapWindow(wxWindow* parent, Editor& editor) :
 	wxDialog(parent, wxID_ANY, "Export Minimap", wxDefaultPosition, wxSize(400, 300)),
-	editor(editor) {
+	editor(editor)
+{
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 	wxSizer* tmpsizer;
 
@@ -564,9 +573,8 @@ ExportMiniMapWindow::ExportMiniMapWindow(wxWindow* parent, Editor &editor) :
 	choices.Add("Ground Floor");
 	choices.Add("Specific Floor");
 
-	if (editor.hasSelection()) {
+	if (editor.hasSelection())
 		choices.Add("Selected Area");
-	}
 
 	// Area options
 	tmpsizer = newd wxStaticBoxSizer(wxHORIZONTAL, this, "Area Options");
@@ -592,30 +600,35 @@ ExportMiniMapWindow::ExportMiniMapWindow(wxWindow* parent, Editor &editor) :
 
 ExportMiniMapWindow::~ExportMiniMapWindow() = default;
 
-void ExportMiniMapWindow::OnExportTypeChange(wxCommandEvent &event) {
+void ExportMiniMapWindow::OnExportTypeChange(wxCommandEvent& event)
+{
 	floor_number->Enable(event.GetSelection() == 2);
 }
 
-void ExportMiniMapWindow::OnClickBrowse(wxCommandEvent &WXUNUSED(event)) {
+void ExportMiniMapWindow::OnClickBrowse(wxCommandEvent& WXUNUSED(event))
+{
 	wxDirDialog dialog(NULL, "Select the output folder", "", wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST);
-	if (dialog.ShowModal() == wxID_OK) {
-		const wxString &directory = dialog.GetPath();
+	if(dialog.ShowModal() == wxID_OK) {
+		const wxString& directory = dialog.GetPath();
 		directory_text_field->ChangeValue(directory);
 	}
 	CheckValues();
 }
 
-void ExportMiniMapWindow::OnDirectoryChanged(wxKeyEvent &event) {
+void ExportMiniMapWindow::OnDirectoryChanged(wxKeyEvent& event)
+{
 	CheckValues();
 	event.Skip();
 }
 
-void ExportMiniMapWindow::OnFileNameChanged(wxKeyEvent &event) {
+void ExportMiniMapWindow::OnFileNameChanged(wxKeyEvent& event)
+{
 	CheckValues();
 	event.Skip();
 }
 
-void ExportMiniMapWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
+void ExportMiniMapWindow::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
 	g_gui.CreateLoadBar("Exporting minimap...");
 
 	auto format = static_cast<MinimapExportFormat>(format_options->GetSelection());
@@ -635,13 +648,15 @@ void ExportMiniMapWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 	EndModal(wxID_OK);
 }
 
-void ExportMiniMapWindow::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void ExportMiniMapWindow::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	// Just close this window
 	EndModal(wxID_CANCEL);
 }
 
-void ExportMiniMapWindow::CheckValues() {
-	if (directory_text_field->IsEmpty()) {
+void ExportMiniMapWindow::CheckValues()
+{
+	if(directory_text_field->IsEmpty()) {
 		error_field->SetLabel("Type or select an output folder.");
 		ok_button->Enable(false);
 		return;
@@ -675,11 +690,13 @@ void ExportMiniMapWindow::CheckValues() {
 // Numkey forwarding text control
 
 BEGIN_EVENT_TABLE(KeyForwardingTextCtrl, wxTextCtrl)
-EVT_KEY_DOWN(KeyForwardingTextCtrl::OnKeyDown)
+	EVT_KEY_DOWN(KeyForwardingTextCtrl::OnKeyDown)
 END_EVENT_TABLE()
 
-void KeyForwardingTextCtrl::OnKeyDown(wxKeyEvent &event) {
-	if (event.GetKeyCode() == WXK_UP || event.GetKeyCode() == WXK_DOWN || event.GetKeyCode() == WXK_PAGEDOWN || event.GetKeyCode() == WXK_PAGEUP) {
+void KeyForwardingTextCtrl::OnKeyDown(wxKeyEvent& event)
+{
+	if(event.GetKeyCode() == WXK_UP || event.GetKeyCode() == WXK_DOWN ||
+		event.GetKeyCode() == WXK_PAGEDOWN || event.GetKeyCode() == WXK_PAGEUP) {
 		GetParent()->GetEventHandler()->AddPendingEvent(event);
 	} else {
 		event.Skip();
@@ -690,20 +707,21 @@ void KeyForwardingTextCtrl::OnKeyDown(wxKeyEvent &event) {
 // Find Item Dialog (Jump to item)
 
 BEGIN_EVENT_TABLE(FindDialog, wxDialog)
-EVT_TIMER(wxID_ANY, FindDialog::OnTextIdle)
-EVT_TEXT(JUMP_DIALOG_TEXT, FindDialog::OnTextChange)
-EVT_KEY_DOWN(FindDialog::OnKeyDown)
-EVT_TEXT_ENTER(JUMP_DIALOG_TEXT, FindDialog::OnClickOK)
-EVT_LISTBOX_DCLICK(JUMP_DIALOG_LIST, FindDialog::OnClickList)
-EVT_BUTTON(wxID_OK, FindDialog::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, FindDialog::OnClickCancel)
+	EVT_TIMER(wxID_ANY, FindDialog::OnTextIdle)
+	EVT_TEXT(JUMP_DIALOG_TEXT, FindDialog::OnTextChange)
+	EVT_KEY_DOWN(FindDialog::OnKeyDown)
+	EVT_TEXT_ENTER(JUMP_DIALOG_TEXT, FindDialog::OnClickOK)
+	EVT_LISTBOX_DCLICK(JUMP_DIALOG_LIST, FindDialog::OnClickList)
+	EVT_BUTTON(wxID_OK, FindDialog::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, FindDialog::OnClickCancel)
 END_EVENT_TABLE()
 
 FindDialog::FindDialog(wxWindow* parent, wxString title) :
 	wxDialog(g_gui.root, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, wxRESIZE_BORDER | wxCAPTION | wxCLOSE_BOX),
 	idle_input_timer(this),
 	result_brush(nullptr),
-	result_id(0) {
+	result_id(0)
+{
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 
 	search_field = newd KeyForwardingTextCtrl(this, JUMP_DIALOG_TEXT, "", wxDefaultPosition, wxDefaultSize, wxTE_PROCESS_ENTER);
@@ -727,25 +745,25 @@ FindDialog::FindDialog(wxWindow* parent, wxString title) :
 
 FindDialog::~FindDialog() = default;
 
-void FindDialog::OnKeyDown(wxKeyEvent &event) {
+void FindDialog::OnKeyDown(wxKeyEvent& event)
+{
 	int w, h;
 	item_list->GetSize(&w, &h);
 	size_t amount = 1;
 
-	switch (event.GetKeyCode()) {
+	switch(event.GetKeyCode()) {
 		case WXK_PAGEUP:
 			amount = h / 32 + 1;
 			[[fallthrough]];
 		case WXK_UP: {
-			if (item_list->GetItemCount() > 0) {
+			if(item_list->GetItemCount() > 0) {
 				ssize_t n = item_list->GetSelection();
-				if (n == wxNOT_FOUND) {
+				if(n == wxNOT_FOUND)
 					n = 0;
-				} else if (n != amount && n - amount < n) { // latter is needed for unsigned overflow
+				else if(n != amount && n - amount < n) // latter is needed for unsigned overflow
 					n -= amount;
-				} else {
+				else
 					n = 0;
-				}
 				item_list->SetSelection(n);
 			}
 			break;
@@ -755,16 +773,15 @@ void FindDialog::OnKeyDown(wxKeyEvent &event) {
 			amount = h / 32 + 1;
 			[[fallthrough]];
 		case WXK_DOWN: {
-			if (item_list->GetItemCount() > 0) {
+			if(item_list->GetItemCount() > 0) {
 				ssize_t n = item_list->GetSelection();
 				size_t itemcount = item_list->GetItemCount();
-				if (n == wxNOT_FOUND) {
+				if(n == wxNOT_FOUND)
 					n = 0;
-				} else if (static_cast<uint32_t>(n) < itemcount - amount && itemcount - amount < itemcount) {
+				else if(static_cast<uint32_t>(n) < itemcount - amount && itemcount - amount < itemcount)
 					n += amount;
-				} else {
+				else
 					n = item_list->GetItemCount() - 1;
-				}
 
 				item_list->SetSelection(n);
 			}
@@ -776,28 +793,34 @@ void FindDialog::OnKeyDown(wxKeyEvent &event) {
 	}
 }
 
-void FindDialog::OnTextIdle(wxTimerEvent &WXUNUSED(event)) {
+void FindDialog::OnTextIdle(wxTimerEvent& WXUNUSED(event))
+{
 	RefreshContents();
 }
 
-void FindDialog::OnTextChange(wxCommandEvent &WXUNUSED(event)) {
+void FindDialog::OnTextChange(wxCommandEvent& WXUNUSED(event))
+{
 	idle_input_timer.Start(800, true);
 }
 
-void FindDialog::OnClickList(wxCommandEvent &event) {
+void FindDialog::OnClickList(wxCommandEvent& event)
+{
 	OnClickListInternal(event);
 }
 
-void FindDialog::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
+void FindDialog::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
 	// This is to get virtual callback
 	OnClickOKInternal();
 }
 
-void FindDialog::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void FindDialog::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	EndModal(0);
 }
 
-void FindDialog::RefreshContents() {
+void FindDialog::RefreshContents()
+{
 	// This is to get virtual callback
 	RefreshContentsInternal();
 }
@@ -805,46 +828,46 @@ void FindDialog::RefreshContents() {
 // ============================================================================
 // Find Brush Dialog (Jump to brush)
 
-FindBrushDialog::FindBrushDialog(wxWindow* parent, wxString title) :
-	FindDialog(parent, title) {
+FindBrushDialog::FindBrushDialog(wxWindow* parent, wxString title) : FindDialog(parent, title)
+{
 	RefreshContents();
 }
 
 FindBrushDialog::~FindBrushDialog() = default;
 
-void FindBrushDialog::OnClickListInternal(wxCommandEvent &event) {
+void FindBrushDialog::OnClickListInternal(wxCommandEvent& event)
+{
 	Brush* brush = item_list->GetSelectedBrush();
-	if (brush) {
+	if(brush) {
 		result_brush = brush;
 		EndModal(1);
 	}
 }
 
-void FindBrushDialog::OnClickOKInternal() {
+void FindBrushDialog::OnClickOKInternal()
+{
 	// This is kind of stupid as it would fail unless the "Please enter a search string" wasn't there
-	if (item_list->GetItemCount() > 0) {
-		if (item_list->GetSelection() == wxNOT_FOUND) {
+	if(item_list->GetItemCount() > 0) {
+		if(item_list->GetSelection() == wxNOT_FOUND) {
 			item_list->SetSelection(0);
 		}
 		Brush* brush = item_list->GetSelectedBrush();
-		if (!brush) {
+		if(!brush) {
 			// It's either "Please enter a search string" or "No matches"
 			// Perhaps we can refresh now?
 			std::string search_string = as_lower_str(nstr(search_field->GetValue()));
 			bool do_search = (search_string.size() >= 2);
 
-			if (do_search) {
-				const BrushMap &map = g_brushes.getMap();
-				for (BrushMap::const_iterator iter = map.begin(); iter != map.end(); ++iter) {
+			if(do_search) {
+				const BrushMap& map = g_brushes.getMap();
+				for(BrushMap::const_iterator iter = map.begin(); iter != map.end(); ++iter) {
 					const Brush* brush = iter->second;
-					if (as_lower_str(brush->getName()).find(search_string) == std::string::npos) {
+					if(as_lower_str(brush->getName()).find(search_string) == std::string::npos)
 						continue;
-					}
 
 					// Don't match RAWs now.
-					if (brush->isRaw()) {
+					if(brush->isRaw())
 						continue;
-					}
 
 					// Found one!
 					result_brush = brush;
@@ -852,22 +875,19 @@ void FindBrushDialog::OnClickOKInternal() {
 				}
 
 				// Did we not find a matching brush?
-				if (!result_brush) {
+				if(!result_brush) {
 					// Then let's search the RAWs
-					for (int id = 0; id <= g_items.getMaxID(); ++id) {
-						const ItemType &type = g_items.getItemType(id);
-						if (type.id == 0) {
+					for(int id = 0; id <= g_items.getMaxID(); ++id) {
+						const ItemType& type = g_items.getItemType(id);
+						if(type.id == 0)
 							continue;
-						}
 
 						RAWBrush* raw_brush = type.raw_brush;
-						if (!raw_brush) {
+						if(!raw_brush)
 							continue;
-						}
 
-						if (as_lower_str(raw_brush->getName()).find(search_string) == std::string::npos) {
+						if(as_lower_str(raw_brush->getName()).find(search_string) == std::string::npos)
 							continue;
-						}
 
 						// Found one!
 						result_brush = raw_brush;
@@ -883,65 +903,62 @@ void FindBrushDialog::OnClickOKInternal() {
 	EndModal(1);
 }
 
-void FindBrushDialog::RefreshContentsInternal() {
+void FindBrushDialog::RefreshContentsInternal()
+{
 	item_list->Clear();
 
 	std::string search_string = as_lower_str(nstr(search_field->GetValue()));
 	bool do_search = (search_string.size() >= 2);
 
-	if (do_search) {
+	if(do_search) {
 
 		bool found_search_results = false;
 
-		const BrushMap &brushes_map = g_brushes.getMap();
+		const BrushMap& brushes_map = g_brushes.getMap();
 
 		// We store the raws so they display last of all results
 		std::deque<const RAWBrush*> raws;
 
-		for (BrushMap::const_iterator iter = brushes_map.begin(); iter != brushes_map.end(); ++iter) {
+		for(BrushMap::const_iterator iter = brushes_map.begin(); iter != brushes_map.end(); ++iter) {
 			const Brush* brush = iter->second;
 
-			if (as_lower_str(brush->getName()).find(search_string) == std::string::npos) {
+			if(as_lower_str(brush->getName()).find(search_string) == std::string::npos)
 				continue;
-			}
 
-			if (brush->isRaw()) {
+			if(brush->isRaw())
 				continue;
-			}
 
 			found_search_results = true;
 			item_list->AddBrush(const_cast<Brush*>(brush));
 		}
 
-		for (int id = 0; id <= g_items.getMaxID(); ++id) {
-			const ItemType &type = g_items.getItemType(id);
-			if (type.id == 0) {
+		for(int id = 0; id <= g_items.getMaxID(); ++id) {
+			const ItemType& type = g_items.getItemType(id);
+			if(type.id == 0)
 				continue;
-			}
 
 			RAWBrush* raw_brush = type.raw_brush;
-			if (!raw_brush) {
+			if(!raw_brush)
 				continue;
-			}
 
-			if (as_lower_str(raw_brush->getName()).find(search_string) == std::string::npos) {
+			if(as_lower_str(raw_brush->getName()).find(search_string) == std::string::npos)
 				continue;
-			}
 
 			found_search_results = true;
 			item_list->AddBrush(raw_brush);
 		}
 
-		while (raws.size() > 0) {
+		while(raws.size() > 0) {
 			item_list->AddBrush(const_cast<RAWBrush*>(raws.front()));
 			raws.pop_front();
 		}
 
-		if (found_search_results) {
+		if(found_search_results) {
 			item_list->SetSelection(0);
 		} else {
 			item_list->SetNoMatches();
 		}
+
 	}
 	item_list->Refresh();
 }
@@ -952,32 +969,36 @@ void FindBrushDialog::RefreshContentsInternal() {
 FindDialogListBox::FindDialogListBox(wxWindow* parent, wxWindowID id) :
 	wxVListBox(parent, id, wxDefaultPosition, wxDefaultSize, wxLB_SINGLE),
 	cleared(false),
-	no_matches(false) {
+	no_matches(false)
+{
 	Clear();
 }
 
-FindDialogListBox::~FindDialogListBox() {
+FindDialogListBox::~FindDialogListBox()
+{
 	////
 }
 
-void FindDialogListBox::Clear() {
+void FindDialogListBox::Clear()
+{
 	cleared = true;
 	no_matches = false;
 	brushlist.clear();
 	SetItemCount(1);
 }
 
-void FindDialogListBox::SetNoMatches() {
+void FindDialogListBox::SetNoMatches()
+{
 	cleared = false;
 	no_matches = true;
 	brushlist.clear();
 	SetItemCount(1);
 }
 
-void FindDialogListBox::AddBrush(Brush* brush) {
-	if (cleared || no_matches) {
+void FindDialogListBox::AddBrush(Brush* brush)
+{
+	if(cleared || no_matches)
 		SetItemCount(0);
-	}
 
 	cleared = false;
 	no_matches = false;
@@ -986,32 +1007,32 @@ void FindDialogListBox::AddBrush(Brush* brush) {
 	brushlist.push_back(brush);
 }
 
-Brush* FindDialogListBox::GetSelectedBrush() {
+Brush* FindDialogListBox::GetSelectedBrush()
+{
 	ssize_t n = GetSelection();
-	if (n == wxNOT_FOUND || no_matches || cleared) {
+	if(n == wxNOT_FOUND || no_matches || cleared)
 		return nullptr;
-	}
 	return brushlist[n];
 }
 
-void FindDialogListBox::OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const {
-	if (no_matches) {
+void FindDialogListBox::OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const
+{
+	if(no_matches) {
 		dc.DrawText("No matches for your search.", rect.GetX() + 40, rect.GetY() + 6);
-	} else if (cleared) {
+	} else if(cleared) {
 		dc.DrawText("Please enter your search string.", rect.GetX() + 40, rect.GetY() + 6);
 	} else {
 		ASSERT(n < brushlist.size());
 		Sprite* spr = g_gui.gfx.getSprite(brushlist[n]->getLookID());
-		if (spr) {
+		if(spr) {
 			spr->DrawTo(&dc, SPRITE_SIZE_32x32, rect.GetX(), rect.GetY(), rect.GetWidth(), rect.GetHeight());
 		}
 
-		if (IsSelected(n)) {
-			if (HasFocus()) {
+		if(IsSelected(n)) {
+			if(HasFocus())
 				dc.SetTextForeground(wxColor(0xFF, 0xFF, 0xFF));
-			} else {
+			else
 				dc.SetTextForeground(wxColor(0x00, 0x00, 0xFF));
-			}
 		} else {
 			dc.SetTextForeground(wxColor(0x00, 0x00, 0x00));
 		}
@@ -1020,23 +1041,23 @@ void FindDialogListBox::OnDrawItem(wxDC &dc, const wxRect &rect, size_t n) const
 	}
 }
 
-wxCoord FindDialogListBox::OnMeasureItem(size_t n) const {
+wxCoord FindDialogListBox::OnMeasureItem(size_t n) const
+{
 	return 32;
 }
 
 // ============================================================================
 // wxListBox that can be sorted
 
-SortableListBox::SortableListBox(wxWindow* parent, wxWindowID id, const wxPoint &pos, const wxSize &size) :
-	wxListBox(parent, id, pos, size, 0, nullptr, wxLB_SINGLE | wxLB_NEEDED_SB) { }
+SortableListBox::SortableListBox(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size)
+: wxCheckListBox(parent, id, pos, size, 0, nullptr, wxLB_SINGLE | wxLB_NEEDED_SB)
+{}
 
-SortableListBox::~SortableListBox() { }
+SortableListBox::~SortableListBox() {}
 
 void SortableListBox::Sort() {
-
-	if (GetCount() == 0) {
+	if (GetCount() == 0)
 		return;
-	}
 
 	wxASSERT_MSG(GetClientDataType() != wxClientData_Object, "Sorting a list with data of type wxClientData_Object is currently not implemented");
 
@@ -1053,12 +1074,11 @@ void SortableListBox::DoSort() {
 
 	for (size_t i = 0; i < count; ++i) {
 		stringList.Add(GetString(i));
-		if (dataType == wxClientData_Void) {
+		if (dataType == wxClientData_Void)
 			dataList.Add(GetClientData(i));
-		}
 	}
 
-	// Insertion sort
+	//Insertion sort
 	for (size_t i = 0; i < count; ++i) {
 		size_t j = i;
 		while (j > 0 && stringList[j].CmpNoCase(stringList[j - 1]) < 0) {
@@ -1073,9 +1093,9 @@ void SortableListBox::DoSort() {
 				dataList[j - 1] = tmpData;
 			}
 
-			if (selection == j - 1) {
+			if (selection == j - 1)
 				selection++;
-			} else if (selection == j) {
+			else if (selection == j) {
 				selection--;
 			}
 
@@ -1086,11 +1106,10 @@ void SortableListBox::DoSort() {
 	Freeze();
 	Clear();
 	for (size_t i = 0; i < count; ++i) {
-		if (dataType == wxClientData_Void) {
+		if (dataType == wxClientData_Void)
 			Append(stringList[i], dataList[i]);
-		} else {
+		else
 			Append(stringList[i]);
-		}
 	}
 	Thaw();
 
@@ -1101,66 +1120,77 @@ void SortableListBox::DoSort() {
 // Object properties base
 
 ObjectPropertiesWindowBase::ObjectPropertiesWindowBase(wxWindow* parent, wxString title, const Map* map, const Tile* tile, Item* item, wxPoint position /* = wxDefaultPosition */) :
-	wxDialog(parent, wxID_ANY, title, position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
+wxDialog(parent, wxID_ANY, title,
+	position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
 	edit_map(map),
 	edit_tile(tile),
 	edit_item(item),
 	edit_monster(nullptr),
 	edit_spawn_monster(nullptr),
 	edit_npc(nullptr),
-	edit_spawn_npc(nullptr) {
+	edit_spawn_npc(nullptr)
+{
 	////
 }
 
 ObjectPropertiesWindowBase::ObjectPropertiesWindowBase(wxWindow* parent, wxString title, const Map* map, const Tile* tile, Monster* monster, wxPoint position /* = wxDefaultPosition */) :
-	wxDialog(parent, wxID_ANY, title, position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
+wxDialog(parent, wxID_ANY, title,
+	position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
 	edit_map(map),
 	edit_tile(tile),
 	edit_item(nullptr),
 	edit_monster(monster),
 	edit_spawn_monster(nullptr),
 	edit_npc(nullptr),
-	edit_spawn_npc(nullptr) {
+	edit_spawn_npc(nullptr)
+{
 	////
 }
 
 ObjectPropertiesWindowBase::ObjectPropertiesWindowBase(wxWindow* parent, wxString title, const Map* map, const Tile* tile, SpawnMonster* spawnMonster, wxPoint position /* = wxDefaultPosition */) :
-	wxDialog(parent, wxID_ANY, title, position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
+wxDialog(parent, wxID_ANY, title,
+	position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
 	edit_map(map),
 	edit_tile(tile),
 	edit_item(nullptr),
 	edit_monster(nullptr),
 	edit_spawn_monster(spawnMonster),
 	edit_npc(nullptr),
-	edit_spawn_npc(nullptr) {
+	edit_spawn_npc(nullptr)
+{
 	////
 }
 
 ObjectPropertiesWindowBase::ObjectPropertiesWindowBase(wxWindow* parent, wxString title, const Map* map, const Tile* tile, Npc* npc, wxPoint position /* = wxDefaultPosition */) :
-	wxDialog(parent, wxID_ANY, title, position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
+wxDialog(parent, wxID_ANY, title,
+	position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
 	edit_map(map),
 	edit_tile(tile),
 	edit_item(nullptr),
 	edit_monster(nullptr),
 	edit_spawn_monster(nullptr),
 	edit_npc(npc),
-	edit_spawn_npc(nullptr) {
+	edit_spawn_npc(nullptr)
+{
 	////
 }
 
 ObjectPropertiesWindowBase::ObjectPropertiesWindowBase(wxWindow* parent, wxString title, const Map* map, const Tile* tile, SpawnNpc* spawnNpc, wxPoint position /* = wxDefaultPosition */) :
-	wxDialog(parent, wxID_ANY, title, position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
+wxDialog(parent, wxID_ANY, title,
+	position, wxSize(600, 400), wxCAPTION | wxCLOSE_BOX | wxRESIZE_BORDER),
 	edit_map(map),
 	edit_tile(tile),
 	edit_item(nullptr),
 	edit_monster(nullptr),
 	edit_spawn_monster(nullptr),
 	edit_npc(nullptr),
-	edit_spawn_npc(spawnNpc) {
+	edit_spawn_npc(spawnNpc)
+{
 	////
 }
 
-Item* ObjectPropertiesWindowBase::getItemBeingEdited() {
+Item* ObjectPropertiesWindowBase::getItemBeingEdited()
+{
 	return edit_item;
 }
 
@@ -1168,28 +1198,29 @@ Item* ObjectPropertiesWindowBase::getItemBeingEdited() {
 // Edit Towns Dialog
 
 BEGIN_EVENT_TABLE(EditTownsDialog, wxDialog)
-EVT_LISTBOX(EDIT_TOWNS_LISTBOX, EditTownsDialog::OnListBoxChange)
+	EVT_LISTBOX(EDIT_TOWNS_LISTBOX, EditTownsDialog::OnListBoxChange)
 
-EVT_BUTTON(EDIT_TOWNS_SELECT_TEMPLE, EditTownsDialog::OnClickSelectTemplePosition)
-EVT_BUTTON(EDIT_TOWNS_ADD, EditTownsDialog::OnClickAdd)
-EVT_BUTTON(EDIT_TOWNS_REMOVE, EditTownsDialog::OnClickRemove)
-EVT_BUTTON(wxID_OK, EditTownsDialog::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, EditTownsDialog::OnClickCancel)
+	EVT_BUTTON(EDIT_TOWNS_SELECT_TEMPLE, EditTownsDialog::OnClickSelectTemplePosition)
+	EVT_BUTTON(EDIT_TOWNS_ADD, EditTownsDialog::OnClickAdd)
+	EVT_BUTTON(EDIT_TOWNS_REMOVE, EditTownsDialog::OnClickRemove)
+	EVT_BUTTON(wxID_OK, EditTownsDialog::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, EditTownsDialog::OnClickCancel)
 END_EVENT_TABLE()
 
-EditTownsDialog::EditTownsDialog(wxWindow* parent, Editor &editor) :
-	wxDialog(parent, wxID_ANY, "Towns", wxDefaultPosition, wxSize(280, 330)),
-	editor(editor) {
-	const Map &map = editor.getMap();
+EditTownsDialog::EditTownsDialog(wxWindow* parent, Editor& editor) :
+	wxDialog(parent, wxID_ANY, "Towns", wxDefaultPosition, wxSize(280,330)),
+	editor(editor)
+{
+	const Map& map = editor.getMap();
 
 	// Create topsizer
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 	wxSizer* tmpsizer;
 
-	for (TownMap::const_iterator town_iter = map.towns.begin(); town_iter != map.towns.end(); ++town_iter) {
+	for(TownMap::const_iterator town_iter = map.towns.begin(); town_iter != map.towns.end(); ++town_iter) {
 		Town* town = town_iter->second;
 		town_list.push_back(newd Town(*town));
-		if (max_town_id < town->getID()) {
+		if(max_town_id < town->getID()) {
 			max_town_id = town->getID();
 		}
 	}
@@ -1205,10 +1236,10 @@ EditTownsDialog::EditTownsDialog(wxWindow* parent, Editor &editor) :
 
 	// House options
 	tmpsizer = newd wxStaticBoxSizer(wxHORIZONTAL, this, "Name / ID");
-	name_field = newd wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxSize(190, 20), 0, wxTextValidator(wxFILTER_ASCII, &town_name));
+	name_field = newd wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxSize(190,20), 0, wxTextValidator(wxFILTER_ASCII, &town_name));
 	tmpsizer->Add(name_field, 2, wxEXPAND | wxLEFT | wxBOTTOM, 5);
 
-	id_field = newd wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxSize(40, 20), 0, wxTextValidator(wxFILTER_NUMERIC, &town_id));
+	id_field = newd wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxSize(40,20), 0, wxTextValidator(wxFILTER_NUMERIC, &town_id));
 	id_field->Enable(false);
 	tmpsizer->Add(id_field, 1, wxEXPAND | wxLEFT | wxRIGHT | wxBOTTOM, 5);
 	sizer->Add(tmpsizer, 0, wxEXPAND | wxALL, 10);
@@ -1230,33 +1261,35 @@ EditTownsDialog::EditTownsDialog(wxWindow* parent, Editor &editor) :
 	BuildListBox(true);
 }
 
-EditTownsDialog::~EditTownsDialog() {
-	for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+EditTownsDialog::~EditTownsDialog()
+{
+	for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
 		delete *town_iter;
 	}
 }
 
-void EditTownsDialog::BuildListBox(bool doselect) {
+void EditTownsDialog::BuildListBox(bool doselect)
+{
 	long tmplong = 0;
 	max_town_id = 0;
 	wxArrayString town_name_list;
 	uint32_t selection_before = 0;
 
-	if (doselect && id_field->GetValue().ToLong(&tmplong)) {
+	if(doselect && id_field->GetValue().ToLong(&tmplong)) {
 		uint32_t old_town_id = tmplong;
 
-		for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
-			if (old_town_id == (*town_iter)->getID()) {
+		for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+			if(old_town_id == (*town_iter)->getID()) {
 				selection_before = (*town_iter)->getID();
 				break;
 			}
 		}
 	}
 
-	for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+	for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
 		Town* town = *town_iter;
 		town_name_list.Add(wxstr(town->getName()));
-		if (max_town_id < town->getID()) {
+		if(max_town_id < town->getID()) {
 			max_town_id = town->getID();
 		}
 	}
@@ -1265,11 +1298,11 @@ void EditTownsDialog::BuildListBox(bool doselect) {
 	remove_button->Enable(town_listbox->GetCount() != 0);
 	select_position_button->Enable(false);
 
-	if (doselect) {
-		if (selection_before) {
+	if(doselect) {
+		if(selection_before) {
 			int i = 0;
-			for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
-				if (selection_before == (*town_iter)->getID()) {
+			for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+				if(selection_before == (*town_iter)->getID()) {
 					town_listbox->SetSelection(i);
 					return;
 				}
@@ -1280,35 +1313,36 @@ void EditTownsDialog::BuildListBox(bool doselect) {
 	}
 }
 
-void EditTownsDialog::UpdateSelection(int new_selection) {
+void EditTownsDialog::UpdateSelection(int new_selection)
+{
 	long tmplong;
 
 	// Save old values
-	if (town_list.size() > 0) {
-		if (id_field->GetValue().ToLong(&tmplong)) {
+	if(town_list.size() > 0) {
+		if(id_field->GetValue().ToLong(&tmplong)) {
 			uint32_t old_town_id = tmplong;
 
 			Town* old_town = nullptr;
 
-			for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
-				if (old_town_id == (*town_iter)->getID()) {
+			for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+				if(old_town_id == (*town_iter)->getID()) {
 					old_town = *town_iter;
 					break;
 				}
 			}
 
-			if (old_town) {
+			if(old_town) {
 				Position templepos = temple_position->GetPosition();
 
-				// printf("Changed town %d:%s\n", old_town_id, old_town->getName().c_str());
-				// printf("New values %d:%s:%d:%d:%d\n", town_id, town_name.c_str(), templepos.x, templepos.y, templepos.z);
+				//printf("Changed town %d:%s\n", old_town_id, old_town->getName().c_str());
+				//printf("New values %d:%s:%d:%d:%d\n", town_id, town_name.c_str(), templepos.x, templepos.y, templepos.z);
 				old_town->setTemplePosition(templepos);
 
 				wxString new_name = name_field->GetValue();
 				wxString old_name = wxstr(old_town->getName());
 
 				old_town->setName(nstr(new_name));
-				if (new_name != old_name) {
+				if(new_name != old_name) {
 					// Name has changed, update list
 					BuildListBox(false);
 				}
@@ -1320,7 +1354,7 @@ void EditTownsDialog::UpdateSelection(int new_selection) {
 	town_name.Clear();
 	town_id.Clear();
 
-	if (town_list.size() > size_t(new_selection)) {
+	if(town_list.size() > size_t(new_selection)) {
 		name_field->Enable(true);
 		temple_position->Enable(true);
 		select_position_button->Enable(true);
@@ -1329,7 +1363,7 @@ void EditTownsDialog::UpdateSelection(int new_selection) {
 		Town* town = town_list[new_selection];
 		ASSERT(town);
 
-		// printf("Selected %d:%s\n", new_selection, town->getName().c_str());
+		//printf("Selected %d:%s\n", new_selection, town->getName().c_str());
 		town_name << wxstr(town->getName());
 		name_field->SetValue(town_name);
 		town_id << long(town->getID());
@@ -1344,29 +1378,33 @@ void EditTownsDialog::UpdateSelection(int new_selection) {
 	Refresh();
 }
 
-void EditTownsDialog::OnListBoxChange(wxCommandEvent &event) {
+void EditTownsDialog::OnListBoxChange(wxCommandEvent& event)
+{
 	UpdateSelection(event.GetSelection());
 }
 
-void EditTownsDialog::OnClickSelectTemplePosition(wxCommandEvent &WXUNUSED(event)) {
+void EditTownsDialog::OnClickSelectTemplePosition(wxCommandEvent& WXUNUSED(event))
+{
 	Position templepos = temple_position->GetPosition();
 	g_gui.SetScreenCenterPosition(templepos);
 }
 
-void EditTownsDialog::OnClickAdd(wxCommandEvent &WXUNUSED(event)) {
+void EditTownsDialog::OnClickAdd(wxCommandEvent& WXUNUSED(event))
+{
 	Town* new_town = newd Town(++max_town_id);
 	new_town->setName("Unnamed Town");
-	new_town->setTemplePosition(Position(0, 0, 0));
+	new_town->setTemplePosition(Position(0,0,0));
 	town_list.push_back(new_town);
 
 	BuildListBox(false);
-	UpdateSelection(town_list.size() - 1);
-	town_listbox->SetSelection(town_list.size() - 1);
+	UpdateSelection(town_list.size()-1);
+	town_listbox->SetSelection(town_list.size()-1);
 }
 
-void EditTownsDialog::OnClickRemove(wxCommandEvent &WXUNUSED(event)) {
+void EditTownsDialog::OnClickRemove(wxCommandEvent& WXUNUSED(event))
+{
 	long tmplong;
-	if (id_field->GetValue().ToLong(&tmplong)) {
+	if(id_field->GetValue().ToLong(&tmplong)) {
 		uint32_t old_town_id = tmplong;
 
 		Town* town = nullptr;
@@ -1374,21 +1412,19 @@ void EditTownsDialog::OnClickRemove(wxCommandEvent &WXUNUSED(event)) {
 		std::vector<Town*>::iterator town_iter = town_list.begin();
 
 		int selection_index = 0;
-		while (town_iter != town_list.end()) {
-			if (old_town_id == (*town_iter)->getID()) {
+		while(town_iter != town_list.end()) {
+			if(old_town_id == (*town_iter)->getID()) {
 				town = *town_iter;
 				break;
 			}
 			++selection_index;
 			++town_iter;
 		}
-		if (!town) {
-			return;
-		}
+		if(!town) return;
 
-		const Map &map = editor.getMap();
-		for (const auto &pair : map.houses) {
-			if (pair.second->townid == town->getID()) {
+		const Map& map = editor.getMap();
+		for(const auto& pair : map.houses) {
+			if(pair.second->townid == town->getID()) {
 				g_gui.PopupDialog(this, "Error", "You cannot delete a town which still has houses associated with it.", wxOK);
 				return;
 			}
@@ -1397,55 +1433,58 @@ void EditTownsDialog::OnClickRemove(wxCommandEvent &WXUNUSED(event)) {
 		delete town;
 		town_list.erase(town_iter);
 		BuildListBox(false);
-		UpdateSelection(selection_index - 1);
+		UpdateSelection(selection_index-1);
 	}
 }
 
-void EditTownsDialog::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
+void EditTownsDialog::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
 	long tmplong = 0;
 
-	if (Validate() && TransferDataFromWindow()) {
+	if(Validate() && TransferDataFromWindow()) {
 		// Save old values
-		if (town_list.size() > 0 && id_field->GetValue().ToLong(&tmplong)) {
+		if(town_list.size() > 0 && id_field->GetValue().ToLong(&tmplong)) {
 			uint32_t old_town_id = tmplong;
 
 			Town* old_town = nullptr;
 
-			for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
-				if (old_town_id == (*town_iter)->getID()) {
+			for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+				if(old_town_id == (*town_iter)->getID()) {
 					old_town = *town_iter;
 					break;
 				}
 			}
 
-			if (old_town) {
+			if(old_town) {
 				Position templepos = temple_position->GetPosition();
 
-				// printf("Changed town %d:%s\n", old_town_id, old_town->getName().c_str());
-				// printf("New values %d:%s:%d:%d:%d\n", town_id, town_name.c_str(), templepos.x, templepos.y, templepos.z);
+				//printf("Changed town %d:%s\n", old_town_id, old_town->getName().c_str());
+				//printf("New values %d:%s:%d:%d:%d\n", town_id, town_name.c_str(), templepos.x, templepos.y, templepos.z);
 				old_town->setTemplePosition(templepos);
 
 				wxString new_name = name_field->GetValue();
 				wxString old_name = wxstr(old_town->getName());
 
 				old_town->setName(nstr(new_name));
-				if (new_name != old_name) {
+				if(new_name != old_name) {
 					// Name has changed, update list
 					BuildListBox(true);
 				}
 			}
 		}
 
-		Towns &towns = editor.getMap().towns;
+		Towns& towns = editor.getMap().towns;
 
 		// Verify the newd information
-		for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+		for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
 			Town* town = *town_iter;
-			if (town->getName() == "") {
+			if(town->getName() == "") {
 				g_gui.PopupDialog(this, "Error", "You can't have a town with an empty name.", wxOK);
 				return;
 			}
-			if (!town->getTemplePosition().isValid() || town->getTemplePosition().x > editor.getMap().getWidth() || town->getTemplePosition().y > editor.getMap().getHeight()) {
+			if(!town->getTemplePosition().isValid() ||
+				town->getTemplePosition().x > editor.getMap().getWidth() ||
+				town->getTemplePosition().y > editor.getMap().getHeight()) {
 				wxString msg;
 				msg << "The town " << wxstr(town->getName()) << " has an invalid temple position.";
 				g_gui.PopupDialog(this, "Error", msg, wxOK);
@@ -1457,7 +1496,7 @@ void EditTownsDialog::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 		towns.clear();
 
 		// Build the newd town map
-		for (std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
+		for(std::vector<Town*>::iterator town_iter = town_list.begin(); town_iter != town_list.end(); ++town_iter) {
 			towns.addTown(*town_iter);
 		}
 		town_list.clear();
@@ -1468,7 +1507,8 @@ void EditTownsDialog::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
 	}
 }
 
-void EditTownsDialog::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void EditTownsDialog::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	// Just close this window
 	EndModal(0);
 }
@@ -1478,14 +1518,15 @@ void EditTownsDialog::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
 // Jump to a position on the map by entering XYZ coordinates
 
 BEGIN_EVENT_TABLE(GotoPositionDialog, wxDialog)
-EVT_BUTTON(wxID_OK, GotoPositionDialog::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, GotoPositionDialog::OnClickCancel)
+	EVT_BUTTON(wxID_OK, GotoPositionDialog::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, GotoPositionDialog::OnClickCancel)
 END_EVENT_TABLE()
 
-GotoPositionDialog::GotoPositionDialog(wxWindow* parent, Editor &editor) :
+GotoPositionDialog::GotoPositionDialog(wxWindow* parent, Editor& editor) :
 	wxDialog(parent, wxID_ANY, "Go To Position", wxDefaultPosition, wxDefaultSize),
-	editor(editor) {
-	const Map &map = editor.getMap();
+	editor(editor)
+{
+	const Map& map = editor.getMap();
 
 	// create topsizer
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
@@ -1503,11 +1544,13 @@ GotoPositionDialog::GotoPositionDialog(wxWindow* parent, Editor &editor) :
 	Centre(wxBOTH);
 }
 
-void GotoPositionDialog::OnClickCancel(wxCommandEvent &) {
+void GotoPositionDialog::OnClickCancel(wxCommandEvent &)
+{
 	EndModal(0);
 }
 
-void GotoPositionDialog::OnClickOK(wxCommandEvent &) {
+void GotoPositionDialog::OnClickOK(wxCommandEvent &)
+{
 	g_gui.SetScreenCenterPosition(posctrl->GetPosition());
 	EndModal(1);
 }
diff --git a/source/common_windows.h b/source/common_windows.h
index 47ad61cd..03ddb000 100644
--- a/source/common_windows.h
+++ b/source/common_windows.h
@@ -29,42 +29,45 @@ class MapTab;
 /**
  * A toggle button with an item on it.
  */
-class ItemToggleButton : public DCButton {
+class ItemToggleButton : public DCButton
+{
 public:
 	ItemToggleButton(wxWindow* parent, RenderSize size, int lookid, wxWindowID id = wxID_ANY) :
-		DCButton(parent, id, wxDefaultPosition, DC_BTN_TOGGLE, size, lookid) { }
-	virtual ~ItemToggleButton() { }
+		DCButton(parent, id, wxDefaultPosition, DC_BTN_TOGGLE, size, lookid) {}
+	virtual ~ItemToggleButton() {}
 };
 
 /**
  * A button with an item on it.
  */
-class ItemButton : public DCButton {
+class ItemButton : public DCButton
+{
 public:
 	ItemButton(wxWindow* parent, RenderSize size, uint16_t lookid, wxWindowID id = wxID_ANY) :
-		DCButton(parent, id, wxDefaultPosition, DC_BTN_NORMAL, size, lookid) { }
-	virtual ~ItemButton() { }
+		DCButton(parent, id, wxDefaultPosition, DC_BTN_NORMAL, size, lookid) {}
+	virtual ~ItemButton() {}
 };
 
 /**
  * The map properties window
  * Change map size, protocol etc.
  */
-class MapPropertiesWindow : public wxDialog {
+class MapPropertiesWindow : public wxDialog
+{
 public:
-	MapPropertiesWindow(wxWindow* parent, MapTab* tab, Editor &editor);
+	MapPropertiesWindow(wxWindow* parent, MapTab* tab, Editor& editor);
 	virtual ~MapPropertiesWindow();
 
-	void OnChangeVersion(wxCommandEvent &);
+	void OnChangeVersion(wxCommandEvent&);
 
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
 
 protected:
 	void UpdateProtocolList();
 
 	MapTab* view;
-	Editor &editor;
+	Editor& editor;
 	wxSpinCtrl* height_spin;
 	wxSpinCtrl* width_spin;
 	wxChoice* version_choice;
@@ -73,6 +76,7 @@ class MapPropertiesWindow : public wxDialog {
 	wxTextCtrl* house_filename_ctrl;
 	wxTextCtrl* spawn_filename_ctrl;
 	wxTextCtrl* spawn_npc_filename_ctrl;
+	wxTextCtrl* zone_filename_ctrl;
 
 	DECLARE_EVENT_TABLE();
 };
@@ -81,17 +85,17 @@ class MapPropertiesWindow : public wxDialog {
  * The import map dialog
  * Allows selection of file path, offset and some weird options.
  */
-class ImportMapWindow : public wxDialog {
+class ImportMapWindow : public wxDialog
+{
 public:
-	ImportMapWindow(wxWindow* parent, Editor &editor);
+	ImportMapWindow(wxWindow* parent, Editor& editor);
 	virtual ~ImportMapWindow();
 
-	void OnClickBrowse(wxCommandEvent &);
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
-
+	void OnClickBrowse(wxCommandEvent&);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
 protected:
-	Editor &editor;
+	Editor& editor;
 
 	wxTextCtrl* file_text_field;
 	wxSpinCtrl* x_offset_ctrl;
@@ -108,22 +112,23 @@ class ImportMapWindow : public wxDialog {
 /**
  * The export minimap dialog, select output path and what floors to export.
  */
-class ExportMiniMapWindow : public wxDialog {
+class ExportMiniMapWindow : public wxDialog
+{
 public:
-	ExportMiniMapWindow(wxWindow* parent, Editor &editor);
+	ExportMiniMapWindow(wxWindow* parent, Editor& editor);
 	virtual ~ExportMiniMapWindow();
 
-	void OnClickBrowse(wxCommandEvent &);
-	void OnDirectoryChanged(wxKeyEvent &);
-	void OnFileNameChanged(wxKeyEvent &);
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
-	void OnExportTypeChange(wxCommandEvent &);
+	void OnClickBrowse(wxCommandEvent&);
+	void OnDirectoryChanged(wxKeyEvent&);
+	void OnFileNameChanged(wxKeyEvent&);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
+	void OnExportTypeChange(wxCommandEvent&);
 
 protected:
 	void CheckValues();
 
-	Editor &editor;
+	Editor& editor;
 
 	wxChoice* format_options;
 	wxStaticText* error_field;
@@ -139,13 +144,14 @@ class ExportMiniMapWindow : public wxDialog {
 /**
  * Text control that will forward up/down pgup / pgdown keys to parent window
  */
-class KeyForwardingTextCtrl : public wxTextCtrl {
+class KeyForwardingTextCtrl : public wxTextCtrl
+{
 public:
-	KeyForwardingTextCtrl(wxWindow* parent, wxWindowID id, const wxString &value = "", const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize, long style = 0, const wxValidator &validator = wxDefaultValidator, const wxString &name = wxTextCtrlNameStr) :
-		wxTextCtrl(parent, id, value, pos, size, style, validator, name) { }
-	~KeyForwardingTextCtrl() { }
+	KeyForwardingTextCtrl(wxWindow* parent, wxWindowID id, const wxString& value = "", const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = 0, const wxValidator& validator = wxDefaultValidator, const wxString& name = wxTextCtrlNameStr)
+		: wxTextCtrl(parent, id, value, pos, size, style, validator, name) {}
+	~KeyForwardingTextCtrl() {}
 
-	void OnKeyDown(wxKeyEvent &);
+	void OnKeyDown(wxKeyEvent&);
 
 	DECLARE_EVENT_TABLE()
 };
@@ -154,7 +160,8 @@ class KeyForwardingTextCtrl : public wxTextCtrl {
  * The list inside a find dialog
  * Presents a list of brushes
  */
-class FindDialogListBox : public wxVListBox {
+class FindDialogListBox : public wxVListBox
+{
 public:
 	FindDialogListBox(wxWindow* parent, wxWindowID id);
 	~FindDialogListBox();
@@ -164,9 +171,8 @@ class FindDialogListBox : public wxVListBox {
 	void AddBrush(Brush*);
 	Brush* GetSelectedBrush();
 
-	void OnDrawItem(wxDC &dc, const wxRect &rect, size_t index) const;
+	void OnDrawItem(wxDC& dc, const wxRect& rect, size_t index) const;
 	wxCoord OnMeasureItem(size_t index) const;
-
 protected:
 	bool cleared;
 	bool no_matches;
@@ -174,15 +180,15 @@ class FindDialogListBox : public wxVListBox {
 };
 
 /**
- * A wxListBox that can be sorted without using style wxLB_SORT.
- * wxLB_SORT does not work properly on Windows and causes errors on macOS.
- */
-class SortableListBox : public wxListBox {
+* A wxListBox that can be sorted without using style wxLB_SORT.
+* wxLB_SORT does not work properly on Windows and causes errors on macOS.
+*/
+class SortableListBox : public wxCheckListBox
+{
 public:
 	SortableListBox(wxWindow* parent, wxWindowID id, const wxPoint &pos = wxDefaultPosition, const wxSize &size = wxDefaultSize);
 	~SortableListBox();
 	void Sort();
-
 private:
 	void DoSort();
 };
@@ -192,29 +198,25 @@ class SortableListBox : public wxListBox {
  * ShowModal will return 0 or the item id for item dialogs
  * 0 or 1 for brush dialogs
  */
-class FindDialog : public wxDialog {
+class FindDialog : public wxDialog
+{
 public:
 	FindDialog(wxWindow* parent, wxString title);
 	virtual ~FindDialog();
 
-	void OnKeyDown(wxKeyEvent &);
-	void OnTextChange(wxCommandEvent &);
-	void OnTextIdle(wxTimerEvent &);
-	void OnClickList(wxCommandEvent &);
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
+	void OnKeyDown(wxKeyEvent&);
+	void OnTextChange(wxCommandEvent&);
+	void OnTextIdle(wxTimerEvent&);
+	void OnClickList(wxCommandEvent&);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
 
 	void RefreshContents();
-	virtual const Brush* getResult() const {
-		return result_brush;
-	}
-	virtual int getResultID() const {
-		return result_id;
-	}
-
+	virtual const Brush* getResult() const {return result_brush;}
+	virtual int getResultID() const {return result_id;}
 protected:
 	virtual void RefreshContentsInternal() = 0;
-	virtual void OnClickListInternal(wxCommandEvent &) = 0;
+	virtual void OnClickListInternal(wxCommandEvent&) = 0;
 	virtual void OnClickOKInternal() = 0;
 
 	FindDialogListBox* item_list;
@@ -230,13 +232,14 @@ class FindDialog : public wxDialog {
  * Find a brush dialog
  * Find out what brush was returned through GetResult
  */
-class FindBrushDialog : public FindDialog {
+class FindBrushDialog : public FindDialog
+{
 public:
 	FindBrushDialog(wxWindow* parent, wxString title = "Jump to Brush");
 	virtual ~FindBrushDialog();
 
 	virtual void RefreshContentsInternal();
-	virtual void OnClickListInternal(wxCommandEvent &);
+	virtual void OnClickListInternal(wxCommandEvent&);
 	virtual void OnClickOKInternal();
 };
 
@@ -244,16 +247,17 @@ class FindBrushDialog : public FindDialog {
  * Go to position dialog
  * Allows entry of 3 coordinates and goes there instantly
  */
-class GotoPositionDialog : public wxDialog {
+class GotoPositionDialog : public wxDialog
+{
 public:
-	GotoPositionDialog(wxWindow* parent, Editor &editor);
-	~GotoPositionDialog() { }
+	GotoPositionDialog(wxWindow* parent, Editor& editor);
+	~GotoPositionDialog() {}
 
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
 
 protected:
-	Editor &editor;
+	Editor& editor;
 	PositionCtrl* posctrl;
 
 	DECLARE_EVENT_TABLE();
@@ -264,33 +268,29 @@ class GotoPositionDialog : public wxDialog {
  * There are two versions, one for otbmv4 maps and one for the old maps.
  * They are declared in old_properties_window / properties_window
  */
-class ObjectPropertiesWindowBase : public wxDialog {
+class ObjectPropertiesWindowBase : public wxDialog
+{
 public:
 	ObjectPropertiesWindowBase(
 		wxWindow* parent, wxString title,
 		const Map* map, const Tile* tile, Item* item,
-		wxPoint position = wxDefaultPosition
-	);
+		wxPoint position = wxDefaultPosition);
 	ObjectPropertiesWindowBase(
 		wxWindow* parent, wxString title,
 		const Map* map, const Tile* tile, SpawnMonster* spawnMonster,
-		wxPoint position = wxDefaultPosition
-	);
+		wxPoint position = wxDefaultPosition);
 	ObjectPropertiesWindowBase(
 		wxWindow* parent, wxString title,
 		const Map* map, const Tile* tile, SpawnNpc* spawnNpc,
-		wxPoint position = wxDefaultPosition
-	);
+		wxPoint position = wxDefaultPosition);
 	ObjectPropertiesWindowBase(
 		wxWindow* parent, wxString title,
 		const Map* map, const Tile* tile, Npc* npc,
-		wxPoint position = wxDefaultPosition
-	);
+		wxPoint position = wxDefaultPosition);
 	ObjectPropertiesWindowBase(
 		wxWindow* parent, wxString title,
 		const Map* map, const Tile* tile, Monster* monster,
-		wxPoint position = wxDefaultPosition
-	);
+		wxPoint position = wxDefaultPosition);
 
 	Item* getItemBeingEdited();
 	Monster* getMonsterBeingEdited();
@@ -311,23 +311,24 @@ class ObjectPropertiesWindowBase : public wxDialog {
 /**
  * The edit towns dialog, ugly as sin.
  */
-class EditTownsDialog : public wxDialog {
+class EditTownsDialog : public wxDialog
+{
 public:
-	EditTownsDialog(wxWindow* parent, Editor &editor);
+	EditTownsDialog(wxWindow* parent, Editor& editor);
 	virtual ~EditTownsDialog();
 
-	void OnListBoxChange(wxCommandEvent &);
-	void OnClickSelectTemplePosition(wxCommandEvent &);
-	void OnClickAdd(wxCommandEvent &);
-	void OnClickRemove(wxCommandEvent &);
-	void OnClickOK(wxCommandEvent &);
-	void OnClickCancel(wxCommandEvent &);
-
+	void OnListBoxChange(wxCommandEvent&);
+	void OnClickSelectTemplePosition(wxCommandEvent&);
+	void OnClickAdd(wxCommandEvent&);
+	void OnClickRemove(wxCommandEvent&);
+	void OnClickOK(wxCommandEvent&);
+	void OnClickCancel(wxCommandEvent&);
 protected:
+
 	void BuildListBox(bool doselect);
 	void UpdateSelection(int new_selection);
 
-	Editor &editor;
+	Editor& editor;
 
 	std::vector<Town*> town_list;
 	uint32_t max_town_id;
diff --git a/source/complexitem.h b/source/complexitem.h
index 7e32dc06..e9423f88 100644
--- a/source/complexitem.h
+++ b/source/complexitem.h
@@ -52,12 +52,12 @@ class Container : public Item {
 	size_t getVolume() const noexcept {
 		return getItemType().volume;
 	}
-	double getWeight() noexcept {
+	double getWeight() noexcept override {
 		return getItemType().weight;
 	}
 
-	virtual bool unserializeItemNode_OTBM(const IOMap &maphandle, BinaryNode* node);
-	virtual bool serializeItemNode_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const;
+	virtual bool unserializeItemNode_OTBM(const IOMap &maphandle, BinaryNode* node) override;
+	virtual bool serializeItemNode_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const override;
 	// virtual bool unserializeItemNode_OTMM(const IOMap& maphandle, BinaryNode* node);
 	// virtual bool serializeItemNode_OTMM(const IOMap& maphandle, NodeFileWriteHandle& f) const;
 
@@ -74,8 +74,8 @@ class Teleport : public Item {
 		return this;
 	}
 
-	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const;
-	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node);
+	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const override;
+	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node) override;
 	// virtual void serializeItemAttributes_OTMM(const IOMap& maphandle, NodeFileWriteHandle& f) const;
 	// virtual bool readItemAttribute_OTMM(const IOMap& maphandle, OTMM_ItemAttribute attr, BinaryNode* node);
 
@@ -118,8 +118,8 @@ class Door : public Item {
 		doorId = id;
 	}
 
-	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const;
-	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node);
+	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const override;
+	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node) override;
 	// virtual void serializeItemAttributes_OTMM(const IOMap& maphandle, NodeFileWriteHandle& f) const;
 	// virtual bool readItemAttribute_OTMM(const IOMap& maphandle, OTMM_ItemAttribute attr, BinaryNode* node);
 
@@ -143,8 +143,8 @@ class Depot : public Item {
 		depotId = id;
 	}
 
-	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const;
-	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node);
+	virtual void serializeItemAttributes_OTBM(const IOMap &maphandle, NodeFileWriteHandle &f) const override;
+	virtual bool readItemAttribute_OTBM(const IOMap &maphandle, OTBM_ItemAttribute attr, BinaryNode* node) override;
 	// virtual void serializeItemAttributes_OTMM(const IOMap& maphandle, NodeFileWriteHandle& f) const;
 	// virtual bool readItemAttribute_OTMM(const IOMap& maphandle, OTMM_ItemAttribute attr, BinaryNode* node);
 
diff --git a/source/editor.cpp b/source/editor.cpp
index 931a9602..e2bd1b88 100644
--- a/source/editor.cpp
+++ b/source/editor.cpp
@@ -41,24 +41,24 @@
 #include "live_client.h"
 #include "live_action.h"
 
-Editor::Editor(CopyBuffer &copybuffer) :
+Editor::Editor(CopyBuffer& copybuffer) :
 	live_server(nullptr),
 	live_client(nullptr),
 	actionQueue(newd ActionQueue(*this)),
 	selection(*this),
 	copybuffer(copybuffer),
-	replace_brush(nullptr) {
+	replace_brush(nullptr)
+{
 	wxString error;
 	wxArrayString warnings;
 	bool ok = true;
 
 	ClientVersionID defaultVersion = ClientVersionID(g_settings.getInteger(Config::DEFAULT_CLIENT_VERSION));
-	if (defaultVersion == CLIENT_VERSION_NONE) {
+	if(defaultVersion == CLIENT_VERSION_NONE)
 		defaultVersion = ClientVersion::getLatestVersion()->getID();
-	}
 
-	if (g_gui.GetCurrentVersionID() != defaultVersion) {
-		if (g_gui.CloseAllEditors()) {
+	if(g_gui.GetCurrentVersionID() != defaultVersion) {
+		if(g_gui.CloseAllEditors()) {
 			ok = g_gui.LoadVersion(defaultVersion, error, warnings);
 			g_gui.PopupDialog("Error", error, wxOK);
 			g_gui.ListDialog("Warnings", warnings);
@@ -67,9 +67,8 @@ Editor::Editor(CopyBuffer &copybuffer) :
 		}
 	}
 
-	if (!ok) {
+	if(!ok)
 		throw std::runtime_error("Couldn't load client version");
-	}
 
 	MapVersion version;
 	version.otbm = g_gui.GetCurrentVersion().getPrefferedMapVersionID();
@@ -86,21 +85,23 @@ Editor::Editor(CopyBuffer &copybuffer) :
 	map.spawnmonsterfile = sname + "-monster.xml";
 	map.spawnnpcfile = sname + "-npc.xml";
 	map.housefile = sname + "-house.xml";
+	map.zonefile = sname + "-zones.xml";
 	map.description = "No map description available.";
 	map.unnamed = true;
 
 	map.doChange();
 }
 
-Editor::Editor(CopyBuffer &copybuffer, const FileName &fn) :
+Editor::Editor(CopyBuffer& copybuffer, const FileName& fn) :
 	live_server(nullptr),
 	live_client(nullptr),
 	actionQueue(newd ActionQueue(*this)),
 	selection(*this),
 	copybuffer(copybuffer),
-	replace_brush(nullptr) {
+	replace_brush(nullptr)
+{
 	MapVersion ver;
-	if (!IOMapOTBM::getVersionInfo(fn, ver)) {
+	if(!IOMapOTBM::getVersionInfo(fn, ver)) {
 		// g_gui.PopupDialog("Error", "Could not open file \"" + fn.GetFullPath() + "\".", wxOK);
 		throw std::runtime_error("Could not open file \"" + nstr(fn.GetFullPath()) + "\".\nThis is not a valid OTBM file or it does not exist.");
 	}
@@ -116,22 +117,21 @@ Editor::Editor(CopyBuffer &copybuffer, const FileName &fn) :
 	*/
 
 	bool success = true;
-	if (g_gui.GetCurrentVersionID() != ver.client) {
+	if(g_gui.GetCurrentVersionID() != ver.client) {
 		wxString error;
 		wxArrayString warnings;
-		if (g_gui.CloseAllEditors()) {
+		if(g_gui.CloseAllEditors()) {
 			success = g_gui.LoadVersion(ver.client, error, warnings);
-			if (!success) {
+			if(!success)
 				g_gui.PopupDialog("Error", error, wxOK);
-			} else {
+			else
 				g_gui.ListDialog("Warnings", warnings);
-			}
 		} else {
 			throw std::runtime_error("All maps of different versions were not closed.");
 		}
 	}
 
-	if (success) {
+	if(success) {
 		ScopedLoadingBar LoadingBar("Loading OTBM map...");
 		success = map.open(nstr(fn.GetFullPath()));
 		/* TODO
@@ -147,18 +147,20 @@ Editor::Editor(CopyBuffer &copybuffer, const FileName &fn) :
 	}
 }
 
-Editor::Editor(CopyBuffer &copybuffer, LiveClient* client) :
+Editor::Editor(CopyBuffer& copybuffer, LiveClient* client) :
 	live_server(nullptr),
 	live_client(client),
 	actionQueue(newd NetworkedActionQueue(*this)),
 	selection(*this),
 	copybuffer(copybuffer),
-	replace_brush(nullptr) {
+	replace_brush(nullptr)
+{
 	;
 }
 
-Editor::~Editor() {
-	if (IsLive()) {
+Editor::~Editor()
+{
+	if(IsLive()) {
 		CloseLiveServer();
 	}
 
@@ -167,82 +169,91 @@ Editor::~Editor() {
 	delete actionQueue;
 }
 
-Action* Editor::createAction(ActionIdentifier type) {
+Action* Editor::createAction(ActionIdentifier type)
+{
 	return actionQueue->createAction(type);
 }
 
-Action* Editor::createAction(BatchAction* parent) {
+Action* Editor::createAction(BatchAction* parent)
+{
 	return actionQueue->createAction(parent);
 }
 
-BatchAction* Editor::createBatch(ActionIdentifier type) {
+BatchAction* Editor::createBatch(ActionIdentifier type)
+{
 	return actionQueue->createBatch(type);
 }
 
-void Editor::addBatch(BatchAction* action, int stacking_delay) {
+void Editor::addBatch(BatchAction* action, int stacking_delay)
+{
 	actionQueue->addBatch(action, stacking_delay);
 }
 
-void Editor::addAction(Action* action, int stacking_delay) {
+void Editor::addAction(Action* action, int stacking_delay )
+{
 	actionQueue->addAction(action, stacking_delay);
 }
 
-bool Editor::canUndo() const {
+bool Editor::canUndo() const
+{
 	return actionQueue->canUndo();
 }
 
-bool Editor::canRedo() const {
+bool Editor::canRedo() const
+{
 	return actionQueue->canRedo();
 }
 
-void Editor::undo(int indexes) {
-	if (indexes <= 0 || !actionQueue->canUndo()) {
+void Editor::undo(int indexes)
+{
+	if(indexes <= 0 || !actionQueue->canUndo())
 		return;
-	}
 
-	while (indexes > 0) {
-		if (!actionQueue->undo()) {
+	while(indexes > 0) {
+		if(!actionQueue->undo())
 			break;
-		}
 		indexes--;
 	}
 	g_gui.UpdateActions();
 	g_gui.RefreshView();
 }
 
-void Editor::redo(int indexes) {
-	if (indexes <= 0 || !actionQueue->canRedo()) {
+void Editor::redo(int indexes)
+{
+	if(indexes <= 0 || !actionQueue->canRedo())
 		return;
-	}
 
-	while (indexes > 0) {
-		if (!actionQueue->redo()) {
+	while(indexes > 0) {
+		if(!actionQueue->redo())
 			break;
-		}
 		indexes--;
 	}
 	g_gui.UpdateActions();
 	g_gui.RefreshView();
 }
 
-void Editor::updateActions() {
+void Editor::updateActions()
+{
 	actionQueue->generateLabels();
 	g_gui.UpdateMenus();
 	g_gui.UpdateActions();
 }
 
-void Editor::resetActionsTimer() {
+void Editor::resetActionsTimer()
+{
 	actionQueue->resetTimer();
 }
 
-void Editor::clearActions() {
+void Editor::clearActions()
+{
 	actionQueue->clear();
 	g_gui.UpdateActions();
 }
 
-bool Editor::hasChanges() const {
-	if (map.hasChanged()) {
-		if (map.getTileCount() == 0) {
+bool Editor::hasChanges() const
+{
+	if(map.hasChanged()) {
+		if(map.getTileCount() == 0) {
 			return actionQueue->hasChanges();
 		}
 		return true;
@@ -250,16 +261,18 @@ bool Editor::hasChanges() const {
 	return false;
 }
 
-void Editor::clearChanges() {
+void Editor::clearChanges()
+{
 	map.clearChanges();
 }
 
-void Editor::saveMap(FileName filename, bool showdialog) {
+void Editor::saveMap(FileName filename, bool showdialog)
+{
 	std::string savefile = filename.GetFullPath().mb_str(wxConvUTF8).data();
 	bool save_as = false;
 	bool save_otgz = false;
 
-	if (savefile.empty()) {
+	if(savefile.empty()) {
 		savefile = map.filename;
 
 		FileName c1(wxstr(savefile));
@@ -268,7 +281,7 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 	}
 
 	// If not named yet, propagate the file name to the auxilliary files
-	if (map.unnamed) {
+	if(map.unnamed) {
 		FileName _name(filename);
 		_name.SetExt("xml");
 
@@ -278,6 +291,8 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 		map.spawnnpcfile = nstr(_name.GetFullName());
 		_name.SetName(filename.GetName() + "-house");
 		map.housefile = nstr(_name.GetFullName());
+		_name.SetName(filename.GetName() + "-zones");
+		map.zonefile = nstr(_name.GetFullName());
 
 		map.unnamed = false;
 	}
@@ -288,53 +303,61 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 	std::string map_path = nstr(converter.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME));
 
 	// Make temporary backups
-	// converter.Assign(wxstr(savefile));
-	std::string backup_otbm, backup_house, backup_spawn, backup_spawn_npc;
+	//converter.Assign(wxstr(savefile));
+	std::string backup_otbm, backup_house, backup_spawn, backup_spawn_npc, backup_zones;
 
-	if (converter.GetExt() == "otgz") {
+	if(converter.GetExt() == "otgz") {
 		save_otgz = true;
-		if (converter.FileExists()) {
+		if(converter.FileExists()) {
 			backup_otbm = map_path + nstr(converter.GetName()) + ".otgz~";
 			std::remove(backup_otbm.c_str());
 			std::rename(savefile.c_str(), backup_otbm.c_str());
 		}
 	} else {
-		if (converter.FileExists()) {
+		if(converter.FileExists()) {
 			backup_otbm = map_path + nstr(converter.GetName()) + ".otbm~";
 			std::remove(backup_otbm.c_str());
 			std::rename(savefile.c_str(), backup_otbm.c_str());
 		}
 
 		converter.SetFullName(wxstr(map.housefile));
-		if (converter.FileExists()) {
+		if(converter.FileExists()) {
 			backup_house = map_path + nstr(converter.GetName()) + ".xml~";
 			std::remove(backup_house.c_str());
 			std::rename((map_path + map.housefile).c_str(), backup_house.c_str());
 		}
 
 		converter.SetFullName(wxstr(map.spawnmonsterfile));
-		if (converter.FileExists()) {
+		if(converter.FileExists()) {
 			backup_spawn = map_path + nstr(converter.GetName()) + ".xml~";
 			std::remove(backup_spawn.c_str());
 			std::rename((map_path + map.spawnmonsterfile).c_str(), backup_spawn.c_str());
 		}
 
 		converter.SetFullName(wxstr(map.spawnnpcfile));
-		if (converter.FileExists()) {
+		if(converter.FileExists()) {
 			backup_spawn_npc = map_path + nstr(converter.GetName()) + ".xml~";
 			std::remove(backup_spawn_npc.c_str());
 			std::rename((map_path + map.spawnnpcfile).c_str(), backup_spawn_npc.c_str());
 		}
+
+		converter.SetFullName(wxstr(map.zonefile));
+		if(converter.FileExists()) {
+			backup_zones = map_path + nstr(converter.GetName()) + ".xml~";
+			std::remove(backup_zones.c_str());
+			std::rename((map_path + map.zonefile).c_str(), backup_zones.c_str());
+		}
 	}
 
 	// Save the map
 	{
 		std::string n = nstr(g_gui.GetLocalDataDirectory()) + ".saving.txt";
 		std::ofstream f(n.c_str(), std::ios::trunc | std::ios::out);
-		f << backup_otbm << std::endl
-		  << backup_house << std::endl
-		  << backup_spawn << std::endl
-		  << backup_spawn_npc << std::endl;
+		f <<
+			backup_otbm << std::endl <<
+			backup_house << std::endl <<
+			backup_spawn << std::endl <<
+			backup_spawn_npc << std::endl;
 	}
 
 	{
@@ -344,45 +367,49 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 		map.filename = fn.GetFullPath().mb_str(wxConvUTF8);
 		map.name = fn.GetFullName().mb_str(wxConvUTF8);
 
-		if (showdialog) {
+		if(showdialog)
 			g_gui.CreateLoadBar("Saving OTBM map...");
-		}
 
 		// Perform the actual save
 		IOMapOTBM mapsaver(map.getVersion());
 		bool success = mapsaver.saveMap(map, fn);
 
-		if (showdialog) {
+		if(showdialog)
 			g_gui.DestroyLoadBar();
-		}
 
 		// Check for errors...
-		if (!success) {
+		if(!success) {
 			// Rename the temporary backup files back to their previous names
-			if (!backup_otbm.empty()) {
+			if(!backup_otbm.empty()) {
 				converter.SetFullName(wxstr(savefile));
 				std::string otbm_filename = map_path + nstr(converter.GetName());
 				std::rename(backup_otbm.c_str(), std::string(otbm_filename + (save_otgz ? ".otgz" : ".otbm")).c_str());
 			}
 
-			if (!backup_house.empty()) {
+			if(!backup_house.empty()) {
 				converter.SetFullName(wxstr(map.housefile));
 				std::string house_filename = map_path + nstr(converter.GetName());
 				std::rename(backup_house.c_str(), std::string(house_filename + ".xml").c_str());
 			}
 
-			if (!backup_spawn.empty()) {
+			if(!backup_spawn.empty()) {
 				converter.SetFullName(wxstr(map.spawnmonsterfile));
 				std::string spawn_filename = map_path + nstr(converter.GetName());
 				std::rename(backup_spawn.c_str(), std::string(spawn_filename + ".xml").c_str());
 			}
 
-			if (!backup_spawn_npc.empty()) {
+			if(!backup_spawn_npc.empty()) {
 				converter.SetFullName(wxstr(map.spawnnpcfile));
 				std::string spawnnpc_filename = map_path + nstr(converter.GetName());
 				std::rename(backup_spawn_npc.c_str(), std::string(spawnnpc_filename + ".xml").c_str());
 			}
 
+			if(!backup_zones.empty()) {
+				converter.SetFullName(wxstr(map.zonefile));
+				std::string zones_filename = map_path + nstr(converter.GetName());
+				std::rename(backup_zones.c_str(), std::string(zones_filename + ".xml").c_str());
+			}
+
 			// Display the error
 			g_gui.PopupDialog("Error", "Could not save, unable to open target for writing.", wxOK);
 		}
@@ -394,13 +421,12 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 		}
 
 		// If failure, don't run the rest of the function
-		if (!success) {
+		if(!success)
 			return;
-		}
 	}
 
 	// Move to permanent backup
-	if (!save_as && g_settings.getInteger(Config::ALWAYS_MAKE_BACKUP)) {
+	if(!save_as && g_settings.getInteger(Config::ALWAYS_MAKE_BACKUP)) {
 		// Move temporary backups to their proper files
 		time_t t = time(nullptr);
 		tm* current_time = localtime(&t);
@@ -408,40 +434,44 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 
 		std::ostringstream date;
 		date << (1900 + current_time->tm_year);
-		if (current_time->tm_mon < 9) {
-			date << "-"
-				 << "0" << current_time->tm_mon + 1;
-		} else {
-			date << "-" << current_time->tm_mon + 1;
-		}
+		if(current_time->tm_mon < 9)
+			date << "-" << "0" << current_time->tm_mon+1;
+		else
+			date << "-" << current_time->tm_mon+1;
 		date << "-" << current_time->tm_mday;
 		date << "-" << current_time->tm_hour;
 		date << "-" << current_time->tm_min;
 		date << "-" << current_time->tm_sec;
 
-		if (!backup_otbm.empty()) {
+		if(!backup_otbm.empty()) {
 			converter.SetFullName(wxstr(savefile));
 			std::string otbm_filename = map_path + nstr(converter.GetName());
 			std::rename(backup_otbm.c_str(), std::string(otbm_filename + "." + date.str() + (save_otgz ? ".otgz" : ".otbm")).c_str());
 		}
 
-		if (!backup_house.empty()) {
+		if(!backup_house.empty()) {
 			converter.SetFullName(wxstr(map.housefile));
 			std::string house_filename = map_path + nstr(converter.GetName());
 			std::rename(backup_house.c_str(), std::string(house_filename + "." + date.str() + ".xml").c_str());
 		}
 
-		if (!backup_spawn.empty()) {
+		if(!backup_spawn.empty()) {
 			converter.SetFullName(wxstr(map.spawnmonsterfile));
 			std::string spawn_filename = map_path + nstr(converter.GetName());
 			std::rename(backup_spawn.c_str(), std::string(spawn_filename + "." + date.str() + ".xml").c_str());
 		}
 
-		if (!backup_spawn_npc.empty()) {
+		if(!backup_spawn_npc.empty()) {
 			converter.SetFullName(wxstr(map.spawnnpcfile));
 			std::string spawnnpc_filename = map_path + nstr(converter.GetName());
 			std::rename(backup_spawn_npc.c_str(), std::string(spawnnpc_filename + "." + date.str() + ".xml").c_str());
 		}
+
+		if(!backup_zones.empty()) {
+			converter.SetFullName(wxstr(map.zonefile));
+			std::string zones_filename = map_path + nstr(converter.GetName());
+			std::rename(backup_zones.c_str(), std::string(zones_filename + "." + date.str() + ".xml").c_str());
+		}
 	} else {
 		// Delete the temporary files
 		std::remove(backup_otbm.c_str());
@@ -453,18 +483,20 @@ void Editor::saveMap(FileName filename, bool showdialog) {
 	clearChanges();
 }
 
-bool Editor::importMiniMap(FileName filename, int import, int import_x_offset, int import_y_offset, int import_z_offset) {
+bool Editor::importMiniMap(FileName filename, int import, int import_x_offset, int import_y_offset, int import_z_offset)
+{
 	return false;
 }
 
-bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offset, int import_z_offset, ImportType house_import_type, ImportType spawn_import_type, ImportType spawn_npc_import_type) {
+bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offset, int import_z_offset, ImportType house_import_type, ImportType spawn_import_type, ImportType spawn_npc_import_type)
+{
 	selection.clear();
 	actionQueue->clear();
 
 	Map imported_map;
 	bool loaded = imported_map.open(nstr(filename.GetFullPath()));
 
-	if (!loaded) {
+	if(!loaded) {
 		g_gui.PopupDialog("Error", "Error loading map!\n" + imported_map.getError(), wxOK | wxICON_INFORMATION);
 		return false;
 	}
@@ -482,30 +514,30 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 	std::map<uint32_t, uint32_t> town_id_map;
 	std::map<uint32_t, uint32_t> house_id_map;
 
-	if (house_import_type != IMPORT_DONT) {
-		for (TownMap::iterator tit = imported_map.towns.begin(); tit != imported_map.towns.end();) {
+	if(house_import_type != IMPORT_DONT) {
+		for(TownMap::iterator tit = imported_map.towns.begin(); tit != imported_map.towns.end();) {
 			Town* imported_town = tit->second;
 			Town* current_town = map.towns.getTown(imported_town->getID());
 
 			Position oldexit = imported_town->getTemplePosition();
 			Position newexit = oldexit + offset;
-			if (newexit.isValid()) {
+			if(newexit.isValid()) {
 				imported_town->setTemplePosition(newexit);
 			}
 
-			switch (house_import_type) {
+			switch(house_import_type) {
 				case IMPORT_MERGE: {
 					town_id_map[imported_town->getID()] = imported_town->getID();
-					if (current_town) {
+					if(current_town) {
 						++tit;
 						continue;
 					}
 					break;
 				}
 				case IMPORT_SMART_MERGE: {
-					if (current_town) {
+					if(current_town) {
 						// Compare and insert/merge depending on parameters
-						if (current_town->getName() == imported_town->getName() && current_town->getID() == imported_town->getID()) {
+						if(current_town->getName() == imported_town->getName() && current_town->getID() == imported_town->getID()) {
 							// Just add to map
 							town_id_map[imported_town->getID()] = current_town->getID();
 							++tit;
@@ -543,11 +575,11 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 			TownMap::iterator tmp_iter = tit;
 			++tmp_iter;
 			uint32_t next_key = 0;
-			if (tmp_iter != imported_map.towns.end()) {
+			if(tmp_iter != imported_map.towns.end()) {
 				next_key = tmp_iter->first;
 			}
 			imported_map.towns.erase(tit);
-			if (next_key != 0) {
+			if(next_key != 0) {
 				tit = imported_map.towns.find(next_key);
 			} else {
 				tit = imported_map.towns.end();
@@ -555,38 +587,34 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 #endif
 		}
 
-		for (HouseMap::iterator hit = imported_map.houses.begin(); hit != imported_map.houses.end();) {
+		for(HouseMap::iterator hit = imported_map.houses.begin(); hit != imported_map.houses.end();) {
 			House* imported_house = hit->second;
 			House* current_house = map.houses.getHouse(imported_house->id);
 			imported_house->townid = town_id_map[imported_house->townid];
 
-			const Position &oldexit = imported_house->getExit();
+			const Position& oldexit = imported_house->getExit();
 			imported_house->setExit(nullptr, Position()); // Reset it
 
-			switch (house_import_type) {
+			switch(house_import_type) {
 				case IMPORT_MERGE: {
 					house_id_map[imported_house->id] = imported_house->id;
-					if (current_house) {
+					if(current_house) {
 						++hit;
 						Position newexit = oldexit + offset;
-						if (newexit.isValid()) {
-							current_house->setExit(&map, newexit);
-						}
+						if(newexit.isValid()) current_house->setExit(&map, newexit);
 						continue;
 					}
 					break;
 				}
 				case IMPORT_SMART_MERGE: {
-					if (current_house) {
+					if(current_house) {
 						// Compare and insert/merge depending on parameters
-						if (current_house->name == imported_house->name && current_house->townid == imported_house->townid) {
+						if(current_house->name == imported_house->name && current_house->townid == imported_house->townid) {
 							// Just add to map
 							house_id_map[imported_house->id] = current_house->id;
 							++hit;
 							Position newexit = oldexit + offset;
-							if (newexit.isValid()) {
-								imported_house->setExit(&map, newexit);
-							}
+							if(newexit.isValid()) imported_house->setExit(&map, newexit);
 							continue;
 						} else {
 							// Conflict! Find a newd id and replace old
@@ -609,18 +637,14 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 				case IMPORT_DONT: {
 					++hit;
 					Position newexit = oldexit + offset;
-					if (newexit.isValid()) {
-						imported_house->setExit(&map, newexit);
-					}
-					continue; // Should never happend..?
+					if(newexit.isValid()) imported_house->setExit(&map, newexit);
+						continue; // Should never happend..?
 					break;
 				}
 			}
 
 			Position newexit = oldexit + offset;
-			if (newexit.isValid()) {
-				imported_house->setExit(&map, newexit);
-			}
+			if(newexit.isValid()) imported_house->setExit(&map, newexit);
 			map.houses.addHouse(imported_house);
 
 #ifdef __VISUALC__ // C++0x compliance to some degree :)
@@ -629,11 +653,11 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 			HouseMap::iterator tmp_iter = hit;
 			++tmp_iter;
 			uint32_t next_key = 0;
-			if (tmp_iter != imported_map.houses.end()) {
+			if(tmp_iter != imported_map.houses.end()) {
 				next_key = tmp_iter->first;
 			}
 			imported_map.houses.erase(hit);
-			if (next_key != 0) {
+			if(next_key != 0) {
 				hit = imported_map.houses.find(next_key);
 			} else {
 				hit = imported_map.houses.end();
@@ -644,16 +668,16 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 
 	// Monster spawn import
 	std::map<Position, SpawnMonster*> spawn_monster_map;
-	if (spawn_import_type != IMPORT_DONT) {
-		for (SpawnNpcPositionList::iterator siter = imported_map.spawnsMonster.begin(); siter != imported_map.spawnsMonster.end();) {
+	if(spawn_import_type != IMPORT_DONT) {
+		for(SpawnNpcPositionList::iterator siter = imported_map.spawnsMonster.begin(); siter != imported_map.spawnsMonster.end();) {
 			Position oldSpawnMonsterPos = *siter;
 			Position newSpawnMonsterPos = *siter + offset;
-			switch (spawn_import_type) {
+			switch(spawn_import_type) {
 				case IMPORT_SMART_MERGE:
 				case IMPORT_INSERT:
 				case IMPORT_MERGE: {
 					Tile* imported_tile = imported_map.getTile(oldSpawnMonsterPos);
-					if (imported_tile) {
+					if(imported_tile) {
 						ASSERT(imported_tile->spawnMonster);
 						spawn_monster_map[newSpawnMonsterPos] = imported_tile->spawnMonster;
 
@@ -662,17 +686,15 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 						Position next_spawn_monster;
 
 						++next;
-						if (next == imported_map.spawnsMonster.end()) {
+						if(next == imported_map.spawnsMonster.end())
 							cont = false;
-						} else {
+						else
 							next_spawn_monster = *next;
-						}
 						imported_map.spawnsMonster.erase(siter);
-						if (cont) {
+						if(cont)
 							siter = imported_map.spawnsMonster.find(next_spawn_monster);
-						} else {
+						else
 							siter = imported_map.spawnsMonster.end();
-						}
 					}
 					break;
 				}
@@ -686,16 +708,16 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 
 	// Npc spawn import
 	std::map<Position, SpawnNpc*> spawn_npc_map;
-	if (spawn_npc_import_type != IMPORT_DONT) {
-		for (SpawnNpcPositionList::iterator siter = imported_map.spawnsNpc.begin(); siter != imported_map.spawnsNpc.end();) {
+	if(spawn_npc_import_type != IMPORT_DONT) {
+		for(SpawnNpcPositionList::iterator siter = imported_map.spawnsNpc.begin(); siter != imported_map.spawnsNpc.end();) {
 			Position oldSpawnNpcPos = *siter;
 			Position newSpawnNpcPos = *siter + offset;
-			switch (spawn_npc_import_type) {
+			switch(spawn_npc_import_type) {
 				case IMPORT_SMART_MERGE:
 				case IMPORT_INSERT:
 				case IMPORT_MERGE: {
 					Tile* importedTile = imported_map.getTile(oldSpawnNpcPos);
-					if (importedTile) {
+					if(importedTile) {
 						ASSERT(importedTile->spawnNpc);
 						spawn_npc_map[newSpawnNpcPos] = importedTile->spawnNpc;
 
@@ -704,17 +726,15 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 						Position next_spawn_npc;
 
 						++next;
-						if (next == imported_map.spawnsNpc.end()) {
+						if(next == imported_map.spawnsNpc.end())
 							cont = false;
-						} else {
+						else
 							next_spawn_npc = *next;
-						}
 						imported_map.spawnsNpc.erase(siter);
-						if (cont) {
+						if(cont)
 							siter = imported_map.spawnsNpc.find(next_spawn_npc);
-						} else {
+						else
 							siter = imported_map.spawnsNpc.end();
-						}
 					}
 					break;
 				}
@@ -727,37 +747,38 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 	}
 
 	// Plain merge of waypoints, very simple! :)
-	for (WaypointMap::iterator iter = imported_map.waypoints.begin(); iter != imported_map.waypoints.end(); ++iter) {
+	for(WaypointMap::iterator iter = imported_map.waypoints.begin(); iter != imported_map.waypoints.end(); ++iter) {
 		iter->second->pos += offset;
 	}
 
 	map.waypoints.waypoints.insert(imported_map.waypoints.begin(), imported_map.waypoints.end());
 	imported_map.waypoints.waypoints.clear();
 
+
 	uint64_t tiles_merged = 0;
 	uint64_t tiles_to_import = imported_map.tilecount;
-	for (MapIterator mit = imported_map.begin(); mit != imported_map.end(); ++mit) {
-		if (tiles_merged % 8092 == 0) {
+	for(MapIterator mit = imported_map.begin(); mit != imported_map.end(); ++mit) {
+		if(tiles_merged % 8092 == 0) {
 			g_gui.SetLoadDone(int(100.0 * tiles_merged / tiles_to_import));
 		}
 		++tiles_merged;
 
 		Tile* import_tile = (*mit)->get();
 		Position new_pos = import_tile->getPosition() + offset;
-		if (!new_pos.isValid()) {
+		if(!new_pos.isValid()) {
 			++discarded_tiles;
 			continue;
 		}
 
-		if (!resizemap && (new_pos.x > map.getWidth() || new_pos.y > map.getHeight())) {
-			if (resize_asked) {
+		if(!resizemap && (new_pos.x > map.getWidth() || new_pos.y > map.getHeight())) {
+			if(resize_asked) {
 				++discarded_tiles;
 				continue;
 			} else {
 				resize_asked = true;
 				int ret = g_gui.PopupDialog("Collision", "The imported tiles are outside the current map scope. Do you want to resize the map? (Else additional tiles will be removed)", wxYES | wxNO);
 
-				if (ret == wxID_YES) {
+				if(ret == wxID_YES) {
 					// ...
 					resizemap = true;
 				} else {
@@ -767,20 +788,21 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 			}
 		}
 
-		if (new_pos.x > newsize_x) {
+		if(new_pos.x > newsize_x) {
 			newsize_x = new_pos.x;
 		}
-		if (new_pos.y > newsize_y) {
+		if(new_pos.y > newsize_y) {
 			newsize_y = new_pos.y;
 		}
 
 		imported_map.setTile(import_tile->getPosition(), nullptr);
 		TileLocation* location = map.createTileL(new_pos);
 
+
 		// Check if we should update any houses
 		int new_houseid = house_id_map[import_tile->getHouseID()];
 		House* house = map.houses.getHouse(new_houseid);
-		if (import_tile->isHouseTile() && house_import_type != IMPORT_DONT && house) {
+		if(import_tile->isHouseTile() && house_import_type != IMPORT_DONT && house) {
 			// We need to notify houses of the tile moving
 			house->removeTile(import_tile);
 			import_tile->setLocation(location);
@@ -789,17 +811,17 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 			import_tile->setLocation(location);
 		}
 
-		if (offset != Position(0, 0, 0)) {
-			for (ItemVector::iterator iter = import_tile->items.begin(); iter != import_tile->items.end(); ++iter) {
+		if(offset != Position(0,0,0)) {
+			for(ItemVector::iterator iter = import_tile->items.begin(); iter != import_tile->items.end(); ++iter) {
 				Item* item = *iter;
-				if (Teleport* teleport = dynamic_cast<Teleport*>(item)) {
+				if(Teleport* teleport = dynamic_cast<Teleport*>(item)) {
 					teleport->setDestination(teleport->getDestination() + offset);
 				}
 			}
 		}
 
 		Tile* old_tile = map.getTile(new_pos);
-		if (old_tile) {
+		if(old_tile) {
 			map.removeSpawnMonster(old_tile);
 		}
 		import_tile->spawnMonster = nullptr;
@@ -807,14 +829,14 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 		map.setTile(new_pos, import_tile, true);
 	}
 
-	for (std::map<Position, SpawnMonster*>::iterator spawn_monster_iter = spawn_monster_map.begin(); spawn_monster_iter != spawn_monster_map.end(); ++spawn_monster_iter) {
+	for(std::map<Position, SpawnMonster*>::iterator spawn_monster_iter = spawn_monster_map.begin(); spawn_monster_iter != spawn_monster_map.end(); ++spawn_monster_iter) {
 		Position pos = spawn_monster_iter->first;
 		TileLocation* location = map.createTileL(pos);
 		Tile* tile = location->get();
-		if (!tile) {
+		if(!tile) {
 			tile = map.allocator(location);
 			map.setTile(pos, tile);
-		} else if (tile->spawnMonster) {
+		} else if(tile->spawnMonster) {
 			map.removeSpawnMonsterInternal(tile);
 			delete tile->spawnMonster;
 		}
@@ -823,14 +845,14 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 		map.addSpawnMonster(tile);
 	}
 
-	for (std::map<Position, SpawnNpc*>::iterator spawn_npc_iter = spawn_npc_map.begin(); spawn_npc_iter != spawn_npc_map.end(); ++spawn_npc_iter) {
+	for(std::map<Position, SpawnNpc*>::iterator spawn_npc_iter = spawn_npc_map.begin(); spawn_npc_iter != spawn_npc_map.end(); ++spawn_npc_iter) {
 		Position pos = spawn_npc_iter->first;
 		TileLocation* location = map.createTileL(pos);
 		Tile* tile = location->get();
-		if (!tile) {
+		if(!tile) {
 			tile = map.allocator(location);
 			map.setTile(pos, tile);
-		} else if (tile->spawnNpc) {
+		} else if(tile->spawnNpc) {
 			map.removeSpawnNpcInternal(tile);
 			delete tile->spawnNpc;
 		}
@@ -851,14 +873,15 @@ bool Editor::importMap(FileName filename, int import_x_offset, int import_y_offs
 	return true;
 }
 
-void Editor::borderizeSelection() {
-	if (selection.empty()) {
+void Editor::borderizeSelection()
+{
+	if(selection.empty()) {
 		g_gui.SetStatusText("No items selected. Can't borderize.");
 		return;
 	}
 
 	Action* action = actionQueue->createAction(ACTION_BORDERIZE);
-	for (const Tile* tile : selection) {
+	for(const Tile* tile : selection) {
 		Tile* new_tile = tile->deepCopy(map);
 		new_tile->borderize(&map);
 		new_tile->select();
@@ -868,14 +891,15 @@ void Editor::borderizeSelection() {
 	updateActions();
 }
 
-void Editor::borderizeMap(bool showdialog) {
-	if (showdialog) {
+void Editor::borderizeMap(bool showdialog)
+{
+	if(showdialog) {
 		g_gui.CreateLoadBar("Borderizing map...");
 	}
 
 	uint64_t tiles_done = 0;
-	for (TileLocation* tileLocation : map) {
-		if (showdialog && tiles_done % 4096 == 0) {
+	for(TileLocation* tileLocation : map) {
+		if(showdialog && tiles_done % 4096 == 0) {
 			g_gui.SetLoadDone(static_cast<int32_t>(tiles_done / double(map.tilecount) * 100.0));
 		}
 
@@ -886,27 +910,28 @@ void Editor::borderizeMap(bool showdialog) {
 		++tiles_done;
 	}
 
-	if (showdialog) {
+	if(showdialog) {
 		g_gui.DestroyLoadBar();
 	}
 }
 
-void Editor::randomizeSelection() {
-	if (selection.empty()) {
+void Editor::randomizeSelection()
+{
+	if(selection.empty()) {
 		g_gui.SetStatusText("No items selected. Can't randomize.");
 		return;
 	}
 
 	Action* action = actionQueue->createAction(ACTION_RANDOMIZE);
-	for (const Tile* tile : selection) {
+	for(const Tile* tile : selection) {
 		Tile* new_tile = tile->deepCopy(map);
 		GroundBrush* brush = new_tile->getGroundBrush();
-		if (brush && brush->isReRandomizable()) {
+		if(brush && brush->isReRandomizable()) {
 			brush->draw(&map, new_tile, nullptr);
 
 			Item* old_ground = tile->ground;
 			Item* new_ground = new_tile->ground;
-			if (old_ground && new_ground) {
+			if(old_ground && new_ground) {
 				new_ground->setActionID(old_ground->getActionID());
 				new_ground->setUniqueID(old_ground->getUniqueID());
 			}
@@ -919,14 +944,15 @@ void Editor::randomizeSelection() {
 	updateActions();
 }
 
-void Editor::randomizeMap(bool showdialog) {
-	if (showdialog) {
+void Editor::randomizeMap(bool showdialog)
+{
+	if(showdialog) {
 		g_gui.CreateLoadBar("Randomizing map...");
 	}
 
 	uint64_t tiles_done = 0;
-	for (TileLocation* tileLocation : map) {
-		if (showdialog && tiles_done % 4096 == 0) {
+	for(TileLocation* tileLocation : map) {
+		if(showdialog && tiles_done % 4096 == 0) {
 			g_gui.SetLoadDone(static_cast<int32_t>(tiles_done / double(map.tilecount) * 100.0));
 		}
 
@@ -934,11 +960,11 @@ void Editor::randomizeMap(bool showdialog) {
 		ASSERT(tile);
 
 		GroundBrush* groundBrush = tile->getGroundBrush();
-		if (groundBrush) {
+		if(groundBrush) {
 			Item* oldGround = tile->ground;
 
 			uint16_t actionId, uniqueId;
-			if (oldGround) {
+			if(oldGround) {
 				actionId = oldGround->getActionID();
 				uniqueId = oldGround->getUniqueID();
 			} else {
@@ -948,7 +974,7 @@ void Editor::randomizeMap(bool showdialog) {
 			groundBrush->draw(&map, tile, nullptr);
 
 			Item* newGround = tile->ground;
-			if (newGround) {
+			if(newGround) {
 				newGround->setActionID(actionId);
 				newGround->setUniqueID(uniqueId);
 			}
@@ -957,33 +983,34 @@ void Editor::randomizeMap(bool showdialog) {
 		++tiles_done;
 	}
 
-	if (showdialog) {
+	if(showdialog) {
 		g_gui.DestroyLoadBar();
 	}
 }
 
-void Editor::clearInvalidHouseTiles(bool showdialog) {
-	if (showdialog) {
+void Editor::clearInvalidHouseTiles(bool showdialog)
+{
+	if(showdialog) {
 		g_gui.CreateLoadBar("Clearing invalid house tiles...");
 	}
 
-	Houses &houses = map.houses;
+	Houses& houses = map.houses;
 
 	HouseMap::iterator iter = houses.begin();
-	while (iter != houses.end()) {
+	while(iter != houses.end()) {
 		House* h = iter->second;
-		if (map.towns.getTown(h->townid) == nullptr) {
+		if(map.towns.getTown(h->townid) == nullptr) {
 #ifdef __VISUALC__ // C++0x compliance to some degree :)
 			iter = houses.erase(iter);
 #else // Bulky, slow way
 			HouseMap::iterator tmp_iter = iter;
 			++tmp_iter;
 			uint32_t next_key = 0;
-			if (tmp_iter != houses.end()) {
+			if(tmp_iter != houses.end()) {
 				next_key = tmp_iter->first;
 			}
 			houses.erase(iter);
-			if (next_key != 0) {
+			if(next_key != 0) {
 				iter = houses.find(next_key);
 			} else {
 				iter = houses.end();
@@ -995,34 +1022,35 @@ void Editor::clearInvalidHouseTiles(bool showdialog) {
 	}
 
 	uint64_t tiles_done = 0;
-	for (MapIterator map_iter = map.begin(); map_iter != map.end(); ++map_iter) {
-		if (showdialog && tiles_done % 4096 == 0) {
+	for(MapIterator map_iter = map.begin(); map_iter != map.end(); ++map_iter) {
+		if(showdialog && tiles_done % 4096 == 0) {
 			g_gui.SetLoadDone(int(tiles_done / double(map.tilecount) * 100.0));
 		}
 
 		Tile* tile = (*map_iter)->get();
 		ASSERT(tile);
-		if (tile->isHouseTile()) {
-			if (houses.getHouse(tile->getHouseID()) == nullptr) {
+		if(tile->isHouseTile()) {
+			if(houses.getHouse(tile->getHouseID()) == nullptr) {
 				tile->setHouse(nullptr);
 			}
 		}
 		++tiles_done;
 	}
 
-	if (showdialog) {
+	if(showdialog) {
 		g_gui.DestroyLoadBar();
 	}
 }
 
-void Editor::clearModifiedTileState(bool showdialog) {
-	if (showdialog) {
+void Editor::clearModifiedTileState(bool showdialog)
+{
+	if(showdialog) {
 		g_gui.CreateLoadBar("Clearing modified state from all tiles...");
 	}
 
 	uint64_t tiles_done = 0;
-	for (MapIterator map_iter = map.begin(); map_iter != map.end(); ++map_iter) {
-		if (showdialog && tiles_done % 4096 == 0) {
+	for(MapIterator map_iter = map.begin(); map_iter != map.end(); ++map_iter) {
+		if(showdialog && tiles_done % 4096 == 0) {
 			g_gui.SetLoadDone(int(tiles_done / double(map.tilecount) * 100.0));
 		}
 
@@ -1032,13 +1060,14 @@ void Editor::clearModifiedTileState(bool showdialog) {
 		++tiles_done;
 	}
 
-	if (showdialog) {
+	if(showdialog) {
 		g_gui.DestroyLoadBar();
 	}
 }
 
-void Editor::moveSelection(const Position &offset) {
-	if (!CanEdit() || !hasSelection()) {
+void Editor::moveSelection(const Position& offset)
+{
+	if(!CanEdit() || !hasSelection()) {
 		return;
 	}
 
@@ -1052,37 +1081,37 @@ void Editor::moveSelection(const Position &offset) {
 	Action* action = actionQueue->createAction(batch_action);
 
 	// Update the tiles with the new positions
-	for (Tile* tile : selection) {
+	for(Tile* tile : selection) {
 		Tile* new_tile = tile->deepCopy(map);
 		Tile* storage_tile = map.allocator(tile->getLocation());
 
 		ItemVector selected_items = new_tile->popSelectedItems();
-		for (Item* item : selected_items) {
+		for(Item* item : selected_items) {
 			storage_tile->addItem(item);
 		}
 
 		// Move monster spawns
-		if (new_tile->spawnMonster && new_tile->spawnMonster->isSelected()) {
+		if(new_tile->spawnMonster && new_tile->spawnMonster->isSelected()) {
 			storage_tile->spawnMonster = new_tile->spawnMonster;
 			new_tile->spawnMonster = nullptr;
 		}
 		// Move monster
-		if (new_tile->monster && new_tile->monster->isSelected()) {
+		if(new_tile->monster && new_tile->monster->isSelected()) {
 			storage_tile->monster = new_tile->monster;
 			new_tile->monster = nullptr;
 		}
 		// Move npc
-		if (new_tile->npc && new_tile->npc->isSelected()) {
+		if(new_tile->npc && new_tile->npc->isSelected()) {
 			storage_tile->npc = new_tile->npc;
 			new_tile->npc = nullptr;
 		}
 		// Move npc spawns
-		if (new_tile->spawnNpc && new_tile->spawnNpc->isSelected()) {
+		if(new_tile->spawnNpc && new_tile->spawnNpc->isSelected()) {
 			storage_tile->spawnNpc = new_tile->spawnNpc;
 			new_tile->spawnNpc = nullptr;
 		}
 
-		if (storage_tile->ground) {
+		if(storage_tile->ground) {
 			storage_tile->house_id = new_tile->house_id;
 			new_tile->house_id = 0;
 			storage_tile->setMapFlags(new_tile->getMapFlags());
@@ -1096,50 +1125,23 @@ void Editor::moveSelection(const Position &offset) {
 	batch_action->addAndCommitAction(action);
 
 	// Remove old borders (and create some new?)
-	if (create_borders && selection.size() < static_cast<size_t>(drag_threshold)) {
+	if(create_borders && selection.size() < static_cast<size_t>(drag_threshold)) {
 		action = actionQueue->createAction(batch_action);
 		TileList borderize_tiles;
 		// Go through all modified (selected) tiles (might be slow)
-		for (const Tile* tile : storage) {
-			const Position &pos = tile->getPosition();
+		for(const Tile* tile : storage) {
+			const Position& pos = tile->getPosition();
 			// Go through all neighbours
 			Tile* t;
-			t = map.getTile(pos.x, pos.y, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x - 1, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x + 1, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x - 1, pos.y, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x + 1, pos.y, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x - 1, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
-			t = map.getTile(pos.x + 1, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-			}
+			t = map.getTile(pos.x  , pos.y  , pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x-1, pos.y-1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x  , pos.y-1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x+1, pos.y-1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x-1, pos.y  , pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x+1, pos.y  , pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x-1, pos.y+1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x  , pos.y+1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
+			t = map.getTile(pos.x+1, pos.y+1, pos.z); if(t && !t->isSelected()) {borderize_tiles.push_back(t);}
 		}
 
 		// Remove duplicates
@@ -1147,15 +1149,15 @@ void Editor::moveSelection(const Position &offset) {
 		borderize_tiles.unique();
 
 		// Create borders
-		for (const Tile* tile : borderize_tiles) {
+		for(const Tile* tile : borderize_tiles) {
 			Tile* new_tile = tile->deepCopy(map);
-			if (borderize) {
+			if(borderize) {
 				new_tile->borderize(&map);
 			}
 			new_tile->wallize(&map);
 			new_tile->tableize(&map);
 			new_tile->carpetize(&map);
-			if (tile->ground && tile->ground->isSelected()) {
+			if(tile->ground && tile->ground->isSelected()) {
 				new_tile->selectGround();
 			}
 			action->addChange(new Change(new_tile));
@@ -1165,10 +1167,10 @@ void Editor::moveSelection(const Position &offset) {
 
 	// New action for adding the destination tiles
 	action = actionQueue->createAction(batch_action);
-	for (Tile* tile : storage) {
-		const Position &old_pos = tile->getPosition();
+	for(Tile* tile : storage) {
+		const Position& old_pos = tile->getPosition();
 		Position new_pos = old_pos - offset;
-		if (new_pos.z < rme::MapMinLayer && new_pos.z > rme::MapMaxLayer) {
+		if(new_pos.z < rme::MapMinLayer && new_pos.z > rme::MapMaxLayer) {
 			delete tile;
 			continue;
 		}
@@ -1177,9 +1179,9 @@ void Editor::moveSelection(const Position &offset) {
 		Tile* old_dest_tile = location->get();
 		Tile* new_dest_tile = nullptr;
 
-		if (!tile->ground || g_settings.getInteger(Config::MERGE_MOVE)) {
+		if(!tile->ground || g_settings.getInteger(Config::MERGE_MOVE)) {
 			// Move items
-			if (old_dest_tile) {
+			if(old_dest_tile) {
 				new_dest_tile = old_dest_tile->deepCopy(map);
 			} else {
 				new_dest_tile = map.allocator(location);
@@ -1195,61 +1197,25 @@ void Editor::moveSelection(const Position &offset) {
 	}
 	batch_action->addAndCommitAction(action);
 
-	if (create_borders && selection.size() < static_cast<size_t>(drag_threshold)) {
+	if(create_borders && selection.size() < static_cast<size_t>(drag_threshold)) {
 		action = actionQueue->createAction(batch_action);
 		TileList borderize_tiles;
 		// Go through all modified (selected) tiles (might be slow)
-		for (Tile* tile : selection) {
+		for(Tile* tile : selection) {
 			bool add_me = false; // If this tile is touched
-			const Position &pos = tile->getPosition();
+			const Position& pos = tile->getPosition();
 			// Go through all neighbours
 			Tile* t;
-			t = map.getTile(pos.x - 1, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x - 1, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x + 1, pos.y - 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x - 1, pos.y, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x + 1, pos.y, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x - 1, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			t = map.getTile(pos.x + 1, pos.y + 1, pos.z);
-			if (t && !t->isSelected()) {
-				borderize_tiles.push_back(t);
-				add_me = true;
-			}
-			if (add_me) {
+			t = map.getTile(pos.x-1, pos.y-1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x-1, pos.y-1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x  , pos.y-1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x+1, pos.y-1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x-1, pos.y  , pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x+1, pos.y  , pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x-1, pos.y+1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x  , pos.y+1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			t = map.getTile(pos.x+1, pos.y+1, pos.z); if(t && !t->isSelected()) { borderize_tiles.push_back(t); add_me = true; }
+			if(add_me) {
 				borderize_tiles.push_back(tile);
 			}
 		}
@@ -1259,19 +1225,19 @@ void Editor::moveSelection(const Position &offset) {
 		borderize_tiles.unique();
 
 		// Create borders
-		for (const Tile* tile : borderize_tiles) {
-			if (!tile || !tile->ground) {
+		for(const Tile* tile : borderize_tiles) {
+			if(!tile || !tile->ground) {
 				continue;
 			}
-			if (tile->ground->getGroundBrush()) {
+			if(tile->ground->getGroundBrush()) {
 				Tile* new_tile = tile->deepCopy(map);
-				if (borderize) {
+				if(borderize) {
 					new_tile->borderize(&map);
 				}
 				new_tile->wallize(&map);
 				new_tile->tableize(&map);
 				new_tile->carpetize(&map);
-				if (tile->ground->isSelected()) {
+				if(tile->ground->isSelected()) {
 					new_tile->selectGround();
 				}
 				action->addChange(new Change(new_tile));
@@ -1286,8 +1252,9 @@ void Editor::moveSelection(const Position &offset) {
 	selection.updateSelectionCount();
 }
 
-void Editor::destroySelection() {
-	if (selection.size() == 0) {
+void Editor::destroySelection()
+{
+	if(selection.size() == 0) {
 		g_gui.SetStatusText("No selected items to delete.");
 	} else {
 		int tile_count = 0;
@@ -1297,43 +1264,43 @@ void Editor::destroySelection() {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DELETE_TILES);
 		Action* action = actionQueue->createAction(batch);
 
-		for (TileSet::iterator it = selection.begin(); it != selection.end(); ++it) {
+		for(TileSet::iterator it = selection.begin(); it != selection.end(); ++it) {
 			tile_count++;
 
 			Tile* tile = *it;
 			Tile* newtile = tile->deepCopy(map);
 
 			ItemVector tile_selection = newtile->popSelectedItems();
-			for (ItemVector::iterator iit = tile_selection.begin(); iit != tile_selection.end(); ++iit) {
+			for(ItemVector::iterator iit = tile_selection.begin(); iit != tile_selection.end(); ++iit) {
 				++item_count;
 				// Delete the items from the tile
 				delete *iit;
 			}
 			// Monster
-			if (newtile->monster && newtile->monster->isSelected()) {
+			if(newtile->monster && newtile->monster->isSelected()) {
 				delete newtile->monster;
 				newtile->monster = nullptr;
 			}
 
-			if (newtile->spawnMonster && newtile->spawnMonster->isSelected()) {
+			if(newtile->spawnMonster && newtile->spawnMonster->isSelected()) {
 				delete newtile->spawnMonster;
 				newtile->spawnMonster = nullptr;
 			}
 			// Npc
-			if (newtile->npc && newtile->npc->isSelected()) {
+			if(newtile->npc && newtile->npc->isSelected()) {
 				delete newtile->npc;
 				newtile->npc = nullptr;
 			}
 
-			if (newtile->spawnNpc && newtile->spawnNpc->isSelected()) {
+			if(newtile->spawnNpc && newtile->spawnNpc->isSelected()) {
 				delete newtile->spawnNpc;
 				newtile->spawnNpc = nullptr;
 			}
 
-			if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
-				for (int y = -1; y <= 1; y++) {
-					for (int x = -1; x <= 1; x++) {
-						const Position &position = tile->getPosition();
+			if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+				for(int y = -1; y <= 1; y++) {
+					for(int x = -1; x <= 1; x++) {
+						const Position& position = tile->getPosition();
 						tilestoborder.push_back(Position(position.x + x, position.y + y, position.z));
 					}
 				}
@@ -1343,17 +1310,17 @@ void Editor::destroySelection() {
 
 		batch->addAndCommitAction(action);
 
-		if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+		if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
 			// Remove duplicates
 			tilestoborder.sort();
 			tilestoborder.unique();
 
 			action = actionQueue->createAction(batch);
-			for (PositionList::iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+			for(PositionList::iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 				TileLocation* location = map.createTileL(*it);
 				Tile* tile = location->get();
 
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->borderize(&map);
 					new_tile->wallize(&map);
@@ -1363,7 +1330,7 @@ void Editor::destroySelection() {
 				} else {
 					Tile* new_tile = map.allocator(location);
 					new_tile->borderize(&map);
-					if (new_tile->size()) {
+					if(new_tile->size()) {
 						action->addChange(newd Change(new_tile));
 					} else {
 						delete new_tile;
@@ -1378,57 +1345,60 @@ void Editor::destroySelection() {
 		updateActions();
 
 		wxString ss;
-		ss << "Deleted " << tile_count << " tile" << (tile_count > 1 ? "s" : "") << " (" << item_count << " item" << (item_count > 1 ? "s" : "") << ")";
+		ss << "Deleted " << tile_count << " tile" << (tile_count > 1 ? "s" : "") <<  " (" << item_count << " item" << (item_count > 1? "s" : "") << ")";
 		g_gui.SetStatusText(ss);
 	}
 }
 
-// Macro to avoid useless code repetition
-void doSurroundingBorders(DoodadBrush* doodad_brush, PositionList &tilestoborder, Tile* buffer_tile, Tile* new_tile) {
-	if (doodad_brush->doNewBorders() && g_settings.getInteger(Config::USE_AUTOMAGIC)) {
-		const Position &position = new_tile->getPosition();
+	// Macro to avoid useless code repetition
+void doSurroundingBorders(DoodadBrush* doodad_brush, PositionList& tilestoborder, Tile* buffer_tile, Tile* new_tile)
+{
+	if(doodad_brush->doNewBorders() && g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+		const Position& position = new_tile->getPosition();
 		tilestoborder.push_back(Position(position));
-		if (buffer_tile->hasGround()) {
-			for (int y = -1; y <= 1; y++) {
-				for (int x = -1; x <= 1; x++) {
+		if(buffer_tile->hasGround()) {
+			for(int y = -1; y <= 1; y++) {
+				for(int x = -1; x <= 1; x++) {
 					tilestoborder.push_back(Position(position.x + x, position.y + y, position.z));
 				}
 			}
-		} else if (buffer_tile->hasWall()) {
-			tilestoborder.push_back(Position(position.x, position.y - 1, position.z));
-			tilestoborder.push_back(Position(position.x - 1, position.y, position.z));
-			tilestoborder.push_back(Position(position.x + 1, position.y, position.z));
-			tilestoborder.push_back(Position(position.x, position.y + 1, position.z));
+		} else if(buffer_tile->hasWall()) {
+			tilestoborder.push_back(Position(position.x, position.y-1, position.z));
+			tilestoborder.push_back(Position(position.x-1, position.y, position.z));
+			tilestoborder.push_back(Position(position.x+1, position.y, position.z));
+			tilestoborder.push_back(Position(position.x, position.y+1, position.z));
 		}
 	}
 }
 
-void removeDuplicateWalls(Tile* buffer, Tile* tile) {
+void removeDuplicateWalls(Tile* buffer, Tile* tile)
+{
 	if (!buffer || buffer->items.empty() || !tile || tile->items.empty()) {
 		return;
 	}
 
-	for (const Item* item : buffer->items) {
-		if (item) {
+	for(const Item* item : buffer->items) {
+		if(item) {
 			WallBrush* brush = item->getWallBrush();
-			if (brush) {
+			if(brush) {
 				tile->cleanWalls(brush);
 			}
 		}
 	}
 }
 
-void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
-	if (!CanEdit()) {
+void Editor::drawInternal(Position offset, bool alt, bool dodraw)
+{
+	if(!CanEdit()) {
 		return;
 	}
 
 	Brush* brush = g_gui.GetCurrentBrush();
-	if (!brush) {
+	if(!brush) {
 		return;
 	}
 
-	if (brush->isDoodad()) {
+	if(brush->isDoodad()) {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 		BaseMap* buffer_map = g_gui.doodad_buffer_map;
@@ -1436,10 +1406,10 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 		Position delta_pos = offset - Position(0x8000, 0x8000, 0x8);
 		PositionList tilestoborder;
 
-		for (MapIterator it = buffer_map->begin(); it != buffer_map->end(); ++it) {
+		for(MapIterator it = buffer_map->begin(); it != buffer_map->end(); ++it) {
 			Tile* buffer_tile = (*it)->get();
 			Position pos = buffer_tile->getPosition() + delta_pos;
-			if (!pos.isValid()) {
+			if(!pos.isValid()) {
 				continue;
 			}
 
@@ -1447,18 +1417,18 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 			Tile* tile = location->get();
 			DoodadBrush* doodad_brush = brush->asDoodad();
 
-			if (doodad_brush->placeOnBlocking() || alt) {
-				if (tile) {
+			if(doodad_brush->placeOnBlocking() || alt) {
+				if(tile) {
 					bool place = true;
-					if (!doodad_brush->placeOnDuplicate() && !alt) {
-						for (ItemVector::const_iterator iter = tile->items.begin(); iter != tile->items.end(); ++iter) {
-							if (doodad_brush->ownsItem(*iter)) {
+					if(!doodad_brush->placeOnDuplicate() && !alt) {
+						for(ItemVector::const_iterator iter = tile->items.begin(); iter != tile->items.end(); ++iter) {
+							if(doodad_brush->ownsItem(*iter)) {
 								place = false;
 								break;
 							}
 						}
 					}
-					if (place) {
+					if(place) {
 						Tile* new_tile = tile->deepCopy(map);
 						removeDuplicateWalls(buffer_tile, new_tile);
 						doSurroundingBorders(doodad_brush, tilestoborder, buffer_tile, new_tile);
@@ -1473,17 +1443,17 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 					action->addChange(newd Change(new_tile));
 				}
 			} else {
-				if (tile && !tile->isBlocking()) {
+				if(tile && !tile->isBlocking()) {
 					bool place = true;
-					if (!doodad_brush->placeOnDuplicate() && !alt) {
-						for (ItemVector::const_iterator iter = tile->items.begin(); iter != tile->items.end(); ++iter) {
-							if (doodad_brush->ownsItem(*iter)) {
+					if(!doodad_brush->placeOnDuplicate() && !alt) {
+						for(ItemVector::const_iterator iter = tile->items.begin(); iter != tile->items.end(); ++iter) {
+							if(doodad_brush->ownsItem(*iter)) {
 								place = false;
 								break;
 							}
 						}
 					}
-					if (place) {
+					if(place) {
 						Tile* new_tile = tile->deepCopy(map);
 						removeDuplicateWalls(buffer_tile, new_tile);
 						doSurroundingBorders(doodad_brush, tilestoborder, buffer_tile, new_tile);
@@ -1495,16 +1465,16 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 		}
 		batch->addAndCommitAction(action);
 
-		if (tilestoborder.size() > 0) {
+		if(tilestoborder.size() > 0) {
 			Action* action = actionQueue->createAction(batch);
 
 			// Remove duplicates
 			tilestoborder.sort();
 			tilestoborder.unique();
 
-			for (PositionList::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+			for(PositionList::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 				Tile* tile = map.getTile(*it);
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->borderize(&map);
 					new_tile->wallize(&map);
@@ -1514,51 +1484,47 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 			batch->addAndCommitAction(action);
 		}
 		addBatch(batch, 2);
-	} else if (brush->isHouseExit()) {
+	} else if(brush->isHouseExit()) {
 		HouseExitBrush* house_exit_brush = brush->asHouseExit();
-		if (!house_exit_brush->canDraw(&map, offset)) {
+		if(!house_exit_brush->canDraw(&map, offset))
 			return;
-		}
 
 		House* house = map.houses.getHouse(house_exit_brush->getHouseID());
-		if (!house) {
+		if(!house)
 			return;
-		}
 
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 		action->addChange(Change::Create(house, offset));
 		batch->addAndCommitAction(action);
 		addBatch(batch, 2);
-	} else if (brush->isWaypoint()) {
+	} else if(brush->isWaypoint()) {
 		WaypointBrush* waypoint_brush = brush->asWaypoint();
-		if (!waypoint_brush->canDraw(&map, offset)) {
+		if(!waypoint_brush->canDraw(&map, offset))
 			return;
-		}
 
 		Waypoint* waypoint = map.waypoints.getWaypoint(waypoint_brush->getWaypoint());
-		if (!waypoint || waypoint->pos == offset) {
+		if(!waypoint || waypoint->pos == offset)
 			return;
-		}
 
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 		action->addChange(Change::Create(waypoint, offset));
 		batch->addAndCommitAction(action);
 		addBatch(batch, 2);
-	} else if (brush->isWall()) {
+	} else if(brush->isWall()) {
 		BatchAction* batch = actionQueue->createBatch(dodraw ? ACTION_DRAW : ACTION_ERASE);
 		Action* action = actionQueue->createAction(batch);
 		// This will only occur with a size 0, when clicking on a tile (not drawing)
 		Tile* tile = map.getTile(offset);
 		Tile* new_tile = nullptr;
-		if (tile) {
+		if(tile) {
 			new_tile = tile->deepCopy(map);
 		} else {
 			new_tile = map.allocator(map.createTileL(offset));
 		}
 
-		if (dodraw) {
+		if(dodraw) {
 			bool b = true;
 			brush->asWall()->draw(&map, new_tile, &b);
 		} else {
@@ -1567,24 +1533,24 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 		action->addChange(newd Change(new_tile));
 		batch->addAndCommitAction(action);
 		addBatch(batch, 2);
-	} else if (brush->isSpawnMonster() || brush->isMonster()) {
+	} else if(brush->isSpawnMonster() || brush->isMonster()) {
 		BatchAction* batch = actionQueue->createBatch(dodraw ? ACTION_DRAW : ACTION_ERASE);
 		Action* action = actionQueue->createAction(batch);
 
 		Tile* tile = map.getTile(offset);
 		Tile* new_tile = nullptr;
-		if (tile) {
+		if(tile) {
 			new_tile = tile->deepCopy(map);
 		} else {
 			new_tile = map.allocator(map.createTileL(offset));
 		}
 		int param;
-		if (brush->isMonster()) {
+		if(brush->isMonster()) {
 			param = g_gui.GetSpawnMonsterTime();
 		} else {
 			param = g_gui.GetBrushSize();
 		}
-		if (dodraw) {
+		if(dodraw) {
 			brush->draw(&map, new_tile, &param);
 		} else {
 			brush->undraw(&map, new_tile);
@@ -1592,24 +1558,24 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 		action->addChange(newd Change(new_tile));
 		batch->addAndCommitAction(action);
 		addBatch(batch, 2);
-	} else if (brush->isSpawnNpc() || brush->isNpc()) {
+	} else if(brush->isSpawnNpc() || brush->isNpc()) {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 
 		Tile* tile = map.getTile(offset);
 		Tile* new_tile = nullptr;
-		if (tile) {
+		if(tile) {
 			new_tile = tile->deepCopy(map);
 		} else {
 			new_tile = map.allocator(map.createTileL(offset));
 		}
 		int param;
-		if (brush->isNpc()) {
+		if(brush->isNpc()) {
 			param = g_gui.GetSpawnNpcTime();
 		} else {
 			param = g_gui.GetBrushSize();
 		}
-		if (dodraw) {
+		if(dodraw) {
 			brush->draw(&map, new_tile, &param);
 		} else {
 			brush->undraw(&map, new_tile);
@@ -1620,18 +1586,19 @@ void Editor::drawInternal(Position offset, bool alt, bool dodraw) {
 	}
 }
 
-void Editor::drawInternal(const PositionVector &tilestodraw, bool alt, bool dodraw) {
-	if (!CanEdit()) {
+void Editor::drawInternal(const PositionVector& tilestodraw, bool alt, bool dodraw)
+{
+	if(!CanEdit()) {
 		return;
 	}
 
 	Brush* brush = g_gui.GetCurrentBrush();
-	if (!brush) {
+	if(!brush) {
 		return;
 	}
 
 #ifdef __DEBUG__
-	if (brush->isGround() || brush->isWall()) {
+	if(brush->isGround() || brush->isWall()) {
 		// Wrong function, end call
 		return;
 	}
@@ -1639,28 +1606,28 @@ void Editor::drawInternal(const PositionVector &tilestodraw, bool alt, bool dodr
 
 	Action* action = actionQueue->createAction(dodraw ? ACTION_DRAW : ACTION_ERASE);
 
-	if (brush->isOptionalBorder()) {
+	if(brush->isOptionalBorder()) {
 		// We actually need to do borders, but on the same tiles we draw to
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
-				if (dodraw) {
+			if(tile) {
+				if(dodraw) {
 					Tile* new_tile = tile->deepCopy(map);
 					brush->draw(&map, new_tile);
 					new_tile->borderize(&map);
 					action->addChange(newd Change(new_tile));
-				} else if (!dodraw && tile->hasOptionalBorder()) {
+				} else if(!dodraw && tile->hasOptionalBorder()) {
 					Tile* new_tile = tile->deepCopy(map);
 					brush->undraw(&map, new_tile);
 					new_tile->borderize(&map);
 					action->addChange(newd Change(new_tile));
 				}
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
 				brush->draw(&map, new_tile);
 				new_tile->borderize(&map);
-				if (new_tile->size() == 0) {
+				if(new_tile->size() == 0) {
 					delete new_tile;
 					continue;
 				}
@@ -1669,18 +1636,18 @@ void Editor::drawInternal(const PositionVector &tilestodraw, bool alt, bool dodr
 		}
 	} else {
 
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
+			if(tile) {
 				Tile* new_tile = tile->deepCopy(map);
-				if (dodraw) {
+				if(dodraw) {
 					brush->draw(&map, new_tile, &alt);
 				} else {
 					brush->undraw(&map, new_tile);
 				}
 				action->addChange(newd Change(new_tile));
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
 				brush->draw(&map, new_tile, &alt);
 				action->addChange(newd Change(new_tile));
@@ -1690,33 +1657,34 @@ void Editor::drawInternal(const PositionVector &tilestodraw, bool alt, bool dodr
 	addAction(action, 2);
 }
 
-void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &tilestoborder, bool alt, bool dodraw) {
-	if (!CanEdit()) {
+void Editor::drawInternal(const PositionVector& tilestodraw, PositionVector& tilestoborder, bool alt, bool dodraw)
+{
+	if(!CanEdit()) {
 		return;
 	}
 
 	Brush* brush = g_gui.GetCurrentBrush();
-	if (!brush) {
+	if(!brush) {
 		return;
 	}
 
-	if (brush->isGround() || brush->isEraser()) {
+	if(brush->isGround() || brush->isEraser()) {
 		ActionIdentifier identifier = (dodraw && !brush->isEraser()) ? ACTION_DRAW : ACTION_ERASE;
 		BatchAction* batch = actionQueue->createBatch(identifier);
 		Action* action = actionQueue->createAction(batch);
 
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
+			if(tile) {
 				Tile* new_tile = tile->deepCopy(map);
-				if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+				if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
 					new_tile->cleanBorders();
 				}
-				if (dodraw) {
-					if (brush->isGround() && alt) {
+				if(dodraw)
+					if(brush->isGround() && alt) {
 						std::pair<bool, GroundBrush*> param;
-						if (replace_brush) {
+						if(replace_brush) {
 							param.first = false;
 							param.second = replace_brush;
 						} else {
@@ -1727,16 +1695,16 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 					} else {
 						g_gui.GetCurrentBrush()->draw(&map, new_tile, nullptr);
 					}
-				} else {
+				else {
 					g_gui.GetCurrentBrush()->undraw(&map, new_tile);
 					tilestoborder.push_back(*it);
 				}
 				action->addChange(newd Change(new_tile));
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
-				if (brush->isGround() && alt) {
+				if(brush->isGround() && alt) {
 					std::pair<bool, GroundBrush*> param;
-					if (replace_brush) {
+					if(replace_brush) {
 						param.first = false;
 						param.second = replace_brush;
 					} else {
@@ -1754,15 +1722,15 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		// Commit changes to map
 		batch->addAndCommitAction(action);
 
-		if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+		if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
 			// Do borders!
 			action = actionQueue->createAction(batch);
-			for (PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+			for(PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 				TileLocation* location = map.createTileL(*it);
 				Tile* tile = location->get();
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
-					if (brush->isEraser()) {
+					if(brush->isEraser()) {
 						new_tile->wallize(&map);
 						new_tile->tableize(&map);
 						new_tile->carpetize(&map);
@@ -1771,14 +1739,14 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 					action->addChange(newd Change(new_tile));
 				} else {
 					Tile* new_tile = map.allocator(location);
-					if (brush->isEraser()) {
+					if(brush->isEraser()) {
 						// There are no carpets/tables/walls on empty tiles...
-						// new_tile->wallize(map);
-						// new_tile->tableize(map);
-						// new_tile->carpetize(map);
+						//new_tile->wallize(map);
+						//new_tile->tableize(map);
+						//new_tile->carpetize(map);
 					}
 					new_tile->borderize(&map);
-					if (new_tile->size() > 0) {
+					if(new_tile->size() > 0) {
 						action->addChange(newd Change(new_tile));
 					} else {
 						delete new_tile;
@@ -1789,22 +1757,21 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		}
 
 		addBatch(batch, 2);
-	} else if (brush->isTable() || brush->isCarpet()) {
+	} else if(brush->isTable() || brush->isCarpet()) {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
+			if(tile) {
 				Tile* new_tile = tile->deepCopy(map);
-				if (dodraw) {
+				if(dodraw)
 					g_gui.GetCurrentBrush()->draw(&map, new_tile, nullptr);
-				} else {
+				else
 					g_gui.GetCurrentBrush()->undraw(&map, new_tile);
-				}
 				action->addChange(newd Change(new_tile));
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
 				g_gui.GetCurrentBrush()->draw(&map, new_tile, nullptr);
 				action->addChange(newd Change(new_tile));
@@ -1816,16 +1783,16 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 
 		// Do borders!
 		action = actionQueue->createAction(batch);
-		for (PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 			Tile* tile = map.getTile(*it);
-			if (brush->isTable()) {
-				if (tile && tile->hasTable()) {
+			if(brush->isTable()) {
+				if(tile && tile->hasTable()) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->tableize(&map);
 					action->addChange(newd Change(new_tile));
 				}
-			} else if (brush->isCarpet()) {
-				if (tile && tile->hasCarpet()) {
+			} else if(brush->isCarpet()) {
+				if(tile && tile->hasCarpet()) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->carpetize(&map);
 					action->addChange(newd Change(new_tile));
@@ -1835,33 +1802,33 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		batch->addAndCommitAction(action);
 
 		addBatch(batch, 2);
-	} else if (brush->isWall()) {
+	} else if(brush->isWall()) {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 
-		if (alt && dodraw) {
+		if(alt && dodraw) {
 			// This is exempt from USE_AUTOMAGIC
 			g_gui.doodad_buffer_map->clear();
 			BaseMap* draw_map = g_gui.doodad_buffer_map;
 
-			for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+			for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 				TileLocation* location = map.createTileL(*it);
 				Tile* tile = location->get();
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->cleanWalls(brush->isWall());
 					g_gui.GetCurrentBrush()->draw(draw_map, new_tile);
 					draw_map->setTile(*it, new_tile, true);
-				} else if (dodraw) {
+				} else if(dodraw) {
 					Tile* new_tile = map.allocator(location);
 					g_gui.GetCurrentBrush()->draw(draw_map, new_tile);
 					draw_map->setTile(*it, new_tile, true);
 				}
 			}
-			for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+			for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 				// Get the correct tiles from the draw map instead of the editor map
 				Tile* tile = draw_map->getTile(*it);
-				if (tile) {
+				if(tile) {
 					tile->wallize(draw_map);
 					action->addChange(newd Change(tile));
 				}
@@ -1870,20 +1837,19 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 			// Commit
 			batch->addAndCommitAction(action);
 		} else {
-			for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+			for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 				TileLocation* location = map.createTileL(*it);
 				Tile* tile = location->get();
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
 					// Wall cleaning is exempt from automagic
 					new_tile->cleanWalls(brush->isWall());
-					if (dodraw) {
+					if(dodraw)
 						g_gui.GetCurrentBrush()->draw(&map, new_tile);
-					} else {
+					else
 						g_gui.GetCurrentBrush()->undraw(&map, new_tile);
-					}
 					action->addChange(newd Change(new_tile));
-				} else if (dodraw) {
+				} else if(dodraw) {
 					Tile* new_tile = map.allocator(location);
 					g_gui.GetCurrentBrush()->draw(&map, new_tile);
 					action->addChange(newd Change(new_tile));
@@ -1893,15 +1859,15 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 			// Commit changes to map
 			batch->addAndCommitAction(action);
 
-			if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+			if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
 				// Do borders!
 				action = actionQueue->createAction(batch);
-				for (PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+				for(PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 					Tile* tile = map.getTile(*it);
-					if (tile) {
+					if(tile) {
 						Tile* new_tile = tile->deepCopy(map);
 						new_tile->wallize(&map);
-						// if(*tile == *new_tile) delete new_tile;
+						//if(*tile == *new_tile) delete new_tile;
 						action->addChange(newd Change(new_tile));
 					}
 				}
@@ -1910,28 +1876,26 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		}
 
 		actionQueue->addBatch(batch, 2);
-	} else if (brush->isDoor()) {
+	} else if(brush->isDoor()) {
 		BatchAction* batch = actionQueue->createBatch(ACTION_DRAW);
 		Action* action = actionQueue->createAction(batch);
 		DoorBrush* door_brush = brush->asDoor();
 
 		// Loop is kind of redundant since there will only ever be one index.
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
+			if(tile) {
 				Tile* new_tile = tile->deepCopy(map);
 				// Wall cleaning is exempt from automagic
-				if (brush->isWall()) {
+				if(brush->isWall())
 					new_tile->cleanWalls(brush->asWall());
-				}
-				if (dodraw) {
+				if(dodraw)
 					door_brush->draw(&map, new_tile, &alt);
-				} else {
+				else
 					door_brush->undraw(&map, new_tile);
-				}
 				action->addChange(newd Change(new_tile));
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
 				door_brush->draw(&map, new_tile, &alt);
 				action->addChange(newd Change(new_tile));
@@ -1941,15 +1905,15 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		// Commit changes to map
 		batch->addAndCommitAction(action);
 
-		if (g_settings.getInteger(Config::USE_AUTOMAGIC)) {
+		if(g_settings.getInteger(Config::USE_AUTOMAGIC)) {
 			// Do borders!
 			action = actionQueue->createAction(batch);
-			for (PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
+			for(PositionVector::const_iterator it = tilestoborder.begin(); it != tilestoborder.end(); ++it) {
 				Tile* tile = map.getTile(*it);
-				if (tile) {
+				if(tile) {
 					Tile* new_tile = tile->deepCopy(map);
 					new_tile->wallize(&map);
-					// if(*tile == *new_tile) delete new_tile;
+					//if(*tile == *new_tile) delete new_tile;
 					action->addChange(newd Change(new_tile));
 				}
 			}
@@ -1959,18 +1923,17 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 		addBatch(batch, 2);
 	} else {
 		Action* action = actionQueue->createAction(ACTION_DRAW);
-		for (PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
+		for(PositionVector::const_iterator it = tilestodraw.begin(); it != tilestodraw.end(); ++it) {
 			TileLocation* location = map.createTileL(*it);
 			Tile* tile = location->get();
-			if (tile) {
+			if(tile) {
 				Tile* new_tile = tile->deepCopy(map);
-				if (dodraw) {
+				if(dodraw)
 					g_gui.GetCurrentBrush()->draw(&map, new_tile);
-				} else {
+				else
 					g_gui.GetCurrentBrush()->undraw(&map, new_tile);
-				}
 				action->addChange(newd Change(new_tile));
-			} else if (dodraw) {
+			} else if(dodraw) {
 				Tile* new_tile = map.allocator(location);
 				g_gui.GetCurrentBrush()->draw(&map, new_tile);
 				action->addChange(newd Change(new_tile));
@@ -1983,38 +1946,45 @@ void Editor::drawInternal(const PositionVector &tilestodraw, PositionVector &til
 ///////////////////////////////////////////////////////////////////////////////
 // Live!
 
-bool Editor::IsLiveClient() const {
+bool Editor::IsLiveClient() const
+{
 	return live_client != nullptr;
 }
 
-bool Editor::IsLiveServer() const {
+bool Editor::IsLiveServer() const
+{
 	return live_server != nullptr;
 }
 
-bool Editor::IsLive() const {
+bool Editor::IsLive() const
+{
 	return IsLiveClient() || IsLiveServer();
 }
 
-bool Editor::IsLocal() const {
+bool Editor::IsLocal() const
+{
 	return !IsLive();
 }
 
-LiveClient* Editor::GetLiveClient() const {
+LiveClient* Editor::GetLiveClient() const
+{
 	return live_client;
 }
 
-LiveServer* Editor::GetLiveServer() const {
+LiveServer* Editor::GetLiveServer() const
+{
 	return live_server;
 }
 
-LiveSocket &Editor::GetLive() const {
-	if (live_server) {
+LiveSocket& Editor::GetLive() const
+{
+	if(live_server)
 		return *live_server;
-	}
 	return *live_client;
 }
 
-LiveServer* Editor::StartLiveServer() {
+LiveServer* Editor::StartLiveServer()
+{
 	ASSERT(IsLocal());
 	live_server = newd LiveServer(*this);
 
@@ -2024,24 +1994,26 @@ LiveServer* Editor::StartLiveServer() {
 	return live_server;
 }
 
-void Editor::BroadcastNodes(DirtyList &dirtyList) {
-	if (IsLiveClient()) {
+void Editor::BroadcastNodes(DirtyList& dirtyList)
+{
+	if(IsLiveClient()) {
 		live_client->sendChanges(dirtyList);
 	} else {
 		live_server->broadcastNodes(dirtyList);
 	}
 }
 
-void Editor::CloseLiveServer() {
+void Editor::CloseLiveServer()
+{
 	ASSERT(IsLive());
-	if (live_client) {
+	if(live_client) {
 		live_client->close();
 
 		delete live_client;
 		live_client = nullptr;
 	}
 
-	if (live_server) {
+	if(live_server) {
 		live_server->close();
 
 		delete live_server;
@@ -2051,17 +2023,20 @@ void Editor::CloseLiveServer() {
 		actionQueue = newd ActionQueue(*this);
 	}
 
-	NetworkConnection &connection = NetworkConnection::getInstance();
+	NetworkConnection& connection = NetworkConnection::getInstance();
 	connection.stop();
 }
 
-void Editor::QueryNode(int ndx, int ndy, bool underground) {
+void Editor::QueryNode(int ndx, int ndy, bool underground)
+{
 	ASSERT(live_client);
 	live_client->queryNode(ndx, ndy, underground);
 }
 
-void Editor::SendNodeRequests() {
-	if (live_client) {
+void Editor::SendNodeRequests()
+{
+	if(live_client) {
 		live_client->sendNodeRequests();
 	}
 }
+
diff --git a/source/graphics.h b/source/graphics.h
index 6703c3c2..4c6a3a22 100644
--- a/source/graphics.h
+++ b/source/graphics.h
@@ -53,6 +53,7 @@ struct SpriteLight {
 class Sprite {
 public:
 	Sprite() { }
+	virtual ~Sprite() { }
 
 	virtual void DrawTo(wxDC* dc, SpriteSize sz, int start_x, int start_y, int width = -1, int height = -1) = 0;
 	virtual void unloadDC() = 0;
diff --git a/source/gui.h b/source/gui.h
index fdb32570..9ed11227 100644
--- a/source/gui.h
+++ b/source/gui.h
@@ -29,6 +29,7 @@
 #include "map_tab.h"
 #include "palette_window.h"
 #include "client_version.h"
+#include "zone_brush.h"
 
 class BaseMap;
 class Map;
@@ -443,6 +444,7 @@ class GUI {
 	FlagBrush* rook_brush;
 	FlagBrush* nolog_brush;
 	FlagBrush* pvp_brush;
+	ZoneBrush* zone_brush;
 
 protected:
 	//=========================================================================
diff --git a/source/gui_ids.h b/source/gui_ids.h
index 141a27aa..c413540a 100644
--- a/source/gui_ids.h
+++ b/source/gui_ids.h
@@ -111,6 +111,10 @@ enum EditorActionID {
 	PALETTE_WAYPOINT_ADD_WAYPOINT,
 	PALETTE_WAYPOINT_REMOVE_WAYPOINT,
 
+	PALETTE_ZONES_LISTBOX,
+	PALETTE_ZONES_ADD_ZONE,
+	PALETTE_ZONES_REMOVE_ZONE,
+
 	PALETTE_DOODAD_USE_THICKNESS,
 	PALETTE_DOODAD_SLIDER,
 	PALETTE_BRUSHSHAPE_SQUARE,
@@ -122,13 +126,16 @@ enum EditorActionID {
 	PALETTE_TERRAIN_NOPVP_TOOL,
 	PALETTE_TERRAIN_NOLOGOUT_TOOL,
 	PALETTE_TERRAIN_PVPZONE_TOOL,
+	PALETTE_TERRAIN_ZONE_TOOL,
 
 	PALETTE_MONSTER_TILESET_CHOICE,
 	PALETTE_MONSTER_LISTBOX,
+	PALETTE_MONSTER_SEARCH,
 	PALETTE_MONSTER_BRUSH_BUTTON,
 	PALETTE_SPAWN_MONSTER_BRUSH_BUTTON,
 	PALETTE_MONSTER_SPAWN_TIME,
 	PALETTE_MONSTER_SPAWN_SIZE,
+	PALETTE_MONSTER_SPAWN_DENSITY,
 
 	PALETTE_NPC_TILESET_CHOICE,
 	PALETTE_NPC_LISTBOX,
diff --git a/source/iomap_otbm.cpp b/source/iomap_otbm.cpp
index f4fed184..afb8a2ea 100644
--- a/source/iomap_otbm.cpp
+++ b/source/iomap_otbm.cpp
@@ -632,6 +632,10 @@ bool IOMapOTBM::loadMap(Map &map, const FileName &filename) {
 		warning("Failed to load houses.");
 		map.housefile = nstr(filename.GetName()) + "-house.xml";
 	}
+	if (!loadZones(map, filename)) {
+		warning("Failed to load zones.");
+		map.zonefile = nstr(filename.GetName()) + "-zones.xml";
+	}
 	if (!loadSpawnsMonster(map, filename)) {
 		warning("Failed to load monsters spawns.");
 		map.spawnmonsterfile = nstr(filename.GetName()) + "-monster.xml";
@@ -730,6 +734,12 @@ bool IOMapOTBM::loadMap(Map &map, NodeFileReadHandle &f) {
 				}
 				break;
 			}
+			case OTBM_ATTR_EXT_ZONE_FILE: {
+				if (!mapHeaderNode->getString(map.zonefile)) {
+					warning("Invalid map zonefile tag");
+				}
+				break;
+			}
 			case OTBM_ATTR_EXT_SPAWN_NPC_FILE: {
 				if (!mapHeaderNode->getString(map.spawnnpcfile)) {
 					warning("Invalid map spawnnpcfile tag");
@@ -835,22 +845,36 @@ bool IOMapOTBM::loadMap(Map &map, NodeFileReadHandle &f) {
 
 					// printf("Didn't die in loop\n");
 
-					for (BinaryNode* itemNode = tileNode->getChild(); itemNode != nullptr; itemNode = itemNode->advance()) {
+					for (BinaryNode* childNode = tileNode->getChild(); childNode != nullptr; childNode = childNode->advance()) {
 						Item* item = nullptr;
-						uint8_t item_type;
-						if (!itemNode->getByte(item_type)) {
+						uint8_t node_type;
+						if (!childNode->getByte(node_type)) {
 							warning("Unknown item type %d:%d:%d", pos.x, pos.y, pos.z);
 							continue;
 						}
-						if (item_type == OTBM_ITEM) {
-							item = Item::Create_OTBM(*this, itemNode);
+						if (node_type == OTBM_ITEM) {
+							item = Item::Create_OTBM(*this, childNode);
 							if (item) {
-								if (!item->unserializeItemNode_OTBM(*this, itemNode)) {
+								if (!item->unserializeItemNode_OTBM(*this, childNode)) {
 									warning("Couldn't unserialize item attributes at %d:%d:%d", pos.x, pos.y, pos.z);
 								}
 								// reform(&map, tile, item);
 								tile->addItem(item);
 							}
+						} else if (node_type == OTBM_TILE_ZONE) {
+							uint16_t zone_count;
+							if (!childNode->getU16(zone_count)) {
+								warning("Invalid zone count at %d:%d:%d", pos.x, pos.y, pos.z);
+								continue;
+							}
+							for (uint16_t i = 0; i < zone_count; ++i) {
+								uint16_t zone_id;
+								if (!childNode->getU16(zone_id)) {
+									warning("Invalid zone id at %d:%d:%d", pos.x, pos.y, pos.z);
+									continue;
+								}
+								tile->addZone(zone_id);
+							}
 						} else {
 							warning("Unknown type of tile child node");
 						}
@@ -1177,6 +1201,41 @@ bool IOMapOTBM::loadHouses(Map &map, pugi::xml_document &doc) {
 	}
 	return true;
 }
+bool IOMapOTBM::loadZones(Map &map, const FileName &dir) {
+	std::string fn = (const char*)(dir.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).mb_str(wxConvUTF8));
+	fn += map.zonefile;
+	FileName filename(wxstr(fn));
+	if (!filename.FileExists()) {
+		return false;
+	}
+
+	pugi::xml_document doc;
+	pugi::xml_parse_result result = doc.load_file(fn.c_str());
+	if (!result) {
+		return false;
+	}
+	return loadZones(map, doc);
+}
+
+bool IOMapOTBM::loadZones(Map &map, pugi::xml_document &doc) {
+	pugi::xml_node node = doc.child("zones");
+	if (!node) {
+		warnings.push_back("IOMapOTBM::loadZones: Invalid rootheader.");
+		return false;
+	}
+
+	pugi::xml_attribute attribute;
+	for (pugi::xml_node zoneNode = node.first_child(); zoneNode; zoneNode = zoneNode.next_sibling()) {
+		if (as_lower_str(zoneNode.name()) != "zone") {
+			continue;
+		}
+
+		std::string name = zoneNode.attribute("name").as_string();
+		unsigned int id = zoneNode.attribute("zoneid").as_uint();
+		map.zones.addZone(name, id);
+	}
+	return true;
+}
 
 bool IOMapOTBM::loadSpawnsNpc(Map &map, const FileName &dir) {
 	std::string fn = (const char*)(dir.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME).mb_str(wxConvUTF8));
@@ -1460,6 +1519,9 @@ bool IOMapOTBM::saveMap(Map &map, const FileName &identifier) {
 	g_gui.SetLoadDone(99, "Saving houses...");
 	saveHouses(map, identifier);
 
+	g_gui.SetLoadDone(99, "Saving zones...");
+	saveZones(map, identifier);
+
 	g_gui.SetLoadDone(99, "Saving npcs spawns...");
 	saveSpawnsNpc(map, identifier);
 	return true;
@@ -1513,6 +1575,10 @@ bool IOMapOTBM::saveMap(Map &map, NodeFileWriteHandle &f) {
 			f.addU8(OTBM_ATTR_EXT_HOUSE_FILE);
 			f.addString(nstr(tmpName.GetFullName()));
 
+			tmpName.Assign(wxstr(map.zonefile));
+			f.addU8(OTBM_ATTR_EXT_ZONE_FILE);
+			f.addString(nstr(tmpName.GetFullName()));
+
 			// Start writing tiles
 			uint32_t tiles_saved = 0;
 			bool first = true;
@@ -1597,6 +1663,14 @@ bool IOMapOTBM::saveMap(Map &map, NodeFileWriteHandle &f) {
 						item->serializeItemNode_OTBM(self, f);
 					}
 				}
+				if (!save_tile->zones.empty()) {
+					f.addNode(OTBM_TILE_ZONE);
+					f.addU16(save_tile->zones.size());
+					for (const auto &zoneId : save_tile->zones) {
+						f.addU16(zoneId);
+					}
+					f.endNode();
+				}
 
 				f.endNode();
 				++map_iterator;
@@ -1763,6 +1837,36 @@ bool IOMapOTBM::saveHouses(Map &map, pugi::xml_document &doc) {
 	return true;
 }
 
+bool IOMapOTBM::saveZones(Map &map, const FileName &dir) {
+	wxString filepath = dir.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME);
+	filepath += wxString(map.zonefile.c_str(), wxConvUTF8);
+
+	// Create the XML file
+	pugi::xml_document doc;
+	if (saveZones(map, doc)) {
+		return doc.save_file(filepath.wc_str(), "\t", pugi::format_default, pugi::encoding_utf8);
+	}
+	return false;
+}
+
+bool IOMapOTBM::saveZones(Map &map, pugi::xml_document &doc) {
+	pugi::xml_node decl = doc.prepend_child(pugi::node_declaration);
+	if (!decl) {
+		return false;
+	}
+
+	decl.append_attribute("version") = "1.0";
+
+	pugi::xml_node zoneNodes = doc.append_child("zones");
+	for (const auto &[name, id] : map.zones) {
+		pugi::xml_node zoneNode = zoneNodes.append_child("zone");
+
+		zoneNode.append_attribute("name") = name.c_str();
+		zoneNode.append_attribute("zoneid") = id;
+	}
+	return true;
+}
+
 bool IOMapOTBM::saveSpawnsNpc(Map &map, const FileName &dir) {
 	wxString filepath = dir.GetPath(wxPATH_GET_SEPARATOR | wxPATH_GET_VOLUME);
 	filepath += wxString(map.spawnnpcfile.c_str(), wxConvUTF8);
diff --git a/source/iomap_otbm.h b/source/iomap_otbm.h
index 782d7086..275afa0e 100644
--- a/source/iomap_otbm.h
+++ b/source/iomap_otbm.h
@@ -23,7 +23,8 @@
 // Pragma pack is VERY important since otherwise it won't be able to load the structs correctly
 #pragma pack(1)
 
-enum OTBM_ItemAttribute {
+enum OTBM_ItemAttribute
+{
 	OTBM_ATTR_DESCRIPTION = 1,
 	OTBM_ATTR_EXT_FILE = 2,
 	OTBM_ATTR_TILE_FLAGS = 3,
@@ -47,11 +48,13 @@ enum OTBM_ItemAttribute {
 	OTBM_ATTR_SLEEPSTART = 21,
 	OTBM_ATTR_CHARGES = 22,
 	OTBM_ATTR_EXT_SPAWN_NPC_FILE = 23,
+	OTBM_ATTR_EXT_ZONE_FILE = 24,
 
 	OTBM_ATTR_ATTRIBUTE_MAP = 128
 };
 
-enum OTBM_NodeTypes_t {
+enum OTBM_NodeTypes_t
+{
 	OTBM_ROOTV1 = 1,
 	OTBM_MAP_DATA = 2,
 	OTBM_ITEM_DEF = 3,
@@ -69,10 +72,12 @@ enum OTBM_NodeTypes_t {
 	OTBM_WAYPOINTS = 15,
 	OTBM_WAYPOINT = 16,
 	OTBM_SPAWN_NPC_AREA = 17,
-	OTBM_SPAWNS_NPC = 18
+	OTBM_SPAWNS_NPC = 18,
+	OTBM_TILE_ZONE = 19
 };
 
-struct OTBM_root_header {
+struct OTBM_root_header
+{
 	uint32_t version;
 	uint16_t width;
 	uint16_t height;
@@ -80,30 +85,35 @@ struct OTBM_root_header {
 	uint32_t minorVersionItems;
 };
 
-struct OTBM_TeleportDest {
+struct OTBM_TeleportDest
+{
 	uint16_t x;
 	uint16_t y;
 	uint8_t z;
 };
 
-struct OTBM_Tile_area_coords {
+struct OTBM_Tile_area_coords
+{
 	uint16_t x;
 	uint16_t y;
 	uint8_t z;
 };
 
-struct OTBM_Tile_coords {
+struct OTBM_Tile_coords
+{
 	uint8_t x;
 	uint8_t y;
 };
 
-struct OTBM_TownTemple_coords {
+struct OTBM_TownTemple_coords
+{
 	uint16_t x;
 	uint16_t y;
 	uint8_t z;
 };
 
-struct OTBM_HouseTile_coords {
+struct OTBM_HouseTile_coords
+{
 	uint8_t x;
 	uint8_t y;
 	uint32_t houseid;
@@ -111,36 +121,39 @@ struct OTBM_HouseTile_coords {
 
 #pragma pack()
 
-class IOMapOTBM : public IOMap {
+class IOMapOTBM : public IOMap
+{
 public:
-	IOMapOTBM(MapVersion ver) {
-		version = ver;
-	}
-	~IOMapOTBM() { }
+	IOMapOTBM(MapVersion ver) {version = ver;}
+	~IOMapOTBM() {}
 
-	static bool getVersionInfo(const FileName &identifier, MapVersion &out_ver);
+	static bool getVersionInfo(const FileName& identifier, MapVersion& out_ver);
 
-	virtual bool loadMap(Map &map, const FileName &identifier);
-	virtual bool saveMap(Map &map, const FileName &identifier);
+	virtual bool loadMap(Map& map, const FileName& identifier);
+	virtual bool saveMap(Map& map, const FileName& identifier);
 
 protected:
-	static bool getVersionInfo(NodeFileReadHandle* f, MapVersion &out_ver);
-
-	virtual bool loadMap(Map &map, NodeFileReadHandle &handle);
-	bool loadSpawnsMonster(Map &map, const FileName &dir);
-	bool loadSpawnsMonster(Map &map, pugi::xml_document &doc);
-	bool loadHouses(Map &map, const FileName &dir);
-	bool loadHouses(Map &map, pugi::xml_document &doc);
-	bool loadSpawnsNpc(Map &map, const FileName &dir);
-	bool loadSpawnsNpc(Map &map, pugi::xml_document &doc);
-
-	virtual bool saveMap(Map &map, NodeFileWriteHandle &handle);
-	bool saveSpawns(Map &map, const FileName &dir);
-	bool saveSpawns(Map &map, pugi::xml_document &doc);
-	bool saveHouses(Map &map, const FileName &dir);
-	bool saveHouses(Map &map, pugi::xml_document &doc);
-	bool saveSpawnsNpc(Map &map, const FileName &dir);
-	bool saveSpawnsNpc(Map &map, pugi::xml_document &doc);
+	static bool getVersionInfo(NodeFileReadHandle* f,  MapVersion& out_ver);
+
+	virtual bool loadMap(Map& map, NodeFileReadHandle& handle);
+	bool loadSpawnsMonster(Map& map, const FileName& dir);
+	bool loadSpawnsMonster(Map& map, pugi::xml_document& doc);
+	bool loadHouses(Map& map, const FileName& dir);
+	bool loadHouses(Map& map, pugi::xml_document& doc);
+	bool loadSpawnsNpc(Map& map, const FileName& dir);
+	bool loadSpawnsNpc(Map& map, pugi::xml_document& doc);
+	bool loadZones(Map& map, const FileName& dir);
+	bool loadZones(Map& map, pugi::xml_document& doc);
+
+	virtual bool saveMap(Map& map, NodeFileWriteHandle& handle);
+	bool saveSpawns(Map& map, const FileName& dir);
+	bool saveSpawns(Map& map, pugi::xml_document& doc);
+	bool saveHouses(Map& map, const FileName& dir);
+	bool saveHouses(Map& map, pugi::xml_document& doc);
+	bool saveSpawnsNpc(Map& map, const FileName& dir);
+	bool saveSpawnsNpc(Map& map, pugi::xml_document& doc);
+	bool saveZones(Map& map, const FileName& dir);
+	bool saveZones(Map& map, pugi::xml_document& doc);
 };
 
 #endif
diff --git a/source/main_menubar.cpp b/source/main_menubar.cpp
index 18a2a42e..ce4d3b2e 100644
--- a/source/main_menubar.cpp
+++ b/source/main_menubar.cpp
@@ -87,6 +87,7 @@ MainMenuBar::MainMenuBar(MainFrame* frame) :
 	MAKE_ACTION(SEARCH_ON_SELECTION_ITEM, wxITEM_NORMAL, OnSearchForItemOnSelection);
 	MAKE_ACTION(REPLACE_ON_SELECTION_ITEMS, wxITEM_NORMAL, OnReplaceItemsOnSelection);
 	MAKE_ACTION(REMOVE_ON_SELECTION_ITEM, wxITEM_NORMAL, OnRemoveItemOnSelection);
+	MAKE_ACTION(REMOVE_ON_SELECTION_MONSTER, wxITEM_NORMAL, OnRemovMonstersOnSelection);
 	MAKE_ACTION(SELECT_MODE_COMPENSATE, wxITEM_RADIO, OnSelectionTypeChange);
 	MAKE_ACTION(SELECT_MODE_LOWER, wxITEM_RADIO, OnSelectionTypeChange);
 	MAKE_ACTION(SELECT_MODE_CURRENT, wxITEM_RADIO, OnSelectionTypeChange);
@@ -175,6 +176,7 @@ MainMenuBar::MainMenuBar(MainFrame* frame) :
 	MAKE_ACTION(SELECT_NPC, wxITEM_NORMAL, OnSelectNpcPalette);
 	MAKE_ACTION(SELECT_HOUSE, wxITEM_NORMAL, OnSelectHousePalette);
 	MAKE_ACTION(SELECT_WAYPOINT, wxITEM_NORMAL, OnSelectWaypointPalette);
+	MAKE_ACTION(SELECT_ZONES, wxITEM_NORMAL, OnSelectZonesPalette);
 	MAKE_ACTION(SELECT_RAW, wxITEM_NORMAL, OnSelectRawPalette);
 
 	MAKE_ACTION(FLOOR_0, wxITEM_RADIO, OnChangeFloor);
@@ -348,6 +350,7 @@ void MainMenuBar::Update() {
 	EnableItem(SEARCH_ON_SELECTION_ITEM, has_selection && is_host);
 	EnableItem(REPLACE_ON_SELECTION_ITEMS, has_selection && is_host);
 	EnableItem(REMOVE_ON_SELECTION_ITEM, has_selection && is_host);
+	EnableItem(REMOVE_ON_SELECTION_MONSTER, has_selection && is_host);
 
 	EnableItem(CUT, has_map);
 	EnableItem(COPY, has_map);
@@ -397,6 +400,7 @@ void MainMenuBar::Update() {
 	EnableItem(SELECT_MONSTER, loaded);
 	EnableItem(SELECT_NPC, loaded);
 	EnableItem(SELECT_WAYPOINT, loaded);
+	EnableItem(SELECT_ZONES, loaded);
 	EnableItem(SELECT_RAW, loaded);
 
 	EnableItem(LIVE_START, is_local);
@@ -604,7 +608,8 @@ bool MainMenuBar::Load(const FileName &path, wxArrayString &warnings, wxString &
 	entries[38].Set(wxACCEL_NORMAL, (int)'C', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_MONSTER));
 	entries[39].Set(wxACCEL_NORMAL, (int)'N', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_NPC));
 	entries[40].Set(wxACCEL_NORMAL, (int)'W', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_WAYPOINT));
-	entries[41].Set(wxACCEL_NORMAL, (int)'R', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_RAW));
+	entries[41].Set(wxACCEL_NORMAL, (int)'Z', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_ZONES));
+	entries[42].Set(wxACCEL_NORMAL, (int)'R', static_cast<int>(MAIN_FRAME_MENU) + static_cast<int>(MenuBar::SELECT_RAW));
 
 	wxAcceleratorTable accelerator(count, entries);
 	frame->SetAcceleratorTable(accelerator);
@@ -1119,6 +1124,23 @@ void MainMenuBar::OnRemoveItemOnSelection(wxCommandEvent &WXUNUSED(event)) {
 	dialog.Destroy();
 }
 
+void MainMenuBar::OnRemovMonstersOnSelection(wxCommandEvent &WXUNUSED(event)) {
+	if (!g_gui.IsEditorOpen()) {
+		return;
+	}
+
+	g_gui.GetCurrentEditor()->clearActions();
+	g_gui.CreateLoadBar("Searching monsters on selection to remove...");
+	int64_t count = RemoveMonstersOnMap(g_gui.GetCurrentMap(), true);
+	g_gui.DestroyLoadBar();
+
+	wxString msg;
+	msg << count << " monsters removed.";
+	g_gui.PopupDialog("Remove Monsters", msg, wxOK);
+	g_gui.GetCurrentMap().doChange();
+	g_gui.RefreshView();
+}
+
 void MainMenuBar::OnSelectionTypeChange(wxCommandEvent &WXUNUSED(event)) {
 	g_settings.setInteger(Config::COMPENSATED_SELECT, IsItemChecked(MenuBar::SELECT_MODE_COMPENSATE));
 
@@ -1931,13 +1953,13 @@ void MainMenuBar::OnToggleFullscreen(wxCommandEvent &WXUNUSED(event)) {
 }
 
 void MainMenuBar::OnTakeScreenshot(wxCommandEvent &WXUNUSED(event)) {
-	wxString path = wxstr(g_settings.getString(Config::SCREENSHOT_DIRECTORY));
-	if (path.size() > 0 && (path.Last() == '/' || path.Last() == '\\')) {
+	auto path = g_settings.getString(Config::SCREENSHOT_DIRECTORY);
+	if (path.size() > 0 && (path.back() == '/' || path.back() == '\\')) {
 		path = path + "/";
 	}
 
 	g_gui.GetCurrentMapTab()->GetView()->GetCanvas()->TakeScreenshot(
-		path, wxstr(g_settings.getString(Config::SCREENSHOT_FORMAT))
+		wxstr(path), wxstr(g_settings.getString(Config::SCREENSHOT_FORMAT))
 	);
 }
 
@@ -2048,6 +2070,10 @@ void MainMenuBar::OnSelectWaypointPalette(wxCommandEvent &WXUNUSED(event)) {
 	g_gui.SelectPalettePage(TILESET_WAYPOINT);
 }
 
+void MainMenuBar::OnSelectZonesPalette(wxCommandEvent &WXUNUSED(event)) {
+	g_gui.SelectPalettePage(TILESET_ZONES);
+}
+
 void MainMenuBar::OnSelectRawPalette(wxCommandEvent &WXUNUSED(event)) {
 	g_gui.SelectPalettePage(TILESET_RAW);
 }
diff --git a/source/main_menubar.h b/source/main_menubar.h
index a7039b6f..c4c4fb51 100644
--- a/source/main_menubar.h
+++ b/source/main_menubar.h
@@ -56,6 +56,7 @@ namespace MenuBar {
 		SEARCH_ON_SELECTION_ITEM,
 		REPLACE_ON_SELECTION_ITEMS,
 		REMOVE_ON_SELECTION_ITEM,
+		REMOVE_ON_SELECTION_MONSTER,
 		SELECT_MODE_COMPENSATE,
 		SELECT_MODE_CURRENT,
 		SELECT_MODE_LOWER,
@@ -134,6 +135,7 @@ namespace MenuBar {
 		SELECT_NPC,
 		SELECT_HOUSE,
 		SELECT_WAYPOINT,
+		SELECT_ZONES,
 		SELECT_RAW,
 		FLOOR_0,
 		FLOOR_1,
@@ -244,6 +246,7 @@ class MainMenuBar : public wxEvtHandler {
 	void OnSearchForItemOnSelection(wxCommandEvent &event);
 	void OnReplaceItemsOnSelection(wxCommandEvent &event);
 	void OnRemoveItemOnSelection(wxCommandEvent &event);
+	void OnRemovMonstersOnSelection(wxCommandEvent &event);
 
 	// Map menu
 	void OnMapEditTowns(wxCommandEvent &event);
@@ -280,6 +283,7 @@ class MainMenuBar : public wxEvtHandler {
 	void OnSelectMonsterPalette(wxCommandEvent &event);
 	void OnSelectNpcPalette(wxCommandEvent &event);
 	void OnSelectWaypointPalette(wxCommandEvent &event);
+	void OnSelectZonesPalette(wxCommandEvent &event);
 	void OnSelectRawPalette(wxCommandEvent &event);
 
 	// Floor menu
diff --git a/source/map.cpp b/source/map.cpp
index e65e3051..fb95ffea 100644
--- a/source/map.cpp
+++ b/source/map.cpp
@@ -21,28 +21,30 @@
 
 #include "map.h"
 
-Map::Map() :
-	BaseMap(),
+Map::Map() : BaseMap(),
 	width(512),
 	height(512),
 	houses(*this),
 	has_changed(false),
 	unnamed(false),
-	waypoints(*this) {
+	waypoints(*this),
+	zones(*this)
+{
 	// Earliest version possible
 	// Caller is responsible for converting us to proper version
 	mapVersion.otbm = MAP_OTBM_1;
 	mapVersion.client = CLIENT_VERSION_NONE;
 }
 
-Map::~Map() {
+Map::~Map()
+{
 	////
 }
 
-bool Map::open(const std::string file) {
-	if (file == filename) {
+bool Map::open(const std::string file)
+{
+	if(file == filename)
 		return true; // Do not reopen ourselves!
-	}
 
 	tilecount = 0;
 
@@ -54,7 +56,7 @@ bool Map::open(const std::string file) {
 
 	warnings = maploader.getWarnings();
 
-	if (!success) {
+	if(!success) {
 		error = maploader.getError();
 		return false;
 	}
@@ -112,8 +114,9 @@ bool Map::open(const std::string file) {
 	return true;
 }
 
-bool Map::convert(MapVersion to, bool showdialog) {
-	if (mapVersion.client == to.client) {
+bool Map::convert(MapVersion to, bool showdialog)
+{
+	if(mapVersion.client == to.client) {
 		// Only OTBM version differs
 		// No changes necessary
 		mapVersion = to;
@@ -139,94 +142,89 @@ bool Map::convert(MapVersion to, bool showdialog) {
 	return true;
 }
 
-bool Map::convert(const ConversionMap &rm, bool showdialog) {
-	if (showdialog) {
+bool Map::convert(const ConversionMap& rm, bool showdialog)
+{
+	if(showdialog)
 		g_gui.CreateLoadBar("Converting map ...");
-	}
 
 	uint64_t tiles_done = 0;
 	std::vector<uint16_t> id_list;
 
-	// std::ofstream conversions("converted_items.txt");
+	//std::ofstream conversions("converted_items.txt");
 
-	for (MapIterator miter = begin(); miter != end(); ++miter) {
+	for(MapIterator miter = begin(); miter != end(); ++miter) {
 		Tile* tile = (*miter)->get();
 		ASSERT(tile);
 
-		if (tile->size() == 0) {
+		if(tile->size() == 0)
 			continue;
-		}
 
 		// id_list try MTM conversion
 		id_list.clear();
 
-		if (tile->ground) {
+		if(tile->ground)
 			id_list.push_back(tile->ground->getID());
-		}
-		for (ItemVector::const_iterator item_iter = tile->items.begin(); item_iter != tile->items.end(); ++item_iter) {
-			if ((*item_iter)->isBorder()) {
+		for(ItemVector::const_iterator item_iter = tile->items.begin(); item_iter != tile->items.end(); ++item_iter)
+			if((*item_iter)->isBorder())
 				id_list.push_back((*item_iter)->getID());
-			}
-		}
 
 		std::sort(id_list.begin(), id_list.end());
 
 		ConversionMap::MTM::const_iterator cfmtm = rm.mtm.end();
 
-		while (id_list.size()) {
+		while(id_list.size()) {
 			cfmtm = rm.mtm.find(id_list);
-			if (cfmtm != rm.mtm.end()) {
+			if(cfmtm != rm.mtm.end())
 				break;
-			}
 			id_list.pop_back();
 		}
 
 		// Keep track of how many items have been inserted at the bottom
 		size_t inserted_items = 0;
 
-		if (cfmtm != rm.mtm.end()) {
-			const std::vector<uint16_t> &v = cfmtm->first;
+		if(cfmtm != rm.mtm.end()) {
+			const std::vector<uint16_t>& v = cfmtm->first;
 
-			if (tile->ground && std::find(v.begin(), v.end(), tile->ground->getID()) != v.end()) {
+			if(tile->ground && std::find(v.begin(), v.end(), tile->ground->getID()) != v.end()) {
 				delete tile->ground;
 				tile->ground = nullptr;
 			}
 
-			for (ItemVector::iterator item_iter = tile->items.begin(); item_iter != tile->items.end();) {
-				if (std::find(v.begin(), v.end(), (*item_iter)->getID()) != v.end()) {
+			for(ItemVector::iterator item_iter = tile->items.begin(); item_iter != tile->items.end(); ) {
+				if(std::find(v.begin(), v.end(), (*item_iter)->getID()) != v.end()) {
 					delete *item_iter;
 					item_iter = tile->items.erase(item_iter);
-				} else {
-					++item_iter;
 				}
+				else
+					++item_iter;
 			}
 
-			const std::vector<uint16_t> &new_items = cfmtm->second;
-			for (std::vector<uint16_t>::const_iterator iit = new_items.begin(); iit != new_items.end(); ++iit) {
+			const std::vector<uint16_t>& new_items = cfmtm->second;
+			for(std::vector<uint16_t>::const_iterator iit = new_items.begin(); iit != new_items.end(); ++iit) {
 				Item* item = Item::Create(*iit);
-				if (item->isGroundTile()) {
+				if(item->isGroundTile())
 					tile->ground = item;
-				} else {
+				else {
 					tile->items.insert(tile->items.begin(), item);
 					++inserted_items;
 				}
 			}
 		}
 
-		if (tile->ground) {
+		if(tile->ground) {
 			ConversionMap::STM::const_iterator cfstm = rm.stm.find(tile->ground->getID());
-			if (cfstm != rm.stm.end()) {
+			if(cfstm != rm.stm.end()) {
 				uint16_t aid = tile->ground->getActionID();
 				uint16_t uid = tile->ground->getUniqueID();
 				delete tile->ground;
 				tile->ground = nullptr;
 
-				const std::vector<uint16_t> &v = cfstm->second;
-				// conversions << "Converted " << tile->getX() << ":" << tile->getY() << ":" << tile->getZ() << " " << id << " -> ";
-				for (std::vector<uint16_t>::const_iterator iit = v.begin(); iit != v.end(); ++iit) {
+				const std::vector<uint16_t>& v = cfstm->second;
+				//conversions << "Converted " << tile->getX() << ":" << tile->getY() << ":" << tile->getZ() << " " << id << " -> ";
+				for(std::vector<uint16_t>::const_iterator iit = v.begin(); iit != v.end(); ++iit) {
 					Item* item = Item::Create(*iit);
-					// conversions << *iit << " ";
-					if (item->isGroundTile()) {
+					//conversions << *iit << " ";
+					if(item->isGroundTile()) {
 						item->setActionID(aid);
 						item->setUniqueID(uid);
 						tile->addItem(item);
@@ -235,139 +233,180 @@ bool Map::convert(const ConversionMap &rm, bool showdialog) {
 						++inserted_items;
 					}
 				}
-				// conversions << std::endl;
+				//conversions << std::endl;
 			}
 		}
 
-		for (ItemVector::iterator replace_item_iter = tile->items.begin() + inserted_items; replace_item_iter != tile->items.end();) {
+		for(ItemVector::iterator replace_item_iter = tile->items.begin() + inserted_items; replace_item_iter != tile->items.end(); ) {
 			uint16_t id = (*replace_item_iter)->getID();
 			ConversionMap::STM::const_iterator cf = rm.stm.find(id);
-			if (cf != rm.stm.end()) {
-				// uint16_t aid = (*replace_item_iter)->getActionID();
-				// uint16_t uid = (*replace_item_iter)->getUniqueID();
+			if(cf != rm.stm.end()) {
+				//uint16_t aid = (*replace_item_iter)->getActionID();
+				//uint16_t uid = (*replace_item_iter)->getUniqueID();
 				delete *replace_item_iter;
 
 				replace_item_iter = tile->items.erase(replace_item_iter);
-				const std::vector<uint16_t> &v = cf->second;
-				for (std::vector<uint16_t>::const_iterator iit = v.begin(); iit != v.end(); ++iit) {
+				const std::vector<uint16_t>& v = cf->second;
+				for(std::vector<uint16_t>::const_iterator iit = v.begin(); iit != v.end(); ++iit) {
 					replace_item_iter = tile->items.insert(replace_item_iter, Item::Create(*iit));
-					// conversions << "Converted " << tile->getX() << ":" << tile->getY() << ":" << tile->getZ() << " " << id << " -> " << *iit << std::endl;
+					//conversions << "Converted " << tile->getX() << ":" << tile->getY() << ":" << tile->getZ() << " " << id << " -> " << *iit << std::endl;
 					++replace_item_iter;
 				}
-			} else {
-				++replace_item_iter;
 			}
+			else
+				++replace_item_iter;
 		}
 
 		++tiles_done;
-		if (showdialog && tiles_done % 0x10000 == 0) {
+		if(showdialog && tiles_done % 0x10000 == 0) {
 			g_gui.SetLoadDone(int(tiles_done / double(getTileCount()) * 100.0));
 		}
 	}
 
-	if (showdialog) {
+	if(showdialog)
 		g_gui.DestroyLoadBar();
-	}
 
 	return true;
 }
 
-void Map::cleanInvalidTiles(bool showdialog) {
-	if (showdialog) {
+void Map::cleanInvalidTiles(bool showdialog)
+{
+	if(showdialog)
 		g_gui.CreateLoadBar("Removing invalid tiles...");
-	}
 
 	uint64_t tiles_done = 0;
 
-	for (MapIterator miter = begin(); miter != end(); ++miter) {
+	for(MapIterator miter = begin(); miter != end(); ++miter) {
 		Tile* tile = (*miter)->get();
 		ASSERT(tile);
 
-		if (tile->size() == 0) {
+		if(tile->size() == 0)
 			continue;
-		}
 
-		for (ItemVector::iterator item_iter = tile->items.begin(); item_iter != tile->items.end();) {
-			if (g_items.isValidID((*item_iter)->getID())) {
+		for(ItemVector::iterator item_iter = tile->items.begin(); item_iter != tile->items.end();) {
+			if(g_items.isValidID((*item_iter)->getID()))
 				++item_iter;
-			} else {
+			else {
 				delete *item_iter;
 				item_iter = tile->items.erase(item_iter);
 			}
 		}
 
 		++tiles_done;
-		if (showdialog && tiles_done % 0x10000 == 0) {
+		if(showdialog && tiles_done % 0x10000 == 0) {
 			g_gui.SetLoadDone(int(tiles_done / double(getTileCount()) * 100.0));
 		}
 	}
 
-	if (showdialog) {
+	if(showdialog)
 		g_gui.DestroyLoadBar();
+}
+
+void Map::cleanDeletedZones(bool showdialog)
+{
+	if(showdialog)
+		g_gui.CreateLoadBar("Removing deleted zones...");
+
+	uint64_t tiles_done = 0;
+
+	for(MapIterator miter = begin(); miter != end(); ++miter) {
+		Tile* tile = (*miter)->get();
+		ASSERT(tile);
+
+		if(tile->size() == 0)
+			continue;
+
+		for (auto iter = tile->zones.begin(); iter != tile->zones.end();) {
+			if (zones.hasZone(*iter))
+				++iter;
+			else
+				iter = tile->zones.erase(iter);
+		}
+
+		++tiles_done;
+		if(showdialog && tiles_done % 0x10000 == 0) {
+			g_gui.SetLoadDone(int(tiles_done / double(getTileCount()) * 100.0));
+		}
 	}
+
+	if(showdialog)
+		g_gui.DestroyLoadBar();
 }
 
-bool Map::doChange() {
+bool Map::doChange()
+{
 	bool doupdate = !has_changed;
 	has_changed = true;
 	return doupdate;
 }
 
-bool Map::clearChanges() {
+bool Map::clearChanges()
+{
 	bool doupdate = has_changed;
 	has_changed = false;
 	return doupdate;
 }
 
-void Map::setWidth(int new_width) {
-	if (new_width > 65000) {
+void Map::setWidth(int new_width)
+{
+	if(new_width > 65000)
 		width = 65000;
-	} else if (new_width < 64) {
+	else if(new_width < 64)
 		width = 64;
-	} else {
+	else
 		width = new_width;
-	}
 }
 
-void Map::setHeight(int new_height) {
-	if (new_height > 65000) {
+void Map::setHeight(int new_height)
+{
+	if(new_height > 65000)
 		height = 65000;
-	} else if (new_height < 64) {
+	else if(new_height < 64)
 		height = 64;
-	} else {
+	else
 		height = new_height;
-	}
 }
-void Map::setMapDescription(const std::string &new_description) {
+void Map::setMapDescription(const std::string& new_description)
+{
 	description = new_description;
 }
 
-void Map::setHouseFilename(const std::string &new_housefile) {
+void Map::setHouseFilename(const std::string&  new_housefile)
+{
 	housefile = new_housefile;
 	unnamed = false;
 }
 
-void Map::setSpawnMonsterFilename(const std::string &new_spawnmonsterfile) {
+void Map::setZoneFilename(const std::string&  new_zonefile)
+{
+	zonefile = new_zonefile;
+	unnamed = false;
+}
+
+void Map::setSpawnMonsterFilename(const std::string&  new_spawnmonsterfile)
+{
 	spawnmonsterfile = new_spawnmonsterfile;
 	unnamed = false;
 }
 
-void Map::setSpawnNpcFilename(const std::string &new_spawnnpcfile) {
+void Map::setSpawnNpcFilename(const std::string&  new_spawnnpcfile)
+{
 	spawnnpcfile = new_spawnnpcfile;
 	unnamed = false;
 }
 
-bool Map::addSpawnMonster(Tile* tile) {
+bool Map::addSpawnMonster(Tile* tile)
+{
 	SpawnMonster* spawnMonster = tile->spawnMonster;
-	if (spawnMonster) {
+	if(spawnMonster) {
 		int z = tile->getZ();
 		int start_x = tile->getX() - spawnMonster->getSize();
 		int start_y = tile->getY() - spawnMonster->getSize();
 		int end_x = tile->getX() + spawnMonster->getSize();
 		int end_y = tile->getY() + spawnMonster->getSize();
 
-		for (int y = start_y; y <= end_y; ++y) {
-			for (int x = start_x; x <= end_x; ++x) {
+		for(int y = start_y; y <= end_y; ++y) {
+			for(int x = start_x; x <= end_x; ++x) {
 				TileLocation* ctile_loc = createTileL(x, y, z);
 				ctile_loc->increaseSpawnCount();
 			}
@@ -378,7 +417,8 @@ bool Map::addSpawnMonster(Tile* tile) {
 	return false;
 }
 
-void Map::removeSpawnMonsterInternal(Tile* tile) {
+void Map::removeSpawnMonsterInternal(Tile* tile)
+{
 	SpawnMonster* spawnMonster = tile->spawnMonster;
 	ASSERT(spawnMonster);
 
@@ -388,83 +428,81 @@ void Map::removeSpawnMonsterInternal(Tile* tile) {
 	int end_x = tile->getX() + spawnMonster->getSize();
 	int end_y = tile->getY() + spawnMonster->getSize();
 
-	for (int y = start_y; y <= end_y; ++y) {
-		for (int x = start_x; x <= end_x; ++x) {
+	for(int y = start_y; y <= end_y; ++y) {
+		for(int x = start_x; x <= end_x; ++x) {
 			TileLocation* ctile_loc = getTileL(x, y, z);
-			if (ctile_loc != nullptr && ctile_loc->getSpawnMonsterCount() > 0) {
+			if(ctile_loc != nullptr && ctile_loc->getSpawnMonsterCount() > 0)
 				ctile_loc->decreaseSpawnMonsterCount();
-			}
 		}
 	}
 }
 
-void Map::removeSpawnMonster(Tile* tile) {
-	if (tile->spawnMonster) {
+void Map::removeSpawnMonster(Tile* tile)
+{
+	if(tile->spawnMonster) {
 		removeSpawnMonsterInternal(tile);
 		spawnsMonster.removeSpawnMonster(tile);
 	}
 }
 
-SpawnMonsterList Map::getSpawnMonsterList(const Tile* tile) const {
+SpawnMonsterList Map::getSpawnMonsterList(const Tile* tile) const
+{
 	SpawnMonsterList list;
-	if (!tile) {
-		return list;
-	}
+	if(!tile) return list;
 
 	const TileLocation* location = tile->getLocation();
-	if (!location || location->getSpawnMonsterCount() == 0) {
+	if(!location || location->getSpawnMonsterCount() == 0)
 		return list;
-	}
 
 	uint32_t found = 0;
-	if (tile->spawnMonster) {
+	if(tile->spawnMonster) {
 		++found;
 		list.push_back(tile->spawnMonster);
 	}
 
 	// Scans the border tiles in an expanding square around the original spawn
-	const Position &position = tile->getPosition();
+	const Position& position = tile->getPosition();
 	int start_x = position.x - 1;
 	int end_x = position.x + 1;
 	int start_y = position.y - 1;
 	int end_y = position.y + 1;
 
-	while (found != location->getSpawnMonsterCount()) {
-		for (int x = start_x; x <= end_x; ++x) {
+	while(found != location->getSpawnMonsterCount()) {
+		for(int x = start_x; x <= end_x; ++x) {
 			const Tile* start_tile = getTile(x, start_y, position.z);
-			if (start_tile && start_tile->spawnMonster) {
+			if(start_tile && start_tile->spawnMonster) {
 				list.push_back(start_tile->spawnMonster);
 				++found;
 			}
 
 			const Tile* end_tile = getTile(x, end_y, position.z);
-			if (end_tile && end_tile->spawnMonster) {
+			if(end_tile && end_tile->spawnMonster) {
 				list.push_back(end_tile->spawnMonster);
 				++found;
 			}
 		}
 
-		for (int y = start_y + 1; y < end_y; ++y) {
+			for(int y = start_y + 1; y < end_y; ++y) {
 			const Tile* start_tile = getTile(start_x, y, position.z);
-			if (start_tile && start_tile->spawnMonster) {
+			if(start_tile && start_tile->spawnMonster) {
 				list.push_back(start_tile->spawnMonster);
 				++found;
 			}
 			const Tile* end_tile = getTile(end_x, y, position.z);
-			if (end_tile && end_tile->spawnMonster) {
+			if(end_tile && end_tile->spawnMonster) {
 				list.push_back(end_tile->spawnMonster);
 				++found;
 			}
 		}
 
-		for (int y = start_y + 1; y < end_y; ++y) {
+		for(int y = start_y + 1; y < end_y; ++y) {
 			const Tile* start_tile = getTile(start_x, y, position.z);
-			if (start_tile && start_tile->spawnMonster) {
+			if(start_tile && start_tile->spawnMonster) {
 				list.push_back(start_tile->spawnMonster);
 				++found;
 			}
 			const Tile* end_tile = getTile(end_x, y, position.z);
-			if (end_tile && end_tile->spawnMonster) {
+			if(end_tile && end_tile->spawnMonster) {
 				list.push_back(end_tile->spawnMonster);
 				++found;
 			}
@@ -477,27 +515,30 @@ SpawnMonsterList Map::getSpawnMonsterList(const Tile* tile) const {
 	return list;
 }
 
-SpawnMonsterList Map::getSpawnMonsterList(const Position &position) const {
+SpawnMonsterList Map::getSpawnMonsterList(const Position& position) const
+{
 	const Tile* tile = getTile(position);
 	return getSpawnMonsterList(tile);
 }
 
-SpawnMonsterList Map::getSpawnMonsterList(int x, int y, int z) const {
+SpawnMonsterList Map::getSpawnMonsterList(int x, int y, int z) const
+{
 	const Tile* tile = getTile(x, y, z);
 	return getSpawnMonsterList(tile);
 }
 
-bool Map::addSpawnNpc(Tile* tile) {
+bool Map::addSpawnNpc(Tile* tile)
+{
 	SpawnNpc* spawnNpc = tile->spawnNpc;
-	if (spawnNpc) {
+	if(spawnNpc) {
 		int z = tile->getZ();
 		int start_x = tile->getX() - spawnNpc->getSize();
 		int start_y = tile->getY() - spawnNpc->getSize();
 		int end_x = tile->getX() + spawnNpc->getSize();
 		int end_y = tile->getY() + spawnNpc->getSize();
 
-		for (int y = start_y; y <= end_y; ++y) {
-			for (int x = start_x; x <= end_x; ++x) {
+		for(int y = start_y; y <= end_y; ++y) {
+			for(int x = start_x; x <= end_x; ++x) {
 				TileLocation* ctile_loc = createTileL(x, y, z);
 				ctile_loc->increaseSpawnNpcCount();
 			}
@@ -508,7 +549,8 @@ bool Map::addSpawnNpc(Tile* tile) {
 	return false;
 }
 
-void Map::removeSpawnNpcInternal(Tile* tile) {
+void Map::removeSpawnNpcInternal(Tile* tile)
+{
 	SpawnNpc* spawnNpc = tile->spawnNpc;
 	ASSERT(spawnNpc);
 
@@ -518,70 +560,68 @@ void Map::removeSpawnNpcInternal(Tile* tile) {
 	int end_x = tile->getX() + spawnNpc->getSize();
 	int end_y = tile->getY() + spawnNpc->getSize();
 
-	for (int y = start_y; y <= end_y; ++y) {
-		for (int x = start_x; x <= end_x; ++x) {
+	for(int y = start_y; y <= end_y; ++y) {
+		for(int x = start_x; x <= end_x; ++x) {
 			TileLocation* ctile_loc = getTileL(x, y, z);
-			if (ctile_loc != nullptr && ctile_loc->getSpawnNpcCount() > 0) {
+			if(ctile_loc != nullptr && ctile_loc->getSpawnNpcCount() > 0)
 				ctile_loc->decreaseSpawnNpcCount();
-			}
 		}
 	}
 }
 
-void Map::removeSpawnNpc(Tile* tile) {
-	if (tile->spawnNpc) {
+void Map::removeSpawnNpc(Tile* tile)
+{
+	if(tile->spawnNpc) {
 		removeSpawnNpcInternal(tile);
 		spawnsNpc.removeSpawnNpc(tile);
 	}
 }
 
-SpawnNpcList Map::getSpawnNpcList(const Tile* tile) const {
+SpawnNpcList Map::getSpawnNpcList(const Tile* tile) const
+{
 	SpawnNpcList listNpc;
-	if (!tile) {
-		return listNpc;
-	}
+	if(!tile) return listNpc;
 
 	const TileLocation* location = tile->getLocation();
-	if (!location || location->getSpawnNpcCount() == 0) {
+	if(!location || location->getSpawnNpcCount() == 0)
 		return listNpc;
-	}
 
 	uint32_t found = 0;
-	if (tile->spawnNpc) {
+	if(tile->spawnNpc) {
 		++found;
 		listNpc.push_back(tile->spawnNpc);
 	}
 
 	// Scans the border tiles in an expanding square around the original spawn
-	const Position &position = tile->getPosition();
+	const Position& position = tile->getPosition();
 	int start_x = position.x - 1;
 	int end_x = position.x + 1;
 	int start_y = position.y - 1;
 	int end_y = position.y + 1;
 
-	while (found != location->getSpawnNpcCount()) {
-		for (int x = start_x; x <= end_x; ++x) {
+	while(found != location->getSpawnNpcCount()) {
+		for(int x = start_x; x <= end_x; ++x) {
 			const Tile* start_tile = getTile(x, start_y, position.z);
-			if (start_tile && start_tile->spawnNpc) {
+			if(start_tile && start_tile->spawnNpc) {
 				listNpc.push_back(start_tile->spawnNpc);
 				++found;
 			}
 
 			const Tile* end_tile = getTile(x, end_y, position.z);
-			if (end_tile && end_tile->spawnNpc) {
+			if(end_tile && end_tile->spawnNpc) {
 				listNpc.push_back(end_tile->spawnNpc);
 				++found;
 			}
 		}
 
-		for (int y = start_y + 1; y < end_y; ++y) {
+			for(int y = start_y + 1; y < end_y; ++y) {
 			const Tile* start_tile = getTile(start_x, y, position.z);
-			if (start_tile && start_tile->spawnNpc) {
+			if(start_tile && start_tile->spawnNpc) {
 				listNpc.push_back(start_tile->spawnNpc);
 				++found;
 			}
 			const Tile* end_tile = getTile(end_x, y, position.z);
-			if (end_tile && end_tile->spawnNpc) {
+			if(end_tile && end_tile->spawnNpc) {
 				listNpc.push_back(end_tile->spawnNpc);
 				++found;
 			}
@@ -594,97 +634,91 @@ SpawnNpcList Map::getSpawnNpcList(const Tile* tile) const {
 	return listNpc;
 }
 
-SpawnNpcList Map::getSpawnNpcList(const Position &position) const {
+SpawnNpcList Map::getSpawnNpcList(const Position& position) const
+{
 	const Tile* tile = getTile(position);
 	return getSpawnNpcList(tile);
 }
 
-SpawnNpcList Map::getSpawnNpcList(int x, int y, int z) const {
+SpawnNpcList Map::getSpawnNpcList(int x, int y, int z) const
+{
 	const Tile* tile = getTile(x, y, z);
 	return getSpawnNpcList(tile);
 }
 
-bool Map::exportMinimap(FileName filename, int floor /*= rme::MapGroundLayer*/, bool displaydialog) {
+bool Map::exportMinimap(FileName filename, int floor /*= rme::MapGroundLayer*/, bool displaydialog)
+{
 	uint8_t* pic = nullptr;
 
-	try {
+	try
+	{
 		int min_x = 0x10000, min_y = 0x10000;
 		int max_x = 0x00000, max_y = 0x00000;
 
-		if (size() == 0) {
+		if(size() == 0)
 			return true;
-		}
 
 		uint32_t minimap_colors[256];
-		for (int i = 0; i < 256; ++i) {
+		for(int i = 0; i < 256; ++i)
 			minimap_colors[i] = colorFromEightBit(i).GetRGB();
-		}
 
-		for (MapIterator mit = begin(); mit != end(); ++mit) {
-			if ((*mit)->get() == nullptr || (*mit)->empty()) {
+		for(MapIterator mit = begin(); mit != end(); ++mit) {
+			if((*mit)->get() == nullptr || (*mit)->empty())
 				continue;
-			}
 
 			Position pos = (*mit)->getPosition();
 
-			if (pos.x < min_x) {
+			if(pos.x < min_x)
 				min_x = pos.x;
-			}
 
-			if (pos.y < min_y) {
+			if(pos.y < min_y)
 				min_y = pos.y;
-			}
 
-			if (pos.x > max_x) {
+			if(pos.x > max_x)
 				max_x = pos.x;
-			}
 
-			if (pos.y > max_y) {
+			if(pos.y > max_y)
 				max_y = pos.y;
-			}
+
 		}
 
-		int minimap_width = max_x - min_x + 1;
-		int minimap_height = max_y - min_y + 1;
+		int minimap_width = max_x - min_x+1;
+		int minimap_height = max_y - min_y+1;
 
-		pic = newd uint8_t[minimap_width * minimap_height]; // 1 byte per pixel
+		pic = newd uint8_t[minimap_width*minimap_height]; // 1 byte per pixel
 
-		memset(pic, 0, minimap_width * minimap_height);
+		memset(pic, 0, minimap_width*minimap_height);
 
 		int tiles_iterated = 0;
-		for (MapIterator mit = begin(); mit != end(); ++mit) {
+		for(MapIterator mit = begin(); mit != end(); ++mit) {
 			Tile* tile = (*mit)->get();
 			++tiles_iterated;
-			if (tiles_iterated % 8192 == 0 && displaydialog) {
+			if(tiles_iterated % 8192 == 0 && displaydialog)
 				g_gui.SetLoadDone(int(tiles_iterated / double(tilecount) * 90.0));
-			}
 
-			if (tile->empty() || tile->getZ() != floor) {
+			if(tile->empty() || tile->getZ() != floor)
 				continue;
-			}
 
-			// std::cout << "Pixel : " << (tile->getY() - min_y) * width + (tile->getX() - min_x) << std::endl;
+			//std::cout << "Pixel : " << (tile->getY() - min_y) * width + (tile->getX() - min_x) << std::endl;
 			uint32_t pixelpos = (tile->getY() - min_y) * minimap_width + (tile->getX() - min_x);
-			uint8_t &pixel = pic[pixelpos];
+			uint8_t& pixel = pic[pixelpos];
 
-			for (ItemVector::const_reverse_iterator item_iter = tile->items.rbegin(); item_iter != tile->items.rend(); ++item_iter) {
-				if ((*item_iter)->getMiniMapColor()) {
+			for(ItemVector::const_reverse_iterator item_iter = tile->items.rbegin(); item_iter != tile->items.rend(); ++item_iter) {
+				if((*item_iter)->getMiniMapColor()) {
 					pixel = (*item_iter)->getMiniMapColor();
 					break;
 				}
 			}
-			if (pixel == 0) {
+			if(pixel == 0)
 				// check ground too
-				if (tile->hasGround()) {
+				if(tile->hasGround())
 					pixel = tile->ground->getMiniMapColor();
-				}
-			}
 		}
 
 		// Create a file for writing
 		FileWriteHandle fh(nstr(filename.GetFullPath()));
 
-		if (!fh.isOpen()) {
+		if(!fh.isOpen()) {
 			delete[] pic;
 			return false;
 		}
@@ -693,10 +727,11 @@ bool Map::exportMinimap(FileName filename, int floor /*= rme::MapGroundLayer*/,
 
 		// Store the file size
 		// We need to predict how large it will be
-		uint32_t file_size = 14 // header
-			+ 40 // image data header
-			+ 256 * 4 // color palette
-			+ ((minimap_width + 3) / 4 * 4) * height; // pixels
+		uint32_t file_size =
+					14 // header
+					+40 // image data header
+					+256*4 // color palette
+					+((minimap_width + 3) / 4 * 4) * height; // pixels
 		fh.addU32(file_size);
 
 		// Two values reserved, must always be 0.
@@ -704,7 +739,7 @@ bool Map::exportMinimap(FileName filename, int floor /*= rme::MapGroundLayer*/,
 		fh.addU16(0);
 
 		// Bitmapdata offset
-		fh.addU32(14 + 40 + 256 * 4);
+		fh.addU32(14 + 40 + 256*4);
 
 		// Header size
 		fh.addU32(40);
@@ -735,62 +770,62 @@ bool Map::exportMinimap(FileName filename, int floor /*= rme::MapGroundLayer*/,
 		fh.addU32(0);
 
 		// Write the color palette
-		for (int i = 0; i < 256; ++i) {
+		for(int i = 0; i < 256; ++i)
 			fh.addU32(minimap_colors[i]);
-		}
 
 		// Bitmap width must be divisible by four, calculate how much padding we need
-		int padding = ((minimap_width & 3) != 0 ? 4 - (minimap_width & 3) : 0);
+		int padding = ((minimap_width & 3) != 0? 4-(minimap_width & 3) : 0);
 		// Bitmap rows are saved in reverse order
-		for (int y = minimap_height - 1; y >= 0; --y) {
-			fh.addRAW(pic + y * minimap_width, minimap_width);
-			for (int i = 0; i < padding; ++i) {
+		for(int y = minimap_height-1; y >= 0; --y) {
+			fh.addRAW(pic + y*minimap_width, minimap_width);
+			for(int i = 0; i < padding; ++i) {
 				fh.addU8(0);
 			}
-			if (y % 100 == 0 && displaydialog) {
-				g_gui.SetLoadDone(90 + int((minimap_height - y) / double(minimap_height) * 10.0));
+			if(y % 100 == 0 && displaydialog) {
+				g_gui.SetLoadDone(90 + int((minimap_height-y) / double(minimap_height) * 10.0));
 			}
 		}
 
 		delete[] pic;
-		// fclose(file);
+		//fclose(file);
 		fh.close();
-	} catch (...) {
+	}
+	catch(...)
+	{
 		delete[] pic;
 	}
 
 	return true;
 }
 
-void Map::updateUniqueIds(Tile* old_tile, Tile* new_tile) {
-	if (old_tile && old_tile->hasUniqueItem()) {
-		if (old_tile->ground) {
+void Map::updateUniqueIds(Tile* old_tile, Tile* new_tile)
+{
+	if(old_tile && old_tile->hasUniqueItem()) {
+		if(old_tile->ground) {
 			uint16_t uid = old_tile->ground->getUniqueID();
-			if (uid != 0) {
+			if(uid != 0)
 				removeUniqueId(uid);
-			}
 		}
-		for (const Item* item : old_tile->items) {
-			if (item) {
+		for(const Item* item : old_tile->items) {
+			if(item) {
 				uint16_t uid = item->getUniqueID();
-				if (uid != 0) {
+				if(uid != 0) {
 					removeUniqueId(uid);
 				}
 			}
 		}
 	}
 
-	if (new_tile && new_tile->hasUniqueItem()) {
-		if (new_tile->ground) {
+	if(new_tile && new_tile->hasUniqueItem()) {
+		if(new_tile->ground) {
 			uint16_t uid = new_tile->ground->getUniqueID();
-			if (uid != 0) {
+			if(uid != 0)
 				addUniqueId(uid);
-			}
 		}
-		for (const Item* item : new_tile->items) {
-			if (item) {
+		for(const Item* item : new_tile->items) {
+			if(item) {
 				uint16_t uid = item->getUniqueID();
-				if (uid != 0) {
+				if(uid != 0) {
 					addUniqueId(uid);
 				}
 			}
@@ -798,25 +833,53 @@ void Map::updateUniqueIds(Tile* old_tile, Tile* new_tile) {
 	}
 }
 
-void Map::addUniqueId(uint16_t uid) {
+void Map::addUniqueId(uint16_t uid)
+{
 	auto it = std::find(uniqueIds.begin(), uniqueIds.end(), uid);
 	if (it == uniqueIds.end()) {
 		uniqueIds.push_back(uid);
 	}
 }
 
-void Map::removeUniqueId(uint16_t uid) {
+void Map::removeUniqueId(uint16_t uid)
+{
 	auto it = std::find(uniqueIds.begin(), uniqueIds.end(), uid);
 	if (it != uniqueIds.end()) {
 		uniqueIds.erase(it);
 	}
 }
 
-bool Map::hasUniqueId(uint16_t uid) const {
-	if (uid < rme::MinUniqueId || uniqueIds.empty()) {
+bool Map::hasUniqueId(uint16_t uid) const
+{
+	if (uid < rme::MinUniqueId || uniqueIds.empty())
 		return false;
-	}
 
 	auto it = std::find(uniqueIds.begin(), uniqueIds.end(), uid);
 	return it != uniqueIds.end();
 }
+
+int64_t RemoveMonstersOnMap(Map &map, bool selectedOnly)
+{
+	int64_t done = 0;
+	int64_t removed = 0;
+
+	MapIterator it = map.begin();
+	MapIterator end = map.end();
+
+	while(it != end) {
+		++done;
+		Tile* tile = (*it)->get();
+		if(selectedOnly && !tile->isSelected()) {
+			++it;
+			continue;
+		}
+		if(tile->monster) {
+			delete tile->monster;
+			tile->monster = nullptr;
+			++removed;
+		}
+
+		++it;
+	}
+	return removed;
+}
diff --git a/source/map.h b/source/map.h
index 2ee57ba5..58d4399e 100644
--- a/source/map.h
+++ b/source/map.h
@@ -25,10 +25,12 @@
 #include "spawn_monster.h"
 #include "complexitem.h"
 #include "waypoints.h"
+#include "zones.h"
 #include "templates.h"
 #include "spawn_npc.h"
 
-class Map : public BaseMap {
+class Map : public BaseMap
+{
 public:
 	// ctor and dtor
 	Map();
@@ -36,110 +38,75 @@ class Map : public BaseMap {
 
 	// Operations on the entire map
 	void cleanInvalidTiles(bool showdialog = false);
+	void cleanDeletedZones(bool showdialog = false);
 	// Save a bmp image of the minimap
 	bool exportMinimap(FileName filename, int floor = rme::MapGroundLayer, bool showdialog = false);
 	//
 	bool convert(MapVersion to, bool showdialog = false);
-	bool convert(const ConversionMap &cm, bool showdialog = false);
+	bool convert(const ConversionMap& cm, bool showdialog = false);
 
 	// Query information about the map
 
-	MapVersion getVersion() const noexcept {
-		return mapVersion;
-	}
+	MapVersion getVersion() const noexcept { return mapVersion; }
 	// Returns true if any change has been done since last save
-	bool hasChanged() const noexcept {
-		return has_changed;
-	}
+	bool hasChanged() const noexcept { return has_changed; }
 	// Makes a change, doesn't matter what. Just so that it asks when saving (Also adds a * to the window title)
 	bool doChange();
 	// Clears any changes
 	bool clearChanges();
 
 	// Errors/warnings
-	bool hasWarnings() const {
-		return warnings.size() != 0;
-	}
-	const wxArrayString &getWarnings() const {
-		return warnings;
-	}
-	bool hasError() const {
-		return error.size() != 0;
-	}
-	wxString getError() const {
-		return error;
-	}
+	bool hasWarnings() const {return warnings.size() != 0;}
+	const wxArrayString& getWarnings() const {return warnings;}
+	bool hasError() const {return error.size() != 0;}
+	wxString getError() const {return error;}
 
 	// Mess with spawnsMonster
 	bool addSpawnMonster(Tile* spawnMonster);
 	void removeSpawnMonster(Tile* tile);
-	void removeSpawnMonster(const Position &position) {
-		removeSpawnMonster(getTile(position));
-	}
+	void removeSpawnMonster(const Position& position) { removeSpawnMonster(getTile(position)); }
 
 	// Returns all possible spawnsMonster on the target tile
 	SpawnMonsterList getSpawnMonsterList(const Tile* tile) const;
-	SpawnMonsterList getSpawnMonsterList(const Position &position) const;
+	SpawnMonsterList getSpawnMonsterList(const Position& position) const;
 	SpawnMonsterList getSpawnMonsterList(int x, int y, int z) const;
 
 	// Mess with npc spawns
 	bool addSpawnNpc(Tile* spawnMonster);
 	void removeSpawnNpc(Tile* tile);
-	void removeSpawnNpc(const Position &position) {
-		removeSpawnNpc(getTile(position));
-	}
+	void removeSpawnNpc(const Position& position) { removeSpawnNpc(getTile(position)); }
 
 	// Returns all possible npc spawns on the target tile
 	SpawnNpcList getSpawnNpcList(const Tile* tile) const;
-	SpawnNpcList getSpawnNpcList(const Position &position) const;
+	SpawnNpcList getSpawnNpcList(const Position& position) const;
 	SpawnNpcList getSpawnNpcList(int x, int y, int z) const;
 
 	// Returns true if the map has been saved
 	// ie. it knows which file it should be saved to
-	bool hasFile() const noexcept {
-		return !filename.empty();
-	}
-	const std::string &getFilename() const noexcept {
-		return filename;
-	}
-	const std::string &getName() const noexcept {
-		return name;
-	}
-	void setName(const std::string &_name) noexcept {
-		name = _name;
-	}
+	bool hasFile() const noexcept { return !filename.empty(); }
+	const std::string& getFilename() const noexcept { return filename; }
+	const std::string& getName() const noexcept { return name; }
+	void setName(const std::string& _name) noexcept { name = _name; }
 
 	// Get map data
-	int getWidth() const {
-		return width;
-	}
-	int getHeight() const {
-		return height;
-	}
-	std::string getMapDescription() const {
-		return description;
-	}
-	std::string getHouseFilename() const {
-		return housefile;
-	}
-	std::string getSpawnFilename() const {
-		return spawnmonsterfile;
-	}
-	std::string getSpawnNpcFilename() const {
-		return spawnnpcfile;
-	}
+	int getWidth() const {return width;}
+	int getHeight() const {return height;}
+	std::string getMapDescription() const {return description;}
+	std::string getHouseFilename() const {return housefile;}
+	std::string getSpawnFilename() const {return spawnmonsterfile;}
+	std::string getSpawnNpcFilename() const {return spawnnpcfile;}
+	std::string getZoneFilename() const {return zonefile;}
 
 	// Set some map data
 	void setWidth(int new_width);
 	void setHeight(int new_height);
-	void setMapDescription(const std::string &new_description);
-	void setHouseFilename(const std::string &new_housefile);
-	void setSpawnMonsterFilename(const std::string &new_spawnmonsterfile);
-	void setSpawnNpcFilename(const std::string &new_npcfile);
+	void setMapDescription(const std::string& new_description);
+	void setHouseFilename(const std::string& new_housefile);
+	void setSpawnMonsterFilename(const std::string& new_spawnmonsterfile);
+	void setSpawnNpcFilename(const std::string& new_npcfile);
+	void setZoneFilename(const std::string& new_zonefile);
 
-	void flagAsNamed() noexcept {
-		unnamed = false;
-	}
+	void flagAsNamed() noexcept { unnamed = false; }
 
 	bool hasUniqueId(uint16_t uid) const;
 
@@ -166,6 +133,7 @@ class Map : public BaseMap {
 	std::string spawnmonsterfile; // The maps spawnmonsterfile
 	std::string spawnnpcfile; // The maps spawnnpcfile
 	std::string housefile; // The housefile
+	std::string zonefile; // The zonefile
 
 public:
 	Towns towns;
@@ -187,53 +155,52 @@ class Map : public BaseMap {
 
 public:
 	Waypoints waypoints;
+	Zones zones;
 
 private:
 	std::vector<uint16_t> uniqueIds;
 };
 
 template <typename ForeachType>
-inline void foreach_ItemOnMap(Map &map, ForeachType &foreach, bool selectedTiles) {
+inline void foreach_ItemOnMap(Map& map, ForeachType& foreach, bool selectedTiles)
+{
 	MapIterator tileiter = map.begin();
 	MapIterator end = map.end();
 	long long done = 0;
 
-	while (tileiter != end) {
+	while(tileiter != end) {
 		++done;
 		Tile* tile = (*tileiter)->get();
-		if (selectedTiles && !tile->isSelected()) {
+		if(selectedTiles && !tile->isSelected()) {
 			++tileiter;
 			continue;
 		}
 
-		if (tile->ground) {
-			foreach (map, tile, tile->ground, done)
-				;
+		if(tile->ground) {
+			foreach(map, tile, tile->ground, done);
 		}
 
 		std::queue<Container*> containers;
-		for (ItemVector::iterator itemiter = tile->items.begin(); itemiter != tile->items.end(); ++itemiter) {
+		for(ItemVector::iterator itemiter = tile->items.begin(); itemiter != tile->items.end(); ++itemiter) {
 			Item* item = *itemiter;
 			Container* container = dynamic_cast<Container*>(item);
-			foreach (map, tile, item, done)
-				;
-			if (container) {
+			foreach(map, tile, item, done);
+			if(container) {
 				containers.push(container);
 
 				do {
 					container = containers.front();
-					ItemVector &v = container->getVector();
-					for (ItemVector::iterator containeriter = v.begin(); containeriter != v.end(); ++containeriter) {
+					ItemVector& v = container->getVector();
+					for(ItemVector::iterator containeriter = v.begin(); containeriter != v.end(); ++containeriter) {
 						Item* i = *containeriter;
 						Container* c = dynamic_cast<Container*>(i);
-						foreach (map, tile, i, done)
-							;
-						if (c) {
+						foreach(map, tile, i, done);
+						if(c) {
 							containers.push(c);
 						}
 					}
 					containers.pop();
-				} while (containers.size());
+				} while(containers.size());
 			}
 		}
 		++tileiter;
@@ -241,28 +208,28 @@ inline void foreach_ItemOnMap(Map &map, ForeachType &foreach, bool selectedTiles
 }
 
 template <typename ForeachType>
-inline void foreach_TileOnMap(Map &map, ForeachType &foreach) {
+inline void foreach_TileOnMap(Map& map, ForeachType& foreach)
+{
 	MapIterator tileiter = map.begin();
 	MapIterator end = map.end();
 	long long done = 0;
 
-	while (tileiter != end) {
-		foreach (map, (*tileiter++)->get(), ++done)
-			;
-	}
+	while(tileiter != end)
+		foreach(map, (*tileiter++)->get(), ++done);
 }
 
 template <typename RemoveIfType>
-inline long long remove_if_TileOnMap(Map &map, RemoveIfType &remove_if) {
+inline long long remove_if_TileOnMap(Map& map, RemoveIfType& remove_if)
+{
 	MapIterator tileiter = map.begin();
 	MapIterator end = map.end();
 	long long done = 0;
 	long long removed = 0;
 	long long total = map.getTileCount();
 
-	while (tileiter != end) {
+	while(tileiter != end) {
 		Tile* tile = (*tileiter)->get();
-		if (remove_if(map, tile, removed, done, total)) {
+		if(remove_if(map, tile, removed, done, total)) {
 			map.setTile(tile->getPosition(), nullptr, true);
 			++removed;
 		}
@@ -274,42 +241,44 @@ inline long long remove_if_TileOnMap(Map &map, RemoveIfType &remove_if) {
 }
 
 template <typename RemoveIfType>
-inline int64_t RemoveItemOnMap(Map &map, RemoveIfType &condition, bool selectedOnly) {
+inline int64_t RemoveItemOnMap(Map& map, RemoveIfType& condition, bool selectedOnly) {
 	int64_t done = 0;
 	int64_t removed = 0;
 
 	MapIterator it = map.begin();
 	MapIterator end = map.end();
 
-	while (it != end) {
+	while(it != end) {
 		++done;
 		Tile* tile = (*it)->get();
-		if (selectedOnly && !tile->isSelected()) {
+		if(selectedOnly && !tile->isSelected()) {
 			++it;
 			continue;
 		}
 
-		if (tile->ground) {
-			if (condition(map, tile->ground, removed, done)) {
+		if(tile->ground) {
+			if(condition(map, tile->ground, removed, done)) {
 				delete tile->ground;
 				tile->ground = nullptr;
 				++removed;
 			}
 		}
 
-		for (auto iit = tile->items.begin(); iit != tile->items.end();) {
+		for(auto iit = tile->items.begin(); iit != tile->items.end();) {
 			Item* item = *iit;
-			if (condition(map, item, removed, done)) {
+			if(condition(map, item, removed, done)) {
 				iit = tile->items.erase(iit);
 				delete item;
 				++removed;
-			} else {
-				++iit;
 			}
+			else
+				++iit;
 		}
 		++it;
 	}
 	return removed;
 }
 
+int64_t RemoveMonstersOnMap(Map &map, bool selectedOnly);
+
 #endif
diff --git a/source/map_display.cpp b/source/map_display.cpp
index e8ff360c..06168797 100644
--- a/source/map_display.cpp
+++ b/source/map_display.cpp
@@ -690,6 +690,8 @@ void MapCanvas::OnMouseActionClick(wxMouseEvent &event) {
 				g_gui.SelectBrush(item->getRAWBrush(), TILESET_RAW);
 			}
 		}
+	} else if (event.AltDown()) {
+		OnMouseCameraClick(event);
 	} else if (g_gui.IsSelectionMode()) {
 		Selection &selection = editor.getSelection();
 		if (isPasting()) {
@@ -1038,6 +1040,7 @@ void MapCanvas::OnMouseActionRelease(wxMouseEvent &event) {
 	int move_x = last_click_map_x - mouse_map_x;
 	int move_y = last_click_map_y - mouse_map_y;
 	int move_z = last_click_map_z - floor;
+	OnMouseCameraRelease(event);
 
 	if (g_gui.IsSelectionMode()) {
 		if (dragging && (move_x != 0 || move_y != 0 || move_z != 0)) {
@@ -1997,7 +2000,8 @@ void MapCanvas::OnCopyPosition(wxCommandEvent &WXUNUSED(event)) {
 	Position minPos = editor.getSelection().minPosition();
 	Position maxPos = editor.getSelection().maxPosition();
 	if (minPos != maxPos) {
-		posToClipboard(minPos.x, minPos.y, minPos.z, maxPos.x, maxPos.y, maxPos.z);
+		int format = g_settings.getInteger(Config::COPY_AREA_FORMAT);
+		posToClipboard(minPos.x, minPos.y, minPos.z, maxPos.x, maxPos.y, maxPos.z, format);
 	} else {
 		int format = g_settings.getInteger(Config::COPY_POSITION_FORMAT);
 		posToClipboard(minPos.x, minPos.y, minPos.z, format);
diff --git a/source/map_drawer.cpp b/source/map_drawer.cpp
index 7e0fc4ac..a9b593cd 100644
--- a/source/map_drawer.cpp
+++ b/source/map_drawer.cpp
@@ -17,9 +17,7 @@
 
 #include "main.h"
 
-#ifdef __APPLE__
-	#include <GLUT/glut.h>
-#else
+#if defined(__LINUX__) || defined(__WINDOWS__)
 	#include <GL/glut.h>
 #endif
 
@@ -44,6 +42,7 @@
 #include "raw_brush.h"
 #include "table_brush.h"
 #include "waypoint_brush.h"
+#include "zone_brush.h"
 #include "light_drawer.h"
 
 DrawingOptions::DrawingOptions() {
@@ -119,9 +118,8 @@ bool DrawingOptions::isOnlyColors() const noexcept {
 }
 
 bool DrawingOptions::isTileIndicators() const noexcept {
-	if (isOnlyColors()) {
+	if (isOnlyColors())
 		return false;
-	}
 	return show_pickupables || show_moveables || show_houses || show_spawns_monster || show_spawns_npc;
 }
 
@@ -154,14 +152,12 @@ void MapDrawer::SetupVars() {
 	floor = canvas->GetFloor();
 
 	if (options.show_all_floors) {
-		if (floor < 8) {
+		if (floor < 8)
 			start_z = rme::MapGroundLayer;
-		} else {
+		else
 			start_z = std::min(rme::MapMaxLayer, floor + 2);
-		}
-	} else {
+	} else
 		start_z = floor;
-	}
 
 	end_z = floor;
 	superend_z = (floor > rme::MapGroundLayer ? 8 : 0);
@@ -219,20 +215,16 @@ void MapDrawer::Draw() {
 	DrawMap();
 	DrawDraggingShadow();
 	DrawHigherFloors();
-	if (options.dragging) {
+	if (options.dragging)
 		DrawSelectionBox();
-	}
 	DrawLiveCursors();
 	DrawBrush();
-	if (options.show_grid && zoom <= 10.f) {
+	if (options.show_grid && zoom <= 10.f)
 		DrawGrid();
-	}
-	if (options.show_ingame_box) {
+	if (options.show_ingame_box)
 		DrawIngameBox();
-	}
-	if (options.isTooltips()) {
+	if (options.isTooltips())
 		DrawTooltips();
-	}
 }
 
 void MapDrawer::DrawBackground() {
@@ -250,19 +242,17 @@ void MapDrawer::DrawBackground() {
 }
 
 inline int getFloorAdjustment(int floor) {
-	if (floor > rme::MapGroundLayer) { // Underground
+	if (floor > rme::MapGroundLayer) // Underground
 		return 0; // No adjustment
-	} else {
+	else
 		return rme::TileSize * (rme::MapGroundLayer - floor);
-	}
 }
 
 void MapDrawer::DrawShade(int map_z) {
 	if (map_z == end_z && start_z != end_z) {
 		bool only_colors = options.isOnlyColors();
-		if (!only_colors) {
+		if (!only_colors)
 			glDisable(GL_TEXTURE_2D);
-		}
 
 		float x = screensize_x * zoom;
 		float y = screensize_y * zoom;
@@ -274,9 +264,8 @@ void MapDrawer::DrawShade(int map_z) {
 		glVertex2f(0, 0);
 		glEnd();
 
-		if (!only_colors) {
+		if (!only_colors)
 			glEnable(GL_TEXTURE_2D);
-		}
 	}
 }
 
@@ -296,11 +285,10 @@ void MapDrawer::DrawMap() {
 	// The current house we're drawing
 	current_house_id = 0;
 	if (brush) {
-		if (brush->isHouse()) {
+		if (brush->isHouse())
 			current_house_id = brush->asHouse()->getHouseID();
-		} else if (brush->isHouseExit()) {
+		else if (brush->isHouseExit())
 			current_house_id = brush->asHouseExit()->getHouseID();
-		}
 	}
 
 	bool only_colors = options.isOnlyColors();
@@ -312,9 +300,8 @@ void MapDrawer::DrawMap() {
 		}
 
 		if (map_z >= end_z) {
-			if (!only_colors) {
+			if (!only_colors)
 				glEnable(GL_TEXTURE_2D);
-			}
 
 			int nd_start_x = start_x & ~3;
 			int nd_start_y = start_y & ~3;
@@ -325,9 +312,8 @@ void MapDrawer::DrawMap() {
 				for (int nd_map_y = nd_start_y; nd_map_y <= nd_end_y; nd_map_y += 4) {
 					QTreeNode* nd = editor.getMap().getLeaf(nd_map_x, nd_map_y);
 					if (!nd) {
-						if (!live_client) {
+						if (!live_client)
 							continue;
-						}
 						nd = editor.getMap().createLeaf(nd_map_x, nd_map_y);
 						nd->setVisible(false, false);
 					}
@@ -372,9 +358,8 @@ void MapDrawer::DrawMap() {
 				}
 			}
 
-			if (!only_colors) {
+			if (!only_colors)
 				glDisable(GL_TEXTURE_2D);
-			}
 
 			DrawPositionIndicator(map_z);
 		}
@@ -388,20 +373,17 @@ void MapDrawer::DrawMap() {
 		++end_y;
 	}
 
-	if (!only_colors) {
+	if (!only_colors)
 		glEnable(GL_TEXTURE_2D);
-	}
 }
 
 void MapDrawer::DrawSecondaryMap(int map_z) {
-	if (options.ingame) {
+	if (options.ingame)
 		return;
-	}
 
 	BaseMap* secondary_map = g_gui.secondary_map;
-	if (!secondary_map) {
+	if (!secondary_map)
 		return;
-	}
 
 	Position normal_pos;
 	Position to_pos(mouse_map_x, mouse_map_y, floor);
@@ -426,9 +408,8 @@ void MapDrawer::DrawSecondaryMap(int map_z) {
 			}
 
 			Tile* tile = secondary_map->getTile(pos);
-			if (!tile) {
+			if (!tile)
 				continue;
-			}
 
 			int draw_x, draw_y;
 			getDrawPosition(final_pos, draw_x, draw_y);
@@ -455,6 +436,10 @@ void MapDrawer::DrawSecondaryMap(int map_z) {
 					r = r / 3 * 2;
 					b = r / 3 * 2;
 				}
+				if (options.show_special_tiles && tile->hasZone(g_gui.zone_brush->getZone())) {
+					r = b / 3 * 2;
+					b = b / 3 * 2;
+				}
 				if (options.show_special_tiles && tile->getMapFlags() & TILESTATE_NOLOGOUT) {
 					b /= 2;
 				}
@@ -576,9 +561,8 @@ void MapDrawer::DrawGrid() {
 }
 
 void MapDrawer::DrawDraggingShadow() {
-	if (!dragging || options.ingame || editor.getSelection().isBusy()) {
+	if (!dragging || options.ingame || editor.getSelection().isBusy())
 		return;
-	}
 
 	glEnable(GL_TEXTURE_2D);
 
@@ -587,9 +571,8 @@ void MapDrawer::DrawDraggingShadow() {
 		int move_x = canvas->drag_start_x - mouse_map_x;
 		int move_y = canvas->drag_start_y - mouse_map_y;
 
-		if (move_x == 0 && move_y == 0 && move_z == 0) {
+		if (move_x == 0 && move_y == 0 && move_z == 0)
 			continue;
-		}
 
 		const Position &position = tile->getPosition();
 		int pos_z = position.z - move_z;
@@ -610,11 +593,10 @@ void MapDrawer::DrawDraggingShadow() {
 			Tile* dest_tile = editor.getMap().getTile(pos);
 
 			for (Item* item : items) {
-				if (dest_tile) {
+				if (dest_tile)
 					BlitItem(draw_x, draw_y, dest_tile, item, true, 160, 160, 160, 160);
-				} else {
+				else
 					BlitItem(draw_x, draw_y, pos, item, true, 160, 160, 160, 160);
-				}
 			}
 
 			if (options.show_monsters && tile->monster && tile->monster->isSelected()) {
@@ -637,9 +619,8 @@ void MapDrawer::DrawDraggingShadow() {
 }
 
 void MapDrawer::DrawHigherFloors() {
-	if (!options.transparent_floors || floor == 0 || floor == 8) {
+	if (!options.transparent_floors || floor == 0 || floor == 8)
 		return;
-	}
 
 	glEnable(GL_TEXTURE_2D);
 
@@ -647,9 +628,8 @@ void MapDrawer::DrawHigherFloors() {
 	for (int map_x = start_x; map_x <= end_x; map_x++) {
 		for (int map_y = start_y; map_y <= end_y; map_y++) {
 			Tile* tile = editor.getMap().getTile(map_x, map_y, map_z);
-			if (!tile) {
+			if (!tile)
 				continue;
-			}
 
 			int draw_x, draw_y;
 			getDrawPosition(tile->getPosition(), draw_x, draw_y);
@@ -664,9 +644,8 @@ void MapDrawer::DrawHigherFloors() {
 
 			bool hidden = options.hide_items_when_zoomed && zoom > 10.f;
 			if (!hidden && !tile->items.empty()) {
-				for (const Item* item : tile->items) {
+				for (const Item* item : tile->items)
 					BlitItem(draw_x, draw_y, tile, item, false, 255, 255, 255, 96);
-				}
 			}
 		}
 	}
@@ -724,9 +703,8 @@ void MapDrawer::DrawSelectionBox() {
 }
 
 void MapDrawer::DrawLiveCursors() {
-	if (options.ingame || !editor.IsLive()) {
+	if (options.ingame || !editor.IsLive())
 		return;
-	}
 
 	LiveSocket &live = editor.GetLive();
 	for (LiveCursor &cursor : live.getCursorList()) {
@@ -748,11 +726,10 @@ void MapDrawer::DrawLiveCursors() {
 		}
 
 		int offset;
-		if (cursor.pos.z <= rme::MapGroundLayer) {
+		if (cursor.pos.z <= rme::MapGroundLayer)
 			offset = (rme::MapGroundLayer - cursor.pos.z) * rme::TileSize;
-		} else {
+		else
 			offset = rme::TileSize * (floor - cursor.pos.z);
-		}
 
 		float draw_x = ((cursor.pos.x * rme::TileSize) - view_scroll_x) - offset;
 		float draw_y = ((cursor.pos.y * rme::TileSize) - view_scroll_y) - offset;
@@ -775,19 +752,18 @@ void MapDrawer::DrawBrush() {
 	Brush* brush = g_gui.GetCurrentBrush();
 
 	BrushColor brushColor = COLOR_BLANK;
-	if (brush->isTerrain() || brush->isTable() || brush->isCarpet()) {
+	if (brush->isTerrain() || brush->isTable() || brush->isCarpet())
 		brushColor = COLOR_BRUSH;
-	} else if (brush->isHouse()) {
+	else if (brush->isHouse())
 		brushColor = COLOR_HOUSE_BRUSH;
-	} else if (brush->isFlag()) {
+	else if (brush->isFlag())
 		brushColor = COLOR_FLAG_BRUSH;
-	} else if (brush->isSpawnMonster()) {
+	else if (brush->isSpawnMonster())
 		brushColor = COLOR_SPAWN_BRUSH;
-	} else if (brush->isSpawnNpc()) {
+	else if (brush->isSpawnNpc())
 		brushColor = COLOR_SPAWN_NPC_BRUSH;
-	} else if (brush->isEraser()) {
+	else if (brush->isEraser())
 		brushColor = COLOR_ERASER;
-	}
 
 	int adjustment = getFloorAdjustment(floor);
 
@@ -839,9 +815,8 @@ void MapDrawer::DrawBrush() {
 			}
 			glEnd();
 		} else {
-			if (brush->isRaw()) {
+			if (brush->isRaw())
 				glEnable(GL_TEXTURE_2D);
-			}
 
 			if (g_gui.GetBrushShape() == BRUSHSHAPE_SQUARE || brush->isSpawnMonster() || brush->isSpawnNpc()) {
 				if (brush->isRaw() || brush->isOptionalBorder()) {
@@ -864,19 +839,17 @@ void MapDrawer::DrawBrush() {
 					}
 
 					RAWBrush* raw_brush = nullptr;
-					if (brush->isRaw()) {
+					if (brush->isRaw())
 						raw_brush = brush->asRaw();
-					}
 
 					for (int y = start_y; y <= end_y; y++) {
 						int cy = y * rme::TileSize - view_scroll_y - adjustment;
 						for (int x = start_x; x <= end_x; x++) {
 							int cx = x * rme::TileSize - view_scroll_x - adjustment;
-							if (brush->isOptionalBorder()) {
+							if (brush->isOptionalBorder())
 								glColorCheck(brush, Position(x, y, floor));
-							} else {
+							else
 								BlitSpriteType(cx, cy, raw_brush->getItemType()->sprite, 160, 160, 160, 160);
-							}
 						}
 					}
 				} else {
@@ -928,9 +901,8 @@ void MapDrawer::DrawBrush() {
 				float radii = width / 2.0f + 0.005f;
 
 				RAWBrush* raw_brush = nullptr;
-				if (brush->isRaw()) {
+				if (brush->isRaw())
 					raw_brush = brush->asRaw();
-				}
 
 				for (int y = start_y - 1; y <= end_y + 1; y++) {
 					int cy = y * rme::TileSize - view_scroll_y - adjustment;
@@ -958,9 +930,8 @@ void MapDrawer::DrawBrush() {
 				}
 			}
 
-			if (brush->isRaw()) {
+			if (brush->isRaw())
 				glDisable(GL_TEXTURE_2D);
-			}
 		}
 	} else {
 		if (brush->isWall()) {
@@ -1023,22 +994,20 @@ void MapDrawer::DrawBrush() {
 			int cy = (mouse_map_y)*rme::TileSize - view_scroll_y - adjustment;
 			int cx = (mouse_map_x)*rme::TileSize - view_scroll_x - adjustment;
 			MonsterBrush* monster_brush = brush->asMonster();
-			if (monster_brush->canDraw(&editor.getMap(), Position(mouse_map_x, mouse_map_y, floor))) {
+			if (monster_brush->canDraw(&editor.getMap(), Position(mouse_map_x, mouse_map_y, floor)))
 				BlitCreature(cx, cy, monster_brush->getType()->outfit, SOUTH, 255, 255, 255, 160);
-			} else {
+			else
 				BlitCreature(cx, cy, monster_brush->getType()->outfit, SOUTH, 255, 64, 64, 160);
-			}
 			glDisable(GL_TEXTURE_2D);
 		} else if (brush->isNpc()) {
 			glEnable(GL_TEXTURE_2D);
 			int cy = (mouse_map_y)*rme::TileSize - view_scroll_y - getFloorAdjustment(floor);
 			int cx = (mouse_map_x)*rme::TileSize - view_scroll_x - getFloorAdjustment(floor);
 			NpcBrush* npcBrush = brush->asNpc();
-			if (npcBrush->canDraw(&editor.getMap(), Position(mouse_map_x, mouse_map_y, floor))) {
+			if (npcBrush->canDraw(&editor.getMap(), Position(mouse_map_x, mouse_map_y, floor)))
 				BlitCreature(cx, cy, npcBrush->getType()->outfit, SOUTH, 255, 255, 255, 160);
-			} else {
+			else
 				BlitCreature(cx, cy, npcBrush->getType()->outfit, SOUTH, 255, 64, 64, 160);
-			}
 			glDisable(GL_TEXTURE_2D);
 		} else if (!brush->isDoodad()) {
 			RAWBrush* raw_brush = nullptr;
@@ -1063,11 +1032,10 @@ void MapDrawer::DrawBrush() {
 									getColor(brush, Position(mouse_map_x + x, mouse_map_y + y, floor), r, g, b);
 									DrawBrushIndicator(cx, cy, brush, r, g, b);
 								} else {
-									if (brush->isHouseExit() || brush->isOptionalBorder()) {
+									if (brush->isHouseExit() || brush->isOptionalBorder())
 										glColorCheck(brush, Position(mouse_map_x + x, mouse_map_y + y, floor));
-									} else {
+									else
 										glColor(brushColor);
-									}
 
 									glBegin(GL_QUADS);
 									glVertex2f(cx, cy + rme::TileSize);
@@ -1089,11 +1057,10 @@ void MapDrawer::DrawBrush() {
 									getColor(brush, Position(mouse_map_x + x, mouse_map_y + y, floor), r, g, b);
 									DrawBrushIndicator(cx, cy, brush, r, g, b);
 								} else {
-									if (brush->isHouseExit() || brush->isOptionalBorder()) {
+									if (brush->isHouseExit() || brush->isOptionalBorder())
 										glColorCheck(brush, Position(mouse_map_x + x, mouse_map_y + y, floor));
-									} else {
+									else
 										glColor(brushColor);
-									}
 
 									glBegin(GL_QUADS);
 									glVertex2f(cx, cy + rme::TileSize);
@@ -1145,16 +1112,13 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Tile* tile, const Item*
 		return;
 	}
 
-	if (type.isMetaItem()) {
+	if (type.isMetaItem())
 		return;
-	}
-	if (!ephemeral && type.pickupable && !options.show_items) {
+	if (!ephemeral && type.pickupable && !options.show_items)
 		return;
-	}
 	GameSprite* sprite = type.sprite;
-	if (!sprite) {
+	if (!sprite)
 		return;
-	}
 
 	int screenx = draw_x - sprite->getDrawOffset().x;
 	int screeny = draw_y - sprite->getDrawOffset().y;
@@ -1182,23 +1146,22 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Tile* tile, const Item*
 			pattern_x = 0;
 		}
 	} else if (type.stackable) {
-		if (item->getSubtype() <= 1) {
+		if (item->getSubtype() <= 1)
 			subtype = 0;
-		} else if (item->getSubtype() <= 2) {
+		else if (item->getSubtype() <= 2)
 			subtype = 1;
-		} else if (item->getSubtype() <= 3) {
+		else if (item->getSubtype() <= 3)
 			subtype = 2;
-		} else if (item->getSubtype() <= 4) {
+		else if (item->getSubtype() <= 4)
 			subtype = 3;
-		} else if (item->getSubtype() < 10) {
+		else if (item->getSubtype() < 10)
 			subtype = 4;
-		} else if (item->getSubtype() < 25) {
+		else if (item->getSubtype() < 25)
 			subtype = 5;
-		} else if (item->getSubtype() < 50) {
+		else if (item->getSubtype() < 50)
 			subtype = 6;
-		} else {
+		else
 			subtype = 7;
-		}
 	}
 
 	if (!ephemeral && options.transparent_items && (!type.isGroundTile() || sprite->width > 1 || sprite->height > 1) && !type.isSplash() && (!type.isBorder || sprite->width > 1 || sprite->height > 1)) {
@@ -1215,16 +1178,14 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Tile* tile, const Item*
 		}
 	}
 
-	if (options.show_hooks && (type.hookSouth || type.hookEast)) {
+	if (options.show_hooks && (type.hookSouth || type.hookEast))
 		DrawHookIndicator(draw_x, draw_y, type);
-	}
 }
 
 void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Position &pos, const Item* item, bool ephemeral, int red, int green, int blue, int alpha) {
 	const ItemType &type = g_items.getItemType(item->getID());
-	if (type.id == 0) {
+	if (type.id == 0)
 		return;
-	}
 
 	if (!options.ingame && !ephemeral && item->isSelected()) {
 		red /= 2;
@@ -1244,16 +1205,13 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Position &pos, const It
 		return;
 	}
 
-	if (type.isMetaItem()) {
+	if (type.isMetaItem())
 		return;
-	}
-	if (!ephemeral && type.pickupable && options.show_items) {
+	if (!ephemeral && type.pickupable && options.show_items)
 		return;
-	}
 	GameSprite* sprite = type.sprite;
-	if (!sprite) {
+	if (!sprite)
 		return;
-	}
 
 	int screenx = draw_x - sprite->getDrawOffset().x;
 	int screeny = draw_y - sprite->getDrawOffset().y;
@@ -1282,23 +1240,22 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Position &pos, const It
 		}
 		*/
 	} else if (type.stackable) {
-		if (item->getSubtype() <= 1) {
+		if (item->getSubtype() <= 1)
 			subtype = 0;
-		} else if (item->getSubtype() <= 2) {
+		else if (item->getSubtype() <= 2)
 			subtype = 1;
-		} else if (item->getSubtype() <= 3) {
+		else if (item->getSubtype() <= 3)
 			subtype = 2;
-		} else if (item->getSubtype() <= 4) {
+		else if (item->getSubtype() <= 4)
 			subtype = 3;
-		} else if (item->getSubtype() < 10) {
+		else if (item->getSubtype() < 10)
 			subtype = 4;
-		} else if (item->getSubtype() < 25) {
+		else if (item->getSubtype() < 25)
 			subtype = 5;
-		} else if (item->getSubtype() < 50) {
+		else if (item->getSubtype() < 50)
 			subtype = 6;
-		} else {
+		else
 			subtype = 7;
-		}
 	}
 
 	if (!ephemeral && options.transparent_items && (!type.isGroundTile() || sprite->width > 1 || sprite->height > 1) && !type.isSplash() && (!type.isBorder || sprite->width > 1 || sprite->height > 1)) {
@@ -1315,21 +1272,18 @@ void MapDrawer::BlitItem(int &draw_x, int &draw_y, const Position &pos, const It
 		}
 	}
 
-	if (options.show_hooks && (type.hookSouth || type.hookEast) && zoom <= 3.0) {
+	if (options.show_hooks && (type.hookSouth || type.hookEast) && zoom <= 3.0)
 		DrawHookIndicator(draw_x, draw_y, type);
-	}
 }
 
 void MapDrawer::BlitSpriteType(int screenx, int screeny, uint32_t spriteid, int red, int green, int blue, int alpha) {
 	const ItemType &type = g_items.getItemType(spriteid);
-	if (type.id == 0) {
+	if (type.id == 0)
 		return;
-	}
 
 	GameSprite* sprite = type.sprite;
-	if (!sprite) {
+	if (!sprite)
 		return;
-	}
 
 	screenx -= sprite->getDrawOffset().x;
 	screeny -= sprite->getDrawOffset().y;
@@ -1346,9 +1300,8 @@ void MapDrawer::BlitSpriteType(int screenx, int screeny, uint32_t spriteid, int
 }
 
 void MapDrawer::BlitSpriteType(int screenx, int screeny, GameSprite* sprite, int red, int green, int blue, int alpha) {
-	if (!sprite) {
+	if (!sprite)
 		return;
-	}
 
 	screenx -= sprite->getDrawOffset().x;
 	screeny -= sprite->getDrawOffset().y;
@@ -1394,9 +1347,8 @@ void MapDrawer::BlitCreature(int screenx, int screeny, const Outfit &outfit, Dir
 		for (int pattern_y = 0; pattern_y < sprite->pattern_y; pattern_y++) {
 
 			// continue if we dont have this addon
-			if (pattern_y > 0 && !(outfit.lookAddon & (1 << (pattern_y - 1)))) {
+			if (pattern_y > 0 && !(outfit.lookAddon & (1 << (pattern_y - 1))))
 				continue;
-			}
 
 			for (int cx = 0; cx != sprite->width; ++cx) {
 				for (int cy = 0; cy != sprite->height; ++cy) {
@@ -1427,68 +1379,56 @@ void MapDrawer::BlitCreature(int screenx, int screeny, const Npc* npc, int red,
 }
 
 void MapDrawer::WriteTooltip(const Item* item, std::ostringstream &stream) {
-	if (!item) {
+	if (!item)
 		return;
-	}
 
 	const uint16_t id = item->getID();
-	if (id < 100) {
+	if (id < 100)
 		return;
-	}
 
 	const uint16_t unique = item->getUniqueID();
 	const uint16_t action = item->getActionID();
 	const std::string &text = item->getText();
-	if (unique == 0 && action == 0 && text.empty()) {
+	if (unique == 0 && action == 0 && text.empty())
 		return;
-	}
 
-	if (stream.tellp() > 0) {
+	if (stream.tellp() > 0)
 		stream << "\n";
-	}
 
 	stream << "id: " << id << "\n";
 
-	if (action > 0) {
+	if (action > 0)
 		stream << "aid: " << action << "\n";
-	}
-	if (unique > 0) {
+	if (unique > 0)
 		stream << "uid: " << unique << "\n";
-	}
-	if (!text.empty()) {
+	if (!text.empty())
 		stream << "text: " << text << "\n";
-	}
 }
 
 void MapDrawer::WriteTooltip(const Waypoint* waypoint, std::ostringstream &stream) {
-	if (stream.tellp() > 0) {
+	if (stream.tellp() > 0)
 		stream << "\n";
-	}
 	stream << "wp: " << waypoint->name << "\n";
 }
 
 void MapDrawer::DrawTile(TileLocation* location) {
-	if (!location) {
+	if (!location)
 		return;
-	}
 
 	Tile* tile = location->get();
-	if (!tile) {
+	if (!tile)
 		return;
-	}
 
-	if (options.show_only_modified && !tile->isModified()) {
+	if (options.show_only_modified && !tile->isModified())
 		return;
-	}
 
 	const Position &position = location->getPosition();
 	bool show_tooltips = options.isTooltips();
 
 	if (show_tooltips && location->getWaypointCount() > 0) {
 		Waypoint* waypoint = canvas->editor.getMap().waypoints.getWaypoint(position);
-		if (waypoint) {
+		if (waypoint)
 			WriteTooltip(waypoint, tooltip);
-		}
 	}
 
 	bool only_colors = options.isOnlyColors();
@@ -1550,6 +1490,17 @@ void MapDrawer::DrawTile(TileLocation* location) {
 				b = b / 3 * 2;
 			}
 
+			bool zone_active = tile->hasZone(g_gui.zone_brush->getZone());
+			if (showspecial && zone_active) {
+				r /= 2;
+				g /= 2;
+			}
+			if (showspecial && ((!tile->zones.empty() && !zone_active) || tile->zones.size() > 1)) {
+				r /= 1.3;
+				g /= 1.2;
+				b /= 1.1;
+			}
+
 			if (showspecial && tile->getMapFlags() & TILESTATE_NOLOGOUT) {
 				b /= 2;
 			}
@@ -1569,29 +1520,25 @@ void MapDrawer::DrawTile(TileLocation* location) {
 			}
 			glEnable(GL_TEXTURE_2D);
 		} else {
-			if (options.show_preview && zoom <= 2.0) {
+			if (options.show_preview && zoom <= 2.0)
 				tile->ground->animate();
-			}
 
 			BlitItem(draw_x, draw_y, tile, tile->ground, false, r, g, b);
 		}
 
-		if (show_tooltips && position.z == floor) {
+		if (show_tooltips && position.z == floor)
 			WriteTooltip(tile->ground, tooltip);
-		}
 	}
 
 	bool hidden = only_colors || (options.hide_items_when_zoomed && zoom > 10.f);
 
 	if (!hidden && !tile->items.empty()) {
 		for (Item* item : tile->items) {
-			if (show_tooltips && position.z == floor) {
+			if (show_tooltips && position.z == floor)
 				WriteTooltip(item, tooltip);
-			}
 
-			if (options.show_preview && zoom <= 2.0) {
+			if (options.show_preview && zoom <= 2.0)
 				item->animate();
-			}
 
 			if (item->isBorder()) {
 				BlitItem(draw_x, draw_y, tile, item, false, r, g, b);
@@ -1610,11 +1557,10 @@ void MapDrawer::DrawTile(TileLocation* location) {
 	}
 
 	if (show_tooltips) {
-		if (location->getWaypointCount() > 0) {
+		if (location->getWaypointCount() > 0)
 			MakeTooltip(draw_x, draw_y, tooltip.str(), 0, 255, 0);
-		} else {
+		else
 			MakeTooltip(draw_x, draw_y, tooltip.str());
-		}
 		tooltip.str("");
 	}
 }
@@ -1653,9 +1599,8 @@ void MapDrawer::DrawBrushIndicator(int x, int y, Brush* brush, uint8_t r, uint8_
 	// background
 	glColor4ub(r, g, b, 0xB4);
 	glBegin(GL_POLYGON);
-	for (int i = 0; i < 8; ++i) {
+	for (int i = 0; i < 8; ++i)
 		glVertex2i(vertexes[i][0] + x, vertexes[i][1] + y);
-	}
 	glEnd();
 
 	// borders
@@ -1693,14 +1638,12 @@ void MapDrawer::DrawHookIndicator(int x, int y, const ItemType &type) {
 }
 
 void MapDrawer::DrawTileIndicators(TileLocation* location) {
-	if (!location) {
+	if (!location)
 		return;
-	}
 
 	Tile* tile = location->get();
-	if (!tile) {
+	if (!tile)
 		return;
-	}
 
 	int x, y;
 	getDrawPosition(location->getPosition(), x, y);
@@ -1714,13 +1657,12 @@ void MapDrawer::DrawTileIndicators(TileLocation* location) {
 		for (const Item* item : tile->items) {
 			const ItemType &type = g_items.getItemType(item->getID());
 			if ((type.pickupable && options.show_pickupables) || (type.moveable && options.show_moveables)) {
-				if (type.pickupable && options.show_pickupables && type.moveable && options.show_moveables) {
+				if (type.pickupable && options.show_pickupables && type.moveable && options.show_moveables)
 					DrawIndicator(x, y, EDITOR_SPRITE_PICKUPABLE_MOVEABLE_ITEM, red, green, blue);
-				} else if (type.pickupable && options.show_pickupables) {
+				else if (type.pickupable && options.show_pickupables)
 					DrawIndicator(x, y, EDITOR_SPRITE_PICKUPABLE_ITEM, red, green, blue);
-				} else if (type.moveable && options.show_moveables) {
+				else if (type.moveable && options.show_moveables)
 					DrawIndicator(x, y, EDITOR_SPRITE_MOVEABLE_ITEM, red, green, blue);
-				}
 			}
 		}
 	}
@@ -1752,28 +1694,22 @@ void MapDrawer::DrawTileIndicators(TileLocation* location) {
 
 void MapDrawer::DrawIndicator(int x, int y, int indicator, uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
 	GameSprite* sprite = g_gui.gfx.getEditorSprite(indicator);
-	if (sprite == nullptr) {
+	if (sprite == nullptr)
 		return;
-	}
 
 	int textureId = sprite->getHardwareID(0, 0, 0, -1, 0, 0, 0, 0);
 	glBlitTexture(x, y, textureId, r, g, b, a, true);
 }
 
 void MapDrawer::DrawPositionIndicator(int z) {
-	if (z != pos_indicator.z
-		|| pos_indicator.x < start_x
-		|| pos_indicator.x > end_x
-		|| pos_indicator.y < start_y
-		|| pos_indicator.y > end_y) {
+	if (z != pos_indicator.z || pos_indicator.x < start_x || pos_indicator.x > end_x || pos_indicator.y < start_y || pos_indicator.y > end_y) {
 		return;
 	}
 
 	constexpr int duration = 5000;
 	const long time = pos_indicator_timer.Time();
-	if (time >= duration) {
+	if (time >= duration)
 		return;
-	}
 
 	int x, y;
 	getDrawPosition(pos_indicator, x, y);
@@ -1788,9 +1724,9 @@ void MapDrawer::DrawPositionIndicator(int z) {
 }
 
 void MapDrawer::DrawTooltips() {
-	if (!options.show_tooltips || tooltips.empty()) {
+#if defined(__LINUX__) || defined(__WINDOWS__)
+	if (!options.show_tooltips || tooltips.empty())
 		return;
-	}
 
 	glDisable(GL_TEXTURE_2D);
 
@@ -1814,9 +1750,8 @@ void MapDrawer::DrawTooltips() {
 			char_count++;
 			line_char_count++;
 
-			if (tooltip->ellipsis && char_count > (MapTooltip::MAX_CHARS + 3)) {
+			if (tooltip->ellipsis && char_count > (MapTooltip::MAX_CHARS + 3))
 				break;
-			}
 		}
 
 		float scale = zoom < 1.0f ? zoom : 1.0f;
@@ -1853,9 +1788,8 @@ void MapDrawer::DrawTooltips() {
 		// background
 		glColor4ub(tooltip->r, tooltip->g, tooltip->b, 255);
 		glBegin(GL_POLYGON);
-		for (int i = 0; i < 8; ++i) {
+		for (int i = 0; i < 8; ++i)
 			glVertex2f(vertexes[i][0], vertexes[i][1]);
-		}
 		glEnd();
 
 		// borders
@@ -1887,9 +1821,8 @@ void MapDrawer::DrawTooltips() {
 
 				if (tooltip->ellipsis && char_count >= MapTooltip::MAX_CHARS) {
 					glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, '.');
-					if (char_count >= (MapTooltip::MAX_CHARS + 2)) {
+					if (char_count >= (MapTooltip::MAX_CHARS + 2))
 						break;
-					}
 				} else if (!iscntrl(*c)) {
 					glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, *c);
 				}
@@ -1898,12 +1831,12 @@ void MapDrawer::DrawTooltips() {
 	}
 
 	glEnable(GL_TEXTURE_2D);
+#endif
 }
 
 void MapDrawer::MakeTooltip(int screenx, int screeny, const std::string &text, uint8_t r, uint8_t g, uint8_t b) {
-	if (text.empty()) {
+	if (text.empty())
 		return;
-	}
 
 	MapTooltip* tooltip = new MapTooltip(screenx, screeny, text, r, g, b);
 	tooltip->checkLineEnding();
@@ -1958,9 +1891,8 @@ void MapDrawer::TakeScreenshot(uint8_t* screenshot_buffer) {
 
 	glPixelStorei(GL_PACK_ALIGNMENT, 1); // 1 byte alignment
 
-	for (int i = 0; i < screensize_y; ++i) {
+	for (int i = 0; i < screensize_y; ++i)
 		glReadPixels(0, screensize_y - i, screensize_x, 1, GL_RGB, GL_UNSIGNED_BYTE, (GLubyte*)(screenshot_buffer) + 3 * screensize_x * i);
-	}
 }
 
 void MapDrawer::ShowPositionIndicator(const Position &position) {
@@ -1969,9 +1901,8 @@ void MapDrawer::ShowPositionIndicator(const Position &position) {
 }
 
 void MapDrawer::glBlitTexture(int x, int y, int textureId, int red, int green, int blue, int alpha, bool adjustZoom) {
-	if (textureId <= 0) {
+	if (textureId <= 0)
 		return;
-	}
 
 	glBindTexture(GL_TEXTURE_2D, textureId);
 	glColor4ub(uint8_t(red), uint8_t(green), uint8_t(blue), uint8_t(alpha));
@@ -2084,11 +2015,10 @@ void MapDrawer::glColor(MapDrawer::BrushColor color) {
 }
 
 void MapDrawer::glColorCheck(Brush* brush, const Position &pos) {
-	if (brush->canDraw(&editor.getMap(), pos)) {
+	if (brush->canDraw(&editor.getMap(), pos))
 		glColor(COLOR_VALID);
-	} else {
+	else
 		glColor(COLOR_INVALID);
-	}
 }
 
 void MapDrawer::drawRect(int x, int y, int w, int h, const wxColor &color, int width) {
@@ -2115,11 +2045,10 @@ void MapDrawer::drawFilledRect(int x, int y, int w, int h, const wxColor &color)
 
 void MapDrawer::getDrawPosition(const Position &position, int &x, int &y) {
 	int offset;
-	if (position.z <= rme::MapGroundLayer) {
+	if (position.z <= rme::MapGroundLayer)
 		offset = (rme::MapGroundLayer - position.z) * rme::TileSize;
-	} else {
+	else
 		offset = rme::TileSize * (floor - position.z);
-	}
 
 	x = ((position.x * rme::TileSize) - view_scroll_x) - offset;
 	y = ((position.y * rme::TileSize) - view_scroll_y) - offset;
diff --git a/source/monster_brush.cpp b/source/monster_brush.cpp
index 88e34d4f..09e594cc 100644
--- a/source/monster_brush.cpp
+++ b/source/monster_brush.cpp
@@ -29,31 +29,35 @@
 
 MonsterBrush::MonsterBrush(MonsterType* type) :
 	Brush(),
-	monster_type(type) {
+	monster_type(type)
+{
 	ASSERT(type->brush == nullptr);
 	type->brush = this;
 }
 
-MonsterBrush::~MonsterBrush() {
+MonsterBrush::~MonsterBrush()
+{
 	////
 }
 
-int MonsterBrush::getLookID() const {
+int MonsterBrush::getLookID() const
+{
 	return 0;
 }
 
-std::string MonsterBrush::getName() const {
-	if (monster_type) {
+std::string MonsterBrush::getName() const
+{
+	if(monster_type)
 		return monster_type->name;
-	}
 	return "Monster Brush";
 }
 
-bool MonsterBrush::canDraw(BaseMap* map, const Position &position) const {
+bool MonsterBrush::canDraw(BaseMap* map, const Position& position) const
+{
 	Tile* tile = map->getTile(position);
-	if (monster_type && tile && !tile->isBlocking()) {
-		if (tile->getLocation()->getSpawnMonsterCount() != 0 || g_settings.getInteger(Config::AUTO_CREATE_SPAWN_MONSTER)) {
-			if (tile->isPZ()) {
+	if(monster_type && tile && !tile->isBlocking()) {
+		if(tile->getLocation()->getSpawnMonsterCount() != 0 || g_settings.getInteger(Config::AUTO_CREATE_SPAWN_MONSTER)) {
+ 			if(tile->isPZ()) {
 				return false;
 			} else {
 				return true;
@@ -63,23 +67,37 @@ bool MonsterBrush::canDraw(BaseMap* map, const Position &position) const {
 	return false;
 }
 
-void MonsterBrush::undraw(BaseMap* map, Tile* tile) {
+void MonsterBrush::undraw(BaseMap* map, Tile* tile)
+{
 	delete tile->monster;
 	tile->monster = nullptr;
 }
 
-void MonsterBrush::draw(BaseMap* map, Tile* tile, void* parameter) {
+void MonsterBrush::drawMonster(BaseMap* map, Tile* tile, void* parameter)
+{
+	ASSERT(tile);
+	ASSERT(parameter);
+	if(canDraw(map, tile->getPosition())) {
+		undraw(map, tile);
+		if(monster_type) {
+			tile->monster = newd Monster(monster_type);
+			tile->monster->setSpawnMonsterTime(*(int*)parameter);
+		}
+	}
+}
+
+void MonsterBrush::draw(BaseMap* map, Tile* tile, void* parameter)
+{
 	ASSERT(tile);
 	ASSERT(parameter);
-	if (canDraw(map, tile->getPosition())) {
+	if(canDraw(map, tile->getPosition())) {
 		undraw(map, tile);
-		if (monster_type) {
-			if (tile->spawnMonster == nullptr && tile->getLocation()->getSpawnMonsterCount() == 0) {
+		if(monster_type) {
+			if(tile->spawnMonster == nullptr && tile->getLocation()->getSpawnMonsterCount() == 0) {
 				// manually place spawnMonster on location
 				tile->spawnMonster = newd SpawnMonster(1);
 			}
-			tile->monster = newd Monster(monster_type);
-			tile->monster->setSpawnMonsterTime(*(int*)parameter);
+			drawMonster(map, tile, parameter);
 		}
 	}
 }
diff --git a/source/monster_brush.h b/source/monster_brush.h
index 993b9a6d..9c4184ca 100644
--- a/source/monster_brush.h
+++ b/source/monster_brush.h
@@ -37,6 +37,7 @@ class MonsterBrush : public Brush {
 
 	virtual bool canDraw(BaseMap* map, const Position &position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
+	void drawMonster(BaseMap* map, Tile* tile, void* parameter);
 	void draw_creature(BaseMap* map, Tile* tile);
 	virtual void undraw(BaseMap* map, Tile* tile);
 
diff --git a/source/numbertextctrl.cpp b/source/numbertextctrl.cpp
index 7bab21cf..75e7d380 100644
--- a/source/numbertextctrl.cpp
+++ b/source/numbertextctrl.cpp
@@ -19,84 +19,95 @@
 #include "numbertextctrl.h"
 
 BEGIN_EVENT_TABLE(NumberTextCtrl, wxTextCtrl)
-EVT_KILL_FOCUS(NumberTextCtrl::OnKillFocus)
-EVT_TEXT_ENTER(wxID_ANY, NumberTextCtrl::OnTextEnter)
+	EVT_KILL_FOCUS(NumberTextCtrl::OnKillFocus)
+	EVT_TEXT_ENTER(wxID_ANY, NumberTextCtrl::OnTextEnter)
 END_EVENT_TABLE()
 
-NumberTextCtrl::NumberTextCtrl(wxWindow* parent, wxWindowID id, long value, long minvalue, long maxvalue, const wxPoint &pos, const wxSize &sz, long style, const wxString &name) :
+NumberTextCtrl::NumberTextCtrl(wxWindow* parent, wxWindowID id,
+		long value, long minvalue, long maxvalue,
+		const wxPoint& pos, const wxSize& sz,
+		long style, const wxString& name) :
 	wxTextCtrl(parent, id, (wxString() << value), pos, sz, style, wxTextValidator(wxFILTER_NUMERIC), name),
-	minval(minvalue), maxval(maxvalue), lastval(value) {
+	minval(minvalue), maxval(maxvalue), lastval(value)
+{
 	////
 }
 
-NumberTextCtrl::NumberTextCtrl(wxWindow* parent, wxWindowID id, long value, long minvalue, long maxvalue, long style, const wxString &name, const wxPoint &pos, const wxSize &sz) :
+NumberTextCtrl::NumberTextCtrl(wxWindow* parent, wxWindowID id,
+		long value, long minvalue, long maxvalue,
+		long style, const wxString& name,
+		const wxPoint& pos, const wxSize& sz) :
 	wxTextCtrl(parent, id, (wxString() << value), pos, sz, style, wxTextValidator(wxFILTER_NUMERIC), name),
-	minval(minvalue), maxval(maxvalue), lastval(value) {
+	minval(minvalue), maxval(maxvalue), lastval(value)
+{
 	////
 }
 
-NumberTextCtrl::~NumberTextCtrl() {
+NumberTextCtrl::~NumberTextCtrl()
+{
 	////
 }
 
-void NumberTextCtrl::OnKillFocus(wxFocusEvent &evt) {
+void NumberTextCtrl::OnKillFocus(wxFocusEvent& evt)
+{
 	CheckRange();
 	evt.Skip();
 }
 
-void NumberTextCtrl::OnTextEnter(wxCommandEvent &evt) {
+void NumberTextCtrl::OnTextEnter(wxCommandEvent& evt)
+{
 	CheckRange();
 }
 
-void NumberTextCtrl::SetIntValue(long value) {
+void NumberTextCtrl::SetIntValue(long value)
+{
 	wxString sv;
 	sv << value;
 	// Will generate events
 	SetValue(sv);
 }
 
-long NumberTextCtrl::GetIntValue() {
+long NumberTextCtrl::GetIntValue()
+{
 	long l;
-	if (GetValue().ToLong(&l)) {
+	if(GetValue().ToLong(&l))
 		return l;
-	}
 	return 0;
 }
 
-void NumberTextCtrl::SetMinValue(long value) {
-	if (value == minval) {
+void NumberTextCtrl::SetMinValue(long value)
+{
+	if(value == minval)
 		return;
-	}
 	minval = value;
 	CheckRange();
 }
 
-void NumberTextCtrl::SetMaxValue(long value) {
-	if (value == maxval) {
+void NumberTextCtrl::SetMaxValue(long value)
+{
+	if(value == maxval)
 		return;
-	}
 	maxval = value;
 	CheckRange();
 }
 
-void NumberTextCtrl::CheckRange() {
-	wxString text = GetValue();
+void NumberTextCtrl::CheckRange()
+{
+	auto text = GetValue().ToStdString();
 	wxString ntext;
 
-	for (size_t s = 0; s < text.size(); ++s) {
-		if (text[s] >= '0' && text[s] <= '9') {
+	for(size_t s = 0; s < text.size(); ++s) {
+		if(text[s] >= '0' && text[s] <= '9')
 			ntext.Append(text[s]);
-		}
 	}
 
 	// Check that value is in range
 	long v;
-	if (ntext.size() != 0 && ntext.ToLong(&v)) {
-		if (v < minval) {
+	if(ntext.size() != 0 && ntext.ToLong(&v)) {
+		if(v < minval)
 			v = minval;
-		} else if (v > maxval) {
+		else if(v > maxval)
 			v = maxval;
-		}
 
 		ntext.clear();
 		ntext << v;
@@ -107,8 +118,9 @@ void NumberTextCtrl::CheckRange() {
 	}
 
 	// Check if there was any change
-	if (ntext != text) {
+	if(ntext != text) {
 		// ChangeValue doesn't generate events
 		ChangeValue(ntext);
 	}
 }
+
diff --git a/source/palette_common.cpp b/source/palette_common.cpp
index 1bba4651..7b4ed274 100644
--- a/source/palette_common.cpp
+++ b/source/palette_common.cpp
@@ -29,141 +29,152 @@
 // Palette Panel
 
 BEGIN_EVENT_TABLE(PalettePanel, wxPanel)
-EVT_TIMER(PALETTE_DELAYED_REFRESH_TIMER, WaypointPalettePanel::OnRefreshTimer)
+	EVT_TIMER(PALETTE_DELAYED_REFRESH_TIMER, WaypointPalettePanel::OnRefreshTimer)
 END_EVENT_TABLE()
 
 PalettePanel::PalettePanel(wxWindow* parent, wxWindowID id, long style) :
 	wxPanel(parent, id, wxDefaultPosition, wxDefaultSize, style),
 	refresh_timer(this, PALETTE_DELAYED_REFRESH_TIMER),
-	last_brush_size(0) {
+	last_brush_size(0)
+{
 	////
 }
 
-PalettePanel::~PalettePanel() {
+PalettePanel::~PalettePanel()
+{
 	////
 }
 
-PaletteWindow* PalettePanel::GetParentPalette() const {
+PaletteWindow* PalettePanel::GetParentPalette() const
+{
 	const wxWindow* w = this;
-	while ((w = w->GetParent()) && dynamic_cast<const PaletteWindow*>(w) == nullptr)
-		;
+	while((w = w->GetParent()) && dynamic_cast<const PaletteWindow*>(w) == nullptr);
 	return const_cast<PaletteWindow*>(static_cast<const PaletteWindow*>(w));
 }
 
-void PalettePanel::InvalidateContents() {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::InvalidateContents()
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->InvalidateContents();
 	}
 }
 
-void PalettePanel::LoadCurrentContents() {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::LoadCurrentContents()
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->OnSwitchIn();
 	}
 	Fit();
 }
 
-void PalettePanel::LoadAllContents() {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::LoadAllContents()
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->LoadAllContents();
 	}
 }
 
-void PalettePanel::AddToolPanel(PalettePanel* panel) {
+void PalettePanel::AddToolPanel(PalettePanel* panel)
+{
 	wxSizer* sp_sizer = newd wxStaticBoxSizer(wxVERTICAL, this, panel->GetName());
 	sp_sizer->Add(panel, 0, wxEXPAND);
 	GetSizer()->Add(sp_sizer, 0, wxEXPAND);
 
-	// GetSizer()->SetDimension(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, wxDefaultCoord);
-	// GetSizer()->Layout();
+	//GetSizer()->SetDimension(wxDefaultCoord, wxDefaultCoord, wxDefaultCoord, wxDefaultCoord);
+	//GetSizer()->Layout();
 	Fit();
 	//
 
 	tool_bars.push_back(panel);
 }
 
-void PalettePanel::SetToolbarIconSize(bool large_icons) {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::SetToolbarIconSize(bool large_icons)
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->SetToolbarIconSize(large_icons);
 	}
 }
 
-wxString PalettePanel::GetName() const {
-	switch (GetType()) {
-		case TILESET_TERRAIN:
-			return "Terrain Palette";
-		case TILESET_DOODAD:
-			return "Doodad Palette";
-		case TILESET_ITEM:
-			return "Item Palette";
-		case TILESET_MONSTER:
-			return "Monster Palette";
-		case TILESET_NPC:
-			return "Npc Palette";
-		case TILESET_HOUSE:
-			return "House Palette";
-		case TILESET_RAW:
-			return "RAW Palette";
-		case TILESET_WAYPOINT:
-			return "Waypoint Palette";
-		case TILESET_UNKNOWN:
-			return "Unknown";
+wxString PalettePanel::GetName() const
+{
+	switch(GetType()) {
+		case TILESET_TERRAIN: return "Terrain Palette";
+		case TILESET_DOODAD: return "Doodad Palette";
+		case TILESET_ITEM: return "Item Palette";
+		case TILESET_MONSTER: return "Monster Palette";
+		case TILESET_NPC: return "Npc Palette";
+		case TILESET_HOUSE: return "House Palette";
+		case TILESET_RAW: return "RAW Palette";
+		case TILESET_WAYPOINT: return "Waypoint Palette";
+		case TILESET_ZONES: return "Zones Palette";
+		case TILESET_UNKNOWN: return "Unknown";
 	}
 	return wxEmptyString;
 }
 
-PaletteType PalettePanel::GetType() const {
+PaletteType PalettePanel::GetType() const
+{
 	return TILESET_UNKNOWN;
 }
 
-Brush* PalettePanel::GetSelectedBrush() const {
+Brush* PalettePanel::GetSelectedBrush() const
+{
 	return nullptr;
 }
 
-int PalettePanel::GetSelectedBrushSize() const {
+int PalettePanel::GetSelectedBrushSize() const
+{
 	return 0;
 }
 
-void PalettePanel::SelectFirstBrush() {
+void PalettePanel::SelectFirstBrush()
+{
 	// Do nothing
 }
 
-bool PalettePanel::SelectBrush(const Brush* whatbrush) {
+bool PalettePanel::SelectBrush(const Brush* whatbrush)
+{
 	return false;
 }
 
-void PalettePanel::OnUpdateBrushSize(BrushShape shape, int size) {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::OnUpdateBrushSize(BrushShape shape, int size)
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->OnUpdateBrushSize(shape, size);
 	}
 }
 
-void PalettePanel::OnSwitchIn() {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::OnSwitchIn()
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->OnSwitchIn();
 	}
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushSize(last_brush_size);
 }
 
-void PalettePanel::OnSwitchOut() {
+void PalettePanel::OnSwitchOut()
+{
 	last_brush_size = g_gui.GetBrushSize();
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->OnSwitchOut();
 	}
 }
 
-void PalettePanel::OnUpdate() {
-	for (ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
+void PalettePanel::OnUpdate()
+{
+	for(ToolBarList::iterator iter = tool_bars.begin(); iter != tool_bars.end(); ++iter) {
 		(*iter)->OnUpdate();
 	}
 }
 
-void PalettePanel::RefreshOtherPalettes() {
+void PalettePanel::RefreshOtherPalettes()
+{
 	refresh_timer.Start(100, true);
 }
 
-void PalettePanel::OnRefreshTimer(wxTimerEvent &) {
+void PalettePanel::OnRefreshTimer(wxTimerEvent&)
+{
 	g_gui.RefreshOtherPalettes(GetParentPalette());
 }
 
@@ -171,16 +182,16 @@ void PalettePanel::OnRefreshTimer(wxTimerEvent &) {
 // Size Page
 
 BEGIN_EVENT_TABLE(BrushSizePanel, wxPanel)
-EVT_TOGGLEBUTTON(PALETTE_BRUSHSHAPE_SQUARE, BrushSizePanel::OnClickSquareBrush)
-EVT_TOGGLEBUTTON(PALETTE_BRUSHSHAPE_CIRCLE, BrushSizePanel::OnClickCircleBrush)
-
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_0, BrushSizePanel::OnClickBrushSize0)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_1, BrushSizePanel::OnClickBrushSize1)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_2, BrushSizePanel::OnClickBrushSize2)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_4, BrushSizePanel::OnClickBrushSize4)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_6, BrushSizePanel::OnClickBrushSize6)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_8, BrushSizePanel::OnClickBrushSize8)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_11, BrushSizePanel::OnClickBrushSize11)
+	EVT_TOGGLEBUTTON(PALETTE_BRUSHSHAPE_SQUARE, BrushSizePanel::OnClickSquareBrush)
+	EVT_TOGGLEBUTTON(PALETTE_BRUSHSHAPE_CIRCLE, BrushSizePanel::OnClickCircleBrush)
+
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_0, BrushSizePanel::OnClickBrushSize0)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_1, BrushSizePanel::OnClickBrushSize1)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_2, BrushSizePanel::OnClickBrushSize2)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_4, BrushSizePanel::OnClickBrushSize4)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_6, BrushSizePanel::OnClickBrushSize6)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_8, BrushSizePanel::OnClickBrushSize8)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_BRUSHSIZE_11,BrushSizePanel::OnClickBrushSize11)
 END_EVENT_TABLE()
 
 BrushSizePanel::BrushSizePanel(wxWindow* parent) :
@@ -195,36 +206,45 @@ BrushSizePanel::BrushSizePanel(wxWindow* parent) :
 	brushsize4Button(nullptr),
 	brushsize6Button(nullptr),
 	brushsize8Button(nullptr),
-	brushsize11Button(nullptr) {
+	brushsize11Button(nullptr)
+{
 	////
 }
 
-void BrushSizePanel::InvalidateContents() {
-	if (loaded) {
+void BrushSizePanel::InvalidateContents()
+{
+	if(loaded) {
 		DestroyChildren();
 		SetSizer(nullptr);
 
-		brushshapeSquareButton = brushshapeCircleButton = brushsize0Button = brushsize1Button = brushsize2Button = brushsize4Button = brushsize6Button = brushsize8Button = brushsize11Button = nullptr;
+		brushshapeSquareButton =
+		brushshapeCircleButton =
+		brushsize0Button =
+		brushsize1Button =
+		brushsize2Button =
+		brushsize4Button =
+		brushsize6Button =
+		brushsize8Button =
+		brushsize11Button = nullptr;
 
 		loaded = false;
 	}
 }
 
-void BrushSizePanel::LoadCurrentContents() {
+void BrushSizePanel::LoadCurrentContents()
+{
 	LoadAllContents();
 }
 
-void BrushSizePanel::LoadAllContents() {
-	if (loaded) {
-		return;
-	}
+void BrushSizePanel::LoadAllContents()
+{
+	if(loaded) return;
 
-	wxSizer* size_sizer = newd wxBoxSizer(wxVERTICAL);
-	;
+	wxSizer* size_sizer = newd wxBoxSizer(wxVERTICAL);;
 	wxSizer* sub_sizer = newd wxBoxSizer(wxHORIZONTAL);
 	RenderSize render_size;
 
-	if (large_icons) {
+	if(large_icons) {
 		// 32x32
 		render_size = RENDER_SIZE_32x32;
 	} else {
@@ -233,44 +253,44 @@ void BrushSizePanel::LoadAllContents() {
 	}
 
 	sub_sizer->Add(brushshapeSquareButton = newd DCButton(this, PALETTE_BRUSHSHAPE_SQUARE, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_9x9));
-	brushshapeSquareButton->SetToolTip("Square brush");
+		brushshapeSquareButton->SetToolTip("Square brush");
 
 	sub_sizer->Add(brushshapeCircleButton = newd DCButton(this, PALETTE_BRUSHSHAPE_CIRCLE, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_CD_9x9));
-	brushshapeCircleButton->SetToolTip("Circle brush");
+		brushshapeCircleButton->SetToolTip("Circle brush");
 	brushshapeSquareButton->SetValue(true);
 
-	if (large_icons) {
+	if(large_icons) {
 		sub_sizer->AddSpacer(36);
 	} else {
 		sub_sizer->AddSpacer(18);
 	}
 
 	sub_sizer->Add(brushsize0Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_0, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_CD_1x1));
-	brushsize0Button->SetToolTip("Brush size 1");
-	brushsize0Button->SetValue(true);
+		brushsize0Button->SetToolTip("Brush size 1");
+		brushsize0Button->SetValue(true);
 
 	sub_sizer->Add(brushsize1Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_1, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_3x3));
-	brushsize1Button->SetToolTip("Brush size 2");
+		brushsize1Button->SetToolTip("Brush size 2");
 
-	if (large_icons) {
+	if(large_icons) {
 		size_sizer->Add(sub_sizer);
 		sub_sizer = newd wxBoxSizer(wxHORIZONTAL);
 	}
 
 	sub_sizer->Add(brushsize2Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_2, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_5x5));
-	brushsize2Button->SetToolTip("Brush size 3");
+		brushsize2Button->SetToolTip("Brush size 3");
 
 	sub_sizer->Add(brushsize4Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_4, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_7x7));
-	brushsize4Button->SetToolTip("Brush size 5");
+		brushsize4Button->SetToolTip("Brush size 5");
 
 	sub_sizer->Add(brushsize6Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_6, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_9x9));
-	brushsize6Button->SetToolTip("Brush size 7");
+		brushsize6Button->SetToolTip("Brush size 7");
 
 	sub_sizer->Add(brushsize8Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_8, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_15x15));
 	brushsize8Button->SetToolTip("Brush size 9");
 
 	sub_sizer->Add(brushsize11Button = newd DCButton(this, PALETTE_TERRAIN_BRUSHSIZE_11, wxDefaultPosition, DC_BTN_TOGGLE, render_size, EDITOR_SPRITE_BRUSH_SD_19x19));
-	brushsize11Button->SetToolTip("Brush size 12");
+		brushsize11Button->SetToolTip("Brush size 12");
 
 	size_sizer->Add(sub_sizer);
 	SetSizerAndFit(size_sizer);
@@ -278,11 +298,13 @@ void BrushSizePanel::LoadAllContents() {
 	loaded = true;
 }
 
-wxString BrushSizePanel::GetName() const {
+wxString BrushSizePanel::GetName() const
+{
 	return "Brush Size";
 }
 
-void BrushSizePanel::SetToolbarIconSize(bool d) {
+void BrushSizePanel::SetToolbarIconSize(bool d)
+{
 	InvalidateContents();
 	large_icons = d;
 }
@@ -291,8 +313,9 @@ void BrushSizePanel::OnSwitchIn() {
 	LoadCurrentContents();
 }
 
-void BrushSizePanel::OnUpdateBrushSize(BrushShape shape, int size) {
-	if (shape == BRUSHSHAPE_SQUARE) {
+void BrushSizePanel::OnUpdateBrushSize(BrushShape shape, int size)
+{
+	if(shape == BRUSHSHAPE_SQUARE) {
 		brushshapeCircleButton->SetValue(false);
 		brushshapeSquareButton->SetValue(true);
 
@@ -316,67 +339,40 @@ void BrushSizePanel::OnUpdateBrushSize(BrushShape shape, int size) {
 		brushsize11Button->SetSprite(EDITOR_SPRITE_BRUSH_CD_19x19);
 	}
 
-	if (brushsize0Button) {
-		brushsize0Button->SetValue(false);
-	}
-	if (brushsize1Button) {
-		brushsize1Button->SetValue(false);
-	}
-	if (brushsize2Button) {
-		brushsize2Button->SetValue(false);
-	}
-	if (brushsize4Button) {
-		brushsize4Button->SetValue(false);
-	}
-	if (brushsize6Button) {
-		brushsize6Button->SetValue(false);
-	}
-	if (brushsize8Button) {
-		brushsize8Button->SetValue(false);
-	}
-	if (brushsize11Button) {
-		brushsize11Button->SetValue(false);
-	}
+	if(brushsize0Button)  brushsize0Button->SetValue(false);
+	if(brushsize1Button)  brushsize1Button->SetValue(false);
+	if(brushsize2Button)  brushsize2Button->SetValue(false);
+	if(brushsize4Button)  brushsize4Button->SetValue(false);
+	if(brushsize6Button)  brushsize6Button->SetValue(false);
+	if(brushsize8Button)  brushsize8Button->SetValue(false);
+	if(brushsize11Button) brushsize11Button->SetValue(false);
 
-	switch (size) {
-		case 0:
-			brushsize0Button->SetValue(true);
-			break;
-		case 1:
-			brushsize1Button->SetValue(true);
-			break;
-		case 2:
-			brushsize2Button->SetValue(true);
-			break;
-		case 4:
-			brushsize4Button->SetValue(true);
-			break;
-		case 6:
-			brushsize6Button->SetValue(true);
-			break;
-		case 8:
-			brushsize8Button->SetValue(true);
-			break;
-		case 11:
-			brushsize11Button->SetValue(true);
-			break;
-		default:
-			brushsize0Button->SetValue(true);
-			break;
+	switch(size) {
+		case 0:  brushsize0Button->SetValue(true);  break;
+		case 1:  brushsize1Button->SetValue(true);  break;
+		case 2:  brushsize2Button->SetValue(true);  break;
+		case 4:  brushsize4Button->SetValue(true);  break;
+		case 6:  brushsize6Button->SetValue(true);  break;
+		case 8:  brushsize8Button->SetValue(true);  break;
+		case 11: brushsize11Button->SetValue(true); break;
+		default: brushsize0Button->SetValue(true);  break;
 	}
 }
 
-void BrushSizePanel::OnClickCircleBrush(wxCommandEvent &event) {
+void BrushSizePanel::OnClickCircleBrush(wxCommandEvent &event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushShape(BRUSHSHAPE_CIRCLE);
 }
 
-void BrushSizePanel::OnClickSquareBrush(wxCommandEvent &event) {
+void BrushSizePanel::OnClickSquareBrush(wxCommandEvent &event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushShape(BRUSHSHAPE_SQUARE);
 }
 
-void BrushSizePanel::OnClickBrushSize(int which) {
+void BrushSizePanel::OnClickBrushSize(int which)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushSize(which);
 }
@@ -385,20 +381,20 @@ void BrushSizePanel::OnClickBrushSize(int which) {
 // Tool Brush Panel
 
 BEGIN_EVENT_TABLE(BrushToolPanel, PalettePanel)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_OPTIONAL_BORDER_TOOL, BrushToolPanel::OnClickGravelButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_ERASER, BrushToolPanel::OnClickEraserButton)
-
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NORMAL_DOOR, BrushToolPanel::OnClickNormalDoorButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_LOCKED_DOOR, BrushToolPanel::OnClickLockedDoorButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_MAGIC_DOOR, BrushToolPanel::OnClickMagicDoorButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_QUEST_DOOR, BrushToolPanel::OnClickQuestDoorButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_HATCH_DOOR, BrushToolPanel::OnClickHatchDoorButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_WINDOW_DOOR, BrushToolPanel::OnClickWindowDoorButton)
-
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_PZ_TOOL, BrushToolPanel::OnClickPZBrushButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NOPVP_TOOL, BrushToolPanel::OnClickNOPVPBrushButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NOLOGOUT_TOOL, BrushToolPanel::OnClickNoLogoutBrushButton)
-EVT_TOGGLEBUTTON(PALETTE_TERRAIN_PVPZONE_TOOL, BrushToolPanel::OnClickPVPZoneBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_OPTIONAL_BORDER_TOOL, BrushToolPanel::OnClickGravelButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_ERASER, BrushToolPanel::OnClickEraserButton)
+
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NORMAL_DOOR,BrushToolPanel::OnClickNormalDoorButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_LOCKED_DOOR,BrushToolPanel::OnClickLockedDoorButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_MAGIC_DOOR, BrushToolPanel::OnClickMagicDoorButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_QUEST_DOOR, BrushToolPanel::OnClickQuestDoorButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_HATCH_DOOR, BrushToolPanel::OnClickHatchDoorButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_WINDOW_DOOR,BrushToolPanel::OnClickWindowDoorButton)
+
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_PZ_TOOL,BrushToolPanel::OnClickPZBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NOPVP_TOOL,BrushToolPanel::OnClickNOPVPBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_NOLOGOUT_TOOL,BrushToolPanel::OnClickNoLogoutBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_TERRAIN_PVPZONE_TOOL,BrushToolPanel::OnClickPVPZoneBrushButton)
 END_EVENT_TABLE()
 
 BrushToolPanel::BrushToolPanel(wxWindow* parent) :
@@ -416,36 +412,49 @@ BrushToolPanel::BrushToolPanel(wxWindow* parent) :
 	pzBrushButton(nullptr),
 	nopvpBrushButton(nullptr),
 	nologBrushButton(nullptr),
-	pvpzoneBrushButton(nullptr) {
+	pvpzoneBrushButton(nullptr)
+{
 	////
 }
 
-BrushToolPanel::~BrushToolPanel() {
+BrushToolPanel::~BrushToolPanel()
+{
 	////
 }
 
-void BrushToolPanel::InvalidateContents() {
-	if (loaded) {
+void BrushToolPanel::InvalidateContents()
+{
+	if(loaded) {
 		DestroyChildren();
 		SetSizer(nullptr);
 
-		optionalBorderButton = eraserButton = normalDoorButton = lockedDoorButton = magicDoorButton = questDoorButton = hatchDoorButton = windowDoorButton = pzBrushButton = nopvpBrushButton = nologBrushButton = pvpzoneBrushButton = nullptr;
+		optionalBorderButton =
+		eraserButton =
+		normalDoorButton =
+		lockedDoorButton =
+		magicDoorButton =
+		questDoorButton =
+		hatchDoorButton =
+		windowDoorButton =
+		pzBrushButton =
+		nopvpBrushButton =
+		nologBrushButton =
+		pvpzoneBrushButton = nullptr;
 
 		loaded = false;
 	}
 }
 
-void BrushToolPanel::LoadCurrentContents() {
+void BrushToolPanel::LoadCurrentContents()
+{
 	LoadAllContents();
 }
 
-void BrushToolPanel::LoadAllContents() {
-	if (loaded) {
-		return;
-	}
+void BrushToolPanel::LoadAllContents()
+{
+	if(loaded) return;
 
-	wxSizer* size_sizer = newd wxBoxSizer(wxVERTICAL);
-	;
+	wxSizer* size_sizer = newd wxBoxSizer(wxVERTICAL);;
 	wxSizer* sub_sizer = newd wxBoxSizer(wxHORIZONTAL);
 
 	/*RenderSize render_size;
@@ -457,32 +466,32 @@ void BrushToolPanel::LoadAllContents() {
 		render_size = RENDER_SIZE_16x16;
 	}*/
 
-	if (large_icons) {
+	if(large_icons) {
 		// Create the tool page with 32x32 icons
 
 		ASSERT(g_gui.optional_brush);
 		sub_sizer->Add(optionalBorderButton = newd BrushButton(this, g_gui.optional_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_OPTIONAL_BORDER_TOOL));
-		optionalBorderButton->SetToolTip("Optional Border Tool");
+			optionalBorderButton->SetToolTip("Optional Border Tool");
 
 		ASSERT(g_gui.eraser);
 		sub_sizer->Add(eraserButton = newd BrushButton(this, g_gui.eraser, RENDER_SIZE_32x32, PALETTE_TERRAIN_ERASER));
-		eraserButton->SetToolTip("Eraser");
+			eraserButton->SetToolTip("Eraser");
 
 		ASSERT(g_gui.pz_brush);
 		sub_sizer->Add(pzBrushButton = newd BrushButton(this, g_gui.pz_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_PZ_TOOL));
-		pzBrushButton->SetToolTip("PZ Tool");
+			pzBrushButton->SetToolTip("PZ Tool");
 
 		ASSERT(g_gui.rook_brush);
 		sub_sizer->Add(nopvpBrushButton = newd BrushButton(this, g_gui.rook_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_NOPVP_TOOL));
-		nopvpBrushButton->SetToolTip("NO PVP Tool");
+			nopvpBrushButton->SetToolTip("NO PVP Tool");
 
 		ASSERT(g_gui.nolog_brush);
 		sub_sizer->Add(nologBrushButton = newd BrushButton(this, g_gui.nolog_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_NOLOGOUT_TOOL));
-		nologBrushButton->SetToolTip("No Logout Tool");
+			nologBrushButton->SetToolTip("No Logout Tool");
 
 		ASSERT(g_gui.pvp_brush);
 		sub_sizer->Add(pvpzoneBrushButton = newd BrushButton(this, g_gui.pvp_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_PVPZONE_TOOL));
-		pvpzoneBrushButton->SetToolTip("PVP Zone Tool");
+			pvpzoneBrushButton->SetToolTip("PVP Zone Tool");
 
 		// New row
 		size_sizer->Add(sub_sizer);
@@ -490,84 +499,85 @@ void BrushToolPanel::LoadAllContents() {
 
 		ASSERT(g_gui.normal_door_brush);
 		sub_sizer->Add(normalDoorButton = newd BrushButton(this, g_gui.normal_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_NORMAL_DOOR));
-		normalDoorButton->SetToolTip("Normal Door Tool");
+			normalDoorButton->SetToolTip("Normal Door Tool");
 
 		ASSERT(g_gui.locked_door_brush);
 		sub_sizer->Add(lockedDoorButton = newd BrushButton(this, g_gui.locked_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_LOCKED_DOOR));
-		lockedDoorButton->SetToolTip("Locked Door Tool");
+			lockedDoorButton->SetToolTip("Locked Door Tool");
 
 		ASSERT(g_gui.magic_door_brush);
 		sub_sizer->Add(magicDoorButton = newd BrushButton(this, g_gui.magic_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_MAGIC_DOOR));
-		magicDoorButton->SetToolTip("Magic Door Tool");
+			magicDoorButton->SetToolTip("Magic Door Tool");
 
 		ASSERT(g_gui.quest_door_brush);
 		sub_sizer->Add(questDoorButton = newd BrushButton(this, g_gui.quest_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_QUEST_DOOR));
-		questDoorButton->SetToolTip("Quest Door Tool");
+			questDoorButton->SetToolTip("Quest Door Tool");
 
 		ASSERT(g_gui.hatch_door_brush);
 		sub_sizer->Add(hatchDoorButton = newd BrushButton(this, g_gui.hatch_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_HATCH_DOOR));
-		hatchDoorButton->SetToolTip("Hatch Window Tool");
+			hatchDoorButton->SetToolTip("Hatch Window Tool");
 
 		ASSERT(g_gui.window_door_brush);
 		sub_sizer->Add(windowDoorButton = newd BrushButton(this, g_gui.window_door_brush, RENDER_SIZE_32x32, PALETTE_TERRAIN_WINDOW_DOOR));
-		windowDoorButton->SetToolTip("Window Tool");
+			windowDoorButton->SetToolTip("Window Tool");
 	} else {
 		// Create the tool page with 16x16 icons
 		// Create tool window #1
 
 		ASSERT(g_gui.optional_brush);
 		sub_sizer->Add(optionalBorderButton = newd BrushButton(this, g_gui.optional_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_OPTIONAL_BORDER_TOOL));
-		optionalBorderButton->SetToolTip("Optional Border Tool");
+			optionalBorderButton->SetToolTip("Optional Border Tool");
 
 		ASSERT(g_gui.eraser);
 		sub_sizer->Add(eraserButton = newd BrushButton(this, g_gui.eraser, RENDER_SIZE_16x16, PALETTE_TERRAIN_ERASER));
-		eraserButton->SetToolTip("Eraser");
+			eraserButton->SetToolTip("Eraser");
 
 		sub_sizer->AddSpacer(20);
 
 		ASSERT(g_gui.normal_door_brush);
 		sub_sizer->Add(normalDoorButton = newd BrushButton(this, g_gui.normal_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_NORMAL_DOOR));
-		normalDoorButton->SetToolTip("Normal Door Tool");
+			normalDoorButton->SetToolTip("Normal Door Tool");
 
 		ASSERT(g_gui.locked_door_brush);
 		sub_sizer->Add(lockedDoorButton = newd BrushButton(this, g_gui.locked_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_LOCKED_DOOR));
-		lockedDoorButton->SetToolTip("Locked Door Tool");
+			lockedDoorButton->SetToolTip("Locked Door Tool");
 
 		ASSERT(g_gui.magic_door_brush);
 		sub_sizer->Add(magicDoorButton = newd BrushButton(this, g_gui.magic_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_MAGIC_DOOR));
-		magicDoorButton->SetToolTip("Magic Door Tool");
+			magicDoorButton->SetToolTip("Magic Door Tool");
 
 		ASSERT(g_gui.quest_door_brush);
 		sub_sizer->Add(questDoorButton = newd BrushButton(this, g_gui.quest_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_QUEST_DOOR));
-		questDoorButton->SetToolTip("Quest Door Tool");
+			questDoorButton->SetToolTip("Quest Door Tool");
 
 		ASSERT(g_gui.hatch_door_brush);
 		sub_sizer->Add(hatchDoorButton = newd BrushButton(this, g_gui.hatch_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_HATCH_DOOR));
-		hatchDoorButton->SetToolTip("Hatch Window Tool");
+			hatchDoorButton->SetToolTip("Hatch Window Tool");
 
 		ASSERT(g_gui.window_door_brush);
 		sub_sizer->Add(windowDoorButton = newd BrushButton(this, g_gui.window_door_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_WINDOW_DOOR));
-		windowDoorButton->SetToolTip("Window Tool");
+			windowDoorButton->SetToolTip("Window Tool");
 
 		// Next row
 		size_sizer->Add(sub_sizer);
 		sub_sizer = newd wxBoxSizer(wxHORIZONTAL);
 
+
 		ASSERT(g_gui.pz_brush);
 		sub_sizer->Add(pzBrushButton = newd BrushButton(this, g_gui.pz_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_PZ_TOOL));
-		pzBrushButton->SetToolTip("PZ Tool");
+			pzBrushButton->SetToolTip("PZ Tool");
 
 		ASSERT(g_gui.rook_brush);
 		sub_sizer->Add(nopvpBrushButton = newd BrushButton(this, g_gui.rook_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_NOPVP_TOOL));
-		nopvpBrushButton->SetToolTip("NO PVP Tool");
+			nopvpBrushButton->SetToolTip("NO PVP Tool");
 
 		ASSERT(g_gui.nolog_brush);
 		sub_sizer->Add(nologBrushButton = newd BrushButton(this, g_gui.nolog_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_NOLOGOUT_TOOL));
-		nologBrushButton->SetToolTip("No Logout Tool");
+			nologBrushButton->SetToolTip("No Logout Tool");
 
 		ASSERT(g_gui.pvp_brush);
 		sub_sizer->Add(pvpzoneBrushButton = newd BrushButton(this, g_gui.pvp_brush, RENDER_SIZE_16x16, PALETTE_TERRAIN_PVPZONE_TOOL));
-		pvpzoneBrushButton->SetToolTip("PVP Zone Tool");
+			pvpzoneBrushButton->SetToolTip("PVP Zone Tool");
 	}
 
 	size_sizer->Add(sub_sizer);
@@ -576,17 +586,20 @@ void BrushToolPanel::LoadAllContents() {
 	loaded = true;
 }
 
-wxString BrushToolPanel::GetName() const {
+wxString BrushToolPanel::GetName() const
+{
 	return "Tools";
 }
 
-void BrushToolPanel::SetToolbarIconSize(bool d) {
+void BrushToolPanel::SetToolbarIconSize(bool d)
+{
 	InvalidateContents();
 	large_icons = d;
 }
 
-void BrushToolPanel::DeselectAll() {
-	if (loaded) {
+void BrushToolPanel::DeselectAll()
+{
+	if(loaded) {
 		optionalBorderButton->SetValue(false);
 		eraserButton->SetValue(false);
 		normalDoorButton->SetValue(false);
@@ -602,76 +615,66 @@ void BrushToolPanel::DeselectAll() {
 	}
 }
 
-Brush* BrushToolPanel::GetSelectedBrush() const {
-	if (optionalBorderButton->GetValue()) {
+Brush* BrushToolPanel::GetSelectedBrush() const
+{
+	if(optionalBorderButton->GetValue())
 		return g_gui.optional_brush;
-	}
-	if (eraserButton->GetValue()) {
+	if(eraserButton->GetValue())
 		return g_gui.eraser;
-	}
-	if (normalDoorButton->GetValue()) {
+	if(normalDoorButton->GetValue())
 		return g_gui.normal_door_brush;
-	}
-	if (lockedDoorButton->GetValue()) {
+	if(lockedDoorButton->GetValue())
 		return g_gui.locked_door_brush;
-	}
-	if (magicDoorButton->GetValue()) {
+	if(magicDoorButton->GetValue())
 		return g_gui.magic_door_brush;
-	}
-	if (questDoorButton->GetValue()) {
+	if(questDoorButton->GetValue())
 		return g_gui.quest_door_brush;
-	}
-	if (hatchDoorButton->GetValue()) {
+	if(hatchDoorButton->GetValue())
 		return g_gui.hatch_door_brush;
-	}
-	if (windowDoorButton->GetValue()) {
+	if(windowDoorButton->GetValue())
 		return g_gui.window_door_brush;
-	}
-	if (pzBrushButton->GetValue()) {
+	if(pzBrushButton->GetValue())
 		return g_gui.pz_brush;
-	}
-	if (nopvpBrushButton->GetValue()) {
+	if(nopvpBrushButton->GetValue())
 		return g_gui.rook_brush;
-	}
-	if (nologBrushButton->GetValue()) {
+	if(nologBrushButton->GetValue())
 		return g_gui.nolog_brush;
-	}
-	if (pvpzoneBrushButton->GetValue()) {
+	if(pvpzoneBrushButton->GetValue())
 		return g_gui.pvp_brush;
-	}
 	return nullptr;
 }
 
-bool BrushToolPanel::SelectBrush(const Brush* whatbrush) {
+bool BrushToolPanel::SelectBrush(const Brush* whatbrush)
+{
 	BrushButton* button = nullptr;
-	if (whatbrush == g_gui.optional_brush) {
+	if(whatbrush == g_gui.optional_brush) {
 		button = optionalBorderButton;
-	} else if (whatbrush == g_gui.eraser) {
+	} else if(whatbrush == g_gui.eraser) {
 		button = eraserButton;
-	} else if (whatbrush == g_gui.normal_door_brush) {
+	} else if(whatbrush == g_gui.normal_door_brush) {
 		button = normalDoorButton;
-	} else if (whatbrush == g_gui.locked_door_brush) {
+	} else if(whatbrush == g_gui.locked_door_brush) {
 		button = lockedDoorButton;
-	} else if (whatbrush == g_gui.magic_door_brush) {
+	} else if(whatbrush == g_gui.magic_door_brush) {
 		button = magicDoorButton;
-	} else if (whatbrush == g_gui.quest_door_brush) {
+	} else if(whatbrush == g_gui.quest_door_brush) {
 		button = questDoorButton;
-	} else if (whatbrush == g_gui.hatch_door_brush) {
+	} else if(whatbrush == g_gui.hatch_door_brush) {
 		button = hatchDoorButton;
-	} else if (whatbrush == g_gui.window_door_brush) {
+	} else if(whatbrush == g_gui.window_door_brush) {
 		button = windowDoorButton;
-	} else if (whatbrush == g_gui.pz_brush) {
+	} else if(whatbrush == g_gui.pz_brush) {
 		button = pzBrushButton;
-	} else if (whatbrush == g_gui.rook_brush) {
+	} else if(whatbrush == g_gui.rook_brush) {
 		button = nopvpBrushButton;
-	} else if (whatbrush == g_gui.nolog_brush) {
+	} else if(whatbrush == g_gui.nolog_brush) {
 		button = nologBrushButton;
-	} else if (whatbrush == g_gui.pvp_brush) {
+	} else if(whatbrush == g_gui.pvp_brush) {
 		button = pvpzoneBrushButton;
 	}
 
 	DeselectAll();
-	if (button) {
+	if(button) {
 		button->SetValue(true);
 		return true;
 	}
@@ -679,66 +682,79 @@ bool BrushToolPanel::SelectBrush(const Brush* whatbrush) {
 	return false;
 }
 
-void BrushToolPanel::OnSwitchIn() {
+void BrushToolPanel::OnSwitchIn()
+{
 	LoadCurrentContents();
 }
 
-void BrushToolPanel::OnClickGravelButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickGravelButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.optional_brush);
 }
 
-void BrushToolPanel::OnClickEraserButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickEraserButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.eraser);
 }
 
-void BrushToolPanel::OnClickNormalDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickNormalDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.normal_door_brush);
 }
 
-void BrushToolPanel::OnClickLockedDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickLockedDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.locked_door_brush);
 }
 
-void BrushToolPanel::OnClickMagicDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickMagicDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.magic_door_brush);
 }
 
-void BrushToolPanel::OnClickQuestDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickQuestDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.quest_door_brush);
 }
 
-void BrushToolPanel::OnClickHatchDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickHatchDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.hatch_door_brush);
 }
 
-void BrushToolPanel::OnClickWindowDoorButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickWindowDoorButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.window_door_brush);
 }
 
-void BrushToolPanel::OnClickPZBrushButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickPZBrushButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.pz_brush);
 }
 
-void BrushToolPanel::OnClickNOPVPBrushButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickNOPVPBrushButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.rook_brush);
 }
 
-void BrushToolPanel::OnClickNoLogoutBrushButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickNoLogoutBrushButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.nolog_brush);
 }
 
-void BrushToolPanel::OnClickPVPZoneBrushButton(wxCommandEvent &event) {
+void BrushToolPanel::OnClickPVPZoneBrushButton(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush(g_gui.pvp_brush);
 }
@@ -747,23 +763,26 @@ void BrushToolPanel::OnClickPVPZoneBrushButton(wxCommandEvent &event) {
 // Brush Button
 
 BEGIN_EVENT_TABLE(BrushButton, ItemToggleButton)
-EVT_KEY_DOWN(BrushButton::OnKey)
+	EVT_KEY_DOWN(BrushButton::OnKey)
 END_EVENT_TABLE()
 
 BrushButton::BrushButton(wxWindow* parent, Brush* _brush, RenderSize sz, uint32_t id) :
 	ItemToggleButton(parent, sz, uint16_t(0), id),
-	brush(_brush) {
+	brush(_brush)
+{
 	ASSERT(sz != RENDER_SIZE_64x64);
 	ASSERT(brush);
 	SetSprite(brush->getLookID());
 	SetToolTip(wxstr(brush->getName()));
 }
 
-BrushButton::~BrushButton() {
+BrushButton::~BrushButton()
+{
 	////
 }
 
-void BrushButton::OnKey(wxKeyEvent &event) {
+void BrushButton::OnKey(wxKeyEvent& event)
+{
 	g_gui.AddPendingCanvasEvent(event);
 }
 
@@ -772,27 +791,28 @@ void BrushButton::OnKey(wxKeyEvent &event) {
 
 BEGIN_EVENT_TABLE(BrushThicknessPanel, PalettePanel)
 #ifdef __WINDOWS__
-// This only works in wxmsw
-EVT_COMMAND_SCROLL_CHANGED(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	// This only works in wxmsw
+	EVT_COMMAND_SCROLL_CHANGED(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
 #else
-EVT_COMMAND_SCROLL_TOP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_BOTTOM(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_LINEUP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_LINEDOWN(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_PAGEUP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_PAGEDOWN(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
-EVT_COMMAND_SCROLL_THUMBRELEASE(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_TOP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_BOTTOM(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_LINEUP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_LINEDOWN(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_PAGEUP(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_PAGEDOWN(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
+	EVT_COMMAND_SCROLL_THUMBRELEASE(PALETTE_DOODAD_SLIDER, BrushThicknessPanel::OnScroll)
 #endif
 
-EVT_CHECKBOX(PALETTE_DOODAD_USE_THICKNESS, BrushThicknessPanel::OnClickCustomThickness)
+	EVT_CHECKBOX(PALETTE_DOODAD_USE_THICKNESS, BrushThicknessPanel::OnClickCustomThickness)
 END_EVENT_TABLE()
 
 BrushThicknessPanel::BrushThicknessPanel(wxWindow* parent) :
-	PalettePanel(parent, wxID_ANY) {
+	PalettePanel(parent, wxID_ANY)
+{
 	wxSizer* thickness_sizer = newd wxBoxSizer(wxVERTICAL);
 
 	wxSizer* thickness_sub_sizer = newd wxBoxSizer(wxHORIZONTAL);
-	thickness_sub_sizer->Add(20, 10);
+	thickness_sub_sizer->Add(20,10);
 	use_button = newd wxCheckBox(this, PALETTE_DOODAD_USE_THICKNESS, "Use custom thickness");
 	thickness_sub_sizer->Add(use_button);
 	thickness_sizer->Add(thickness_sub_sizer, 1, wxEXPAND);
@@ -803,33 +823,39 @@ BrushThicknessPanel::BrushThicknessPanel(wxWindow* parent) :
 	SetSizerAndFit(thickness_sizer);
 }
 
-BrushThicknessPanel::~BrushThicknessPanel() {
+BrushThicknessPanel::~BrushThicknessPanel()
+{
 	////
 }
 
-wxString BrushThicknessPanel::GetName() const {
+wxString BrushThicknessPanel::GetName() const
+{
 	return "Brush Thickness";
 }
 
-void BrushThicknessPanel::OnScroll(wxScrollEvent &event) {
-	static const int lookup_table[10] = { 1, 2, 3, 5, 8, 13, 23, 35, 50, 80 };
+void BrushThicknessPanel::OnScroll(wxScrollEvent& event)
+{
+	static const int lookup_table[10] = {1,2,3,5,8,13,23,35,50,80};
 	use_button->SetValue(true);
 
 	ASSERT(event.GetPosition() >= 1);
 	ASSERT(event.GetPosition() <= 10);
 
-	// printf("SELECT[%d] = %d\n", event.GetPosition()-1, lookup_table[event.GetPosition()-1]);
+	//printf("SELECT[%d] = %d\n", event.GetPosition()-1, lookup_table[event.GetPosition()-1]);
 	g_gui.ActivatePalette(GetParentPalette());
-	g_gui.SetBrushThickness(true, lookup_table[event.GetPosition() - 1], 100);
+	g_gui.SetBrushThickness(true, lookup_table[event.GetPosition()-1], 100);
 }
 
-void BrushThicknessPanel::OnClickCustomThickness(wxCommandEvent &event) {
+void BrushThicknessPanel::OnClickCustomThickness(wxCommandEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushThickness(event.IsChecked());
 }
 
-void BrushThicknessPanel::OnSwitchIn() {
-	static const int lookup_table[10] = { 1, 2, 3, 5, 8, 13, 23, 35, 50, 80 };
+void BrushThicknessPanel::OnSwitchIn()
+{
+	static const int lookup_table[10] = {1,2,3,5,8,13,23,35,50,80};
 	g_gui.ActivatePalette(GetParentPalette());
-	g_gui.SetBrushThickness(lookup_table[slider->GetValue() - 1], 100);
+	g_gui.SetBrushThickness(lookup_table[slider->GetValue()-1], 100);
 }
+
diff --git a/source/palette_monster.cpp b/source/palette_monster.cpp
index ddcf49c7..1d508ac8 100644
--- a/source/palette_monster.cpp
+++ b/source/palette_monster.cpp
@@ -29,20 +29,23 @@
 // Monster palette
 
 BEGIN_EVENT_TABLE(MonsterPalettePanel, PalettePanel)
-EVT_CHOICE(PALETTE_MONSTER_TILESET_CHOICE, MonsterPalettePanel::OnTilesetChange)
+	EVT_CHOICE(PALETTE_MONSTER_TILESET_CHOICE, MonsterPalettePanel::OnTilesetChange)
 
-EVT_LISTBOX(PALETTE_MONSTER_LISTBOX, MonsterPalettePanel::OnListBoxChange)
+	EVT_LISTBOX(PALETTE_MONSTER_LISTBOX, MonsterPalettePanel::OnListBoxChange)
 
-EVT_TOGGLEBUTTON(PALETTE_MONSTER_BRUSH_BUTTON, MonsterPalettePanel::OnClickMonsterBrushButton)
-EVT_TOGGLEBUTTON(PALETTE_SPAWN_MONSTER_BRUSH_BUTTON, MonsterPalettePanel::OnClickSpawnMonsterBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_MONSTER_BRUSH_BUTTON, MonsterPalettePanel::OnClickMonsterBrushButton)
+	EVT_TOGGLEBUTTON(PALETTE_SPAWN_MONSTER_BRUSH_BUTTON, MonsterPalettePanel::OnClickSpawnMonsterBrushButton)
 
-EVT_SPINCTRL(PALETTE_MONSTER_SPAWN_TIME, MonsterPalettePanel::OnChangeSpawnMonsterTime)
-EVT_SPINCTRL(PALETTE_MONSTER_SPAWN_SIZE, MonsterPalettePanel::OnChangeSpawnMonsterSize)
+	EVT_SPINCTRL(PALETTE_MONSTER_SPAWN_TIME, MonsterPalettePanel::OnChangeSpawnMonsterTime)
+	EVT_SPINCTRL(PALETTE_MONSTER_SPAWN_SIZE, MonsterPalettePanel::OnChangeSpawnMonsterSize)
+
+	EVT_TEXT_ENTER(PALETTE_MONSTER_SEARCH, MonsterPalettePanel::OnChangeMonsterName)
 END_EVENT_TABLE()
 
 MonsterPalettePanel::MonsterPalettePanel(wxWindow* parent, wxWindowID id) :
 	PalettePanel(parent, id),
-	handling_event(false) {
+	handling_event(false)
+{
 
 	wxSizer* topsizer = newd wxBoxSizer(wxVERTICAL);
 
@@ -50,6 +53,9 @@ MonsterPalettePanel::MonsterPalettePanel(wxWindow* parent, wxWindowID id) :
 	tileset_choice = newd wxChoice(this, PALETTE_MONSTER_TILESET_CHOICE, wxDefaultPosition, wxDefaultSize, (int)0, (const wxString*)nullptr);
 	sidesizer->Add(tileset_choice, 0, wxEXPAND);
 
+	monster_name_text = newd wxTextCtrl(this, PALETTE_MONSTER_SEARCH, "Name");
+	sidesizer->Add(monster_name_text, 0, wxEXPAND);
+
 	monster_list = newd SortableListBox(this, PALETTE_MONSTER_LISTBOX);
 	sidesizer->Add(monster_list, 1, wxEXPAND);
 	topsizer->Add(sidesizer, 1, wxEXPAND);
@@ -57,7 +63,7 @@ MonsterPalettePanel::MonsterPalettePanel(wxWindow* parent, wxWindowID id) :
 	// Brush selection
 	sidesizer = newd wxStaticBoxSizer(newd wxStaticBox(this, wxID_ANY, "Brushes", wxDefaultPosition, wxSize(150, 200)), wxVERTICAL);
 
-	// sidesizer->Add(180, 1, wxEXPAND);
+	//sidesizer->Add(180, 1, wxEXPAND);
 
 	wxFlexGridSizer* grid = newd wxFlexGridSizer(3, 10, 10);
 	grid->AddGrowableCol(1);
@@ -73,6 +79,9 @@ MonsterPalettePanel::MonsterPalettePanel(wxWindow* parent, wxWindowID id) :
 	grid->Add(spawn_monster_size_spin, 0, wxEXPAND);
 	spawn_monster_brush_button = newd wxToggleButton(this, PALETTE_SPAWN_MONSTER_BRUSH_BUTTON, "Place Spawn");
 	grid->Add(spawn_monster_brush_button, 0, wxEXPAND);
+	grid->Add(newd wxStaticText(this, wxID_ANY, "Spawn density %"));
+	monster_spawndensity_spin = newd wxSpinCtrl(this, PALETTE_MONSTER_SPAWN_DENSITY, i2ws(g_settings.getInteger(Config::SPAWN_MONSTER_DENSITY)), wxDefaultPosition, wxSize(50, 20), wxSP_ARROW_KEYS, 0, 3600, g_settings.getInteger(Config::SPAWN_MONSTER_DENSITY));
+	grid->Add(monster_spawndensity_spin, 0, wxEXPAND);
 
 	sidesizer->Add(grid, 0, wxEXPAND);
 	topsizer->Add(sidesizer, 0, wxEXPAND);
@@ -81,61 +90,77 @@ MonsterPalettePanel::MonsterPalettePanel(wxWindow* parent, wxWindowID id) :
 	OnUpdate();
 }
 
-MonsterPalettePanel::~MonsterPalettePanel() {
+MonsterPalettePanel::~MonsterPalettePanel()
+{
 	////
 }
 
-PaletteType MonsterPalettePanel::GetType() const {
+PaletteType MonsterPalettePanel::GetType() const
+{
 	return TILESET_MONSTER;
 }
 
-void MonsterPalettePanel::SelectFirstBrush() {
+void MonsterPalettePanel::SelectFirstBrush()
+{
 	SelectMonsterBrush();
 }
 
-Brush* MonsterPalettePanel::GetSelectedBrush() const {
-	if (monster_brush_button->GetValue()) {
-		if (monster_list->GetCount() == 0) {
+Brush* MonsterPalettePanel::GetSelectedBrush() const
+{
+	if(monster_brush_button->GetValue()) {
+		if(monster_list->GetCount() == 0) {
 			return nullptr;
 		}
 		Brush* brush = reinterpret_cast<Brush*>(monster_list->GetClientData(monster_list->GetSelection()));
-		if (brush && brush->isMonster()) {
+		if(brush && brush->isMonster()) {
 			g_gui.SetSpawnMonsterTime(monster_spawntime_spin->GetValue());
 			return brush;
 		}
-	} else if (spawn_monster_brush_button->GetValue()) {
+	} else if(spawn_monster_brush_button->GetValue()) {
 		g_settings.setInteger(Config::CURRENT_SPAWN_MONSTER_RADIUS, spawn_monster_size_spin->GetValue());
 		g_settings.setInteger(Config::DEFAULT_SPAWN_MONSTER_TIME, monster_spawntime_spin->GetValue());
+		g_settings.setInteger(Config::SPAWN_MONSTER_DENSITY, monster_spawndensity_spin->GetValue());
+		std::vector<MonsterBrush *> monsters;
+		wxArrayInt selectedIndices;
+		 monster_list->GetCheckedItems(selectedIndices);
+		for (auto index : selectedIndices) {
+			Brush* brush = reinterpret_cast<Brush*>(monster_list->GetClientData(index));
+			if (brush && brush->isMonster()) {
+				monsters.push_back(brush->asMonster());
+			}
+		}
+		g_gui.spawn_brush->setMonsters(monsters);
 		return g_gui.spawn_brush;
 	}
 	return nullptr;
 }
 
-bool MonsterPalettePanel::SelectBrush(const Brush* whatbrush) {
-	if (!whatbrush) {
+bool MonsterPalettePanel::SelectBrush(const Brush* whatbrush)
+{
+	if(!whatbrush)
 		return false;
-	}
 
-	if (whatbrush->isMonster()) {
+	if(whatbrush->isMonster()) {
 		int current_index = tileset_choice->GetSelection();
-		if (current_index != wxNOT_FOUND) {
+		if(current_index != wxNOT_FOUND) {
 			const TilesetCategory* tsc = reinterpret_cast<const TilesetCategory*>(tileset_choice->GetClientData(current_index));
 			// Select first house
-			for (BrushVector::const_iterator iter = tsc->brushlist.begin(); iter != tsc->brushlist.end(); ++iter) {
-				if (*iter == whatbrush) {
+			for(BrushVector::const_iterator iter = tsc->brushlist.begin(); iter != tsc->brushlist.end(); ++iter) {
+				if(*iter == whatbrush) {
 					SelectMonster(whatbrush->getName());
 					return true;
 				}
 			}
 		}
 		// Not in the current display, search the hidden one's
-		for (size_t i = 0; i < tileset_choice->GetCount(); ++i) {
-			if (current_index != (int)i) {
+		for(size_t i = 0; i < tileset_choice->GetCount(); ++i) {
+			if(current_index != (int)i) {
 				const TilesetCategory* tsc = reinterpret_cast<const TilesetCategory*>(tileset_choice->GetClientData(i));
-				for (BrushVector::const_iterator iter = tsc->brushlist.begin();
-					 iter != tsc->brushlist.end();
-					 ++iter) {
-					if (*iter == whatbrush) {
+				for(BrushVector::const_iterator iter = tsc->brushlist.begin();
+						iter != tsc->brushlist.end();
+						++iter)
+				{
+					if(*iter == whatbrush) {
 						SelectTileset(i);
 						SelectMonster(whatbrush->getName());
 						return true;
@@ -143,26 +168,28 @@ bool MonsterPalettePanel::SelectBrush(const Brush* whatbrush) {
 				}
 			}
 		}
-	} else if (whatbrush->isSpawnMonster()) {
+	} else if(whatbrush->isSpawnMonster()) {
 		SelectSpawnBrush();
 		return true;
 	}
 	return false;
 }
 
-int MonsterPalettePanel::GetSelectedBrushSize() const {
+int MonsterPalettePanel::GetSelectedBrushSize() const
+{
 	return spawn_monster_size_spin->GetValue();
 }
 
-void MonsterPalettePanel::OnUpdate() {
+void MonsterPalettePanel::OnUpdate()
+{
 	tileset_choice->Clear();
 	g_materials.createOtherTileset();
 
-	for (TilesetContainer::const_iterator iter = g_materials.tilesets.begin(); iter != g_materials.tilesets.end(); ++iter) {
+	for(TilesetContainer::const_iterator iter = g_materials.tilesets.begin(); iter != g_materials.tilesets.end(); ++iter) {
 		const TilesetCategory* tsc = iter->second->getCategory(TILESET_MONSTER);
-		if (tsc && tsc->size() > 0) {
+		if(tsc && tsc->size() > 0) {
 			tileset_choice->Append(wxstr(iter->second->name), const_cast<TilesetCategory*>(tsc));
-		} else if (iter->second->name == "Others") {
+		} else if(iter->second->name == "Others") {
 			Tileset* ts = const_cast<Tileset*>(iter->second);
 			TilesetCategory* rtsc = ts->getCategory(TILESET_MONSTER);
 			tileset_choice->Append(wxstr(ts->name), rtsc);
@@ -171,28 +198,32 @@ void MonsterPalettePanel::OnUpdate() {
 	SelectTileset(0);
 }
 
-void MonsterPalettePanel::OnUpdateBrushSize(BrushShape shape, int size) {
+void MonsterPalettePanel::OnUpdateBrushSize(BrushShape shape, int size)
+{
 	return spawn_monster_size_spin->SetValue(size);
 }
 
-void MonsterPalettePanel::OnSwitchIn() {
+void MonsterPalettePanel::OnSwitchIn()
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetBrushSize(spawn_monster_size_spin->GetValue());
 }
 
-void MonsterPalettePanel::SelectTileset(size_t index) {
+void MonsterPalettePanel::SelectTileset(size_t index)
+{
 	ASSERT(tileset_choice->GetCount() >= index);
 
 	monster_list->Clear();
-	if (tileset_choice->GetCount() == 0) {
+	if(tileset_choice->GetCount() == 0) {
 		// No tilesets :(
 		monster_brush_button->Enable(false);
 	} else {
 		const TilesetCategory* tsc = reinterpret_cast<const TilesetCategory*>(tileset_choice->GetClientData(index));
 		// Select first house
-		for (BrushVector::const_iterator iter = tsc->brushlist.begin();
-			 iter != tsc->brushlist.end();
-			 ++iter) {
+		for(BrushVector::const_iterator iter = tsc->brushlist.begin();
+				iter != tsc->brushlist.end();
+				++iter)
+		{
 			monster_list->Append(wxstr((*iter)->getName()), *iter);
 		}
 		monster_list->Sort();
@@ -202,20 +233,22 @@ void MonsterPalettePanel::SelectTileset(size_t index) {
 	}
 }
 
-void MonsterPalettePanel::SelectMonster(size_t index) {
+void MonsterPalettePanel::SelectMonster(size_t index)
+{
 	// Save the old g_settings
 	ASSERT(monster_list->GetCount() >= index);
 
-	if (monster_list->GetCount() > 0) {
+	if(monster_list->GetCount() > 0) {
 		monster_list->SetSelection(index);
 	}
 
 	SelectMonsterBrush();
 }
 
-void MonsterPalettePanel::SelectMonster(std::string name) {
-	if (monster_list->GetCount() > 0) {
-		if (!monster_list->SetStringSelection(wxstr(name))) {
+void MonsterPalettePanel::SelectMonster(std::string name)
+{
+	if(monster_list->GetCount() > 0) {
+		if(!monster_list->SetStringSelection(wxstr(name))) {
 			monster_list->SetSelection(0);
 		}
 	}
@@ -223,8 +256,9 @@ void MonsterPalettePanel::SelectMonster(std::string name) {
 	SelectMonsterBrush();
 }
 
-void MonsterPalettePanel::SelectMonsterBrush() {
-	if (monster_list->GetCount() > 0) {
+void MonsterPalettePanel::SelectMonsterBrush()
+{
+	if(monster_list->GetCount() > 0) {
 		monster_brush_button->Enable(true);
 		monster_brush_button->SetValue(true);
 		spawn_monster_brush_button->SetValue(false);
@@ -234,46 +268,57 @@ void MonsterPalettePanel::SelectMonsterBrush() {
 	}
 }
 
-void MonsterPalettePanel::SelectSpawnBrush() {
-	// g_gui.house_exit_brush->setHouse(house);
+void MonsterPalettePanel::SelectSpawnBrush()
+{
+	//g_gui.house_exit_brush->setHouse(house);
 	monster_brush_button->SetValue(false);
 	spawn_monster_brush_button->SetValue(true);
 }
 
-void MonsterPalettePanel::OnTilesetChange(wxCommandEvent &event) {
+void MonsterPalettePanel::OnTilesetChange(wxCommandEvent& event)
+{
 	SelectTileset(event.GetSelection());
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush();
 }
 
-void MonsterPalettePanel::OnListBoxChange(wxCommandEvent &event) {
+void MonsterPalettePanel::OnListBoxChange(wxCommandEvent& event)
+{
 	SelectMonster(event.GetSelection());
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush();
 }
 
-void MonsterPalettePanel::OnClickMonsterBrushButton(wxCommandEvent &event) {
+void MonsterPalettePanel::OnClickMonsterBrushButton(wxCommandEvent& event)
+{
 	SelectMonsterBrush();
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush();
 }
 
-void MonsterPalettePanel::OnClickSpawnMonsterBrushButton(wxCommandEvent &event) {
+void MonsterPalettePanel::OnClickSpawnMonsterBrushButton(wxCommandEvent& event)
+{
 	SelectSpawnBrush();
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SelectBrush();
 }
 
-void MonsterPalettePanel::OnChangeSpawnMonsterTime(wxSpinEvent &event) {
+void MonsterPalettePanel::OnChangeSpawnMonsterTime(wxSpinEvent& event)
+{
 	g_gui.ActivatePalette(GetParentPalette());
 	g_gui.SetSpawnMonsterTime(event.GetPosition());
 }
 
-void MonsterPalettePanel::OnChangeSpawnMonsterSize(wxSpinEvent &event) {
-	if (!handling_event) {
+void MonsterPalettePanel::OnChangeSpawnMonsterSize(wxSpinEvent& event)
+{
+	if(!handling_event) {
 		handling_event = true;
 		g_gui.ActivatePalette(GetParentPalette());
 		g_gui.SetBrushSize(event.GetPosition());
 		handling_event = false;
 	}
 }
+
+void MonsterPalettePanel::OnChangeMonsterName(wxCommandEvent& event)
+{
+}
diff --git a/source/palette_monster.h b/source/palette_monster.h
index 54ab0519..d6a8bad7 100644
--- a/source/palette_monster.h
+++ b/source/palette_monster.h
@@ -15,6 +15,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //////////////////////////////////////////////////////////////////////
 
+
 #ifndef RME_TILESET_MONSTER_H_
 #define RME_TILESET_MONSTER_H_
 
@@ -47,27 +48,28 @@ class MonsterPalettePanel : public PalettePanel {
 	void SelectTileset(size_t index);
 	void SelectMonster(size_t index);
 	void SelectMonster(std::string name);
-
 public:
 	// Event handling
-	void OnChangeSpawnMonsterTime(wxSpinEvent &event);
-	void OnChangeSpawnMonsterSize(wxSpinEvent &event);
-
-	void OnTilesetChange(wxCommandEvent &event);
-	void OnListBoxChange(wxCommandEvent &event);
-	void OnClickMonsterBrushButton(wxCommandEvent &event);
-	void OnClickSpawnMonsterBrushButton(wxCommandEvent &event);
+	void OnChangeSpawnMonsterTime(wxSpinEvent& event);
+	void OnChangeSpawnMonsterSize(wxSpinEvent& event);
 
+	void OnTilesetChange(wxCommandEvent& event);
+	void OnListBoxChange(wxCommandEvent& event);
+	void OnClickMonsterBrushButton(wxCommandEvent& event);
+	void OnClickSpawnMonsterBrushButton(wxCommandEvent& event);
+	void OnChangeMonsterName(wxCommandEvent& event);
 protected:
 	void SelectMonsterBrush();
 	void SelectSpawnBrush();
 
 	wxChoice* tileset_choice;
+	wxTextCtrl* monster_name_text;
 	SortableListBox* monster_list;
 	wxToggleButton* monster_brush_button;
 	wxToggleButton* spawn_monster_brush_button;
 	wxSpinCtrl* monster_spawntime_spin;
 	wxSpinCtrl* spawn_monster_size_spin;
+	wxSpinCtrl* monster_spawndensity_spin;
 
 	bool handling_event;
 
diff --git a/source/palette_window.cpp b/source/palette_window.cpp
index 2a84cf0b..37a914d9 100644
--- a/source/palette_window.cpp
+++ b/source/palette_window.cpp
@@ -28,6 +28,7 @@
 #include "palette_monster.h"
 #include "palette_npc.h"
 #include "palette_waypoints.h"
+#include "palette_zones.h"
 
 #include "house_brush.h"
 #include "map.h"
@@ -36,14 +37,14 @@
 // Palette window
 
 BEGIN_EVENT_TABLE(PaletteWindow, wxPanel)
-EVT_CHOICEBOOK_PAGE_CHANGING(PALETTE_CHOICEBOOK, PaletteWindow::OnSwitchingPage)
-EVT_CHOICEBOOK_PAGE_CHANGED(PALETTE_CHOICEBOOK, PaletteWindow::OnPageChanged)
-EVT_CLOSE(PaletteWindow::OnClose)
+	EVT_CHOICEBOOK_PAGE_CHANGING(PALETTE_CHOICEBOOK, PaletteWindow::OnSwitchingPage)
+	EVT_CHOICEBOOK_PAGE_CHANGED(PALETTE_CHOICEBOOK, PaletteWindow::OnPageChanged)
+	EVT_CLOSE(PaletteWindow::OnClose)
 
-EVT_KEY_DOWN(PaletteWindow::OnKey)
+	EVT_KEY_DOWN(PaletteWindow::OnKey)
 END_EVENT_TABLE()
 
-PaletteWindow::PaletteWindow(wxWindow* parent, const TilesetContainer &tilesets) :
+PaletteWindow::PaletteWindow(wxWindow* parent, const TilesetContainer& tilesets) :
 	wxPanel(parent, wxID_ANY, wxDefaultPosition, wxSize(230, 250)),
 	choicebook(nullptr),
 	terrain_palette(nullptr),
@@ -53,7 +54,9 @@ PaletteWindow::PaletteWindow(wxWindow* parent, const TilesetContainer &tilesets)
 	npc_palette(nullptr),
 	house_palette(nullptr),
 	waypoint_palette(nullptr),
-	raw_palette(nullptr) {
+	zones_palette(nullptr),
+	raw_palette(nullptr)
+{
 	SetMinSize(wxSize(225, 250));
 
 	// Create choicebook
@@ -74,6 +77,9 @@ PaletteWindow::PaletteWindow(wxWindow* parent, const TilesetContainer &tilesets)
 	waypoint_palette = static_cast<WaypointPalettePanel*>(CreateWaypointPalette(choicebook, tilesets));
 	choicebook->AddPage(waypoint_palette, waypoint_palette->GetName());
 
+	zones_palette = static_cast<ZonesPalettePanel*>(CreateZonesPalette(choicebook, tilesets));
+	choicebook->AddPage(zones_palette, zones_palette->GetName());
+
 	monster_palette = static_cast<MonsterPalettePanel*>(CreateMonsterPalette(choicebook, tilesets));
 	choicebook->AddPage(monster_palette, monster_palette->GetName());
 
@@ -95,11 +101,13 @@ PaletteWindow::PaletteWindow(wxWindow* parent, const TilesetContainer &tilesets)
 	Fit();
 }
 
-PaletteWindow::~PaletteWindow() {
+PaletteWindow::~PaletteWindow()
+{
 	////
 }
 
-PalettePanel* PaletteWindow::CreateTerrainPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateTerrainPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	BrushPalettePanel* panel = newd BrushPalettePanel(parent, tilesets, TILESET_TERRAIN);
 	panel->SetListType(wxstr(g_settings.getString(Config::PALETTE_TERRAIN_STYLE)));
 
@@ -114,7 +122,8 @@ PalettePanel* PaletteWindow::CreateTerrainPalette(wxWindow* parent, const Tilese
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateDoodadPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateDoodadPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	BrushPalettePanel* panel = newd BrushPalettePanel(parent, tilesets, TILESET_DOODAD);
 	panel->SetListType(wxstr(g_settings.getString(Config::PALETTE_DOODAD_STYLE)));
 
@@ -127,7 +136,8 @@ PalettePanel* PaletteWindow::CreateDoodadPalette(wxWindow* parent, const Tileset
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateItemPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateItemPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	BrushPalettePanel* panel = newd BrushPalettePanel(parent, tilesets, TILESET_ITEM);
 	panel->SetListType(wxstr(g_settings.getString(Config::PALETTE_ITEM_STYLE)));
 
@@ -137,7 +147,8 @@ PalettePanel* PaletteWindow::CreateItemPalette(wxWindow* parent, const TilesetCo
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateHousePalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateHousePalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	HousePalettePanel* panel = newd HousePalettePanel(parent);
 
 	BrushSizePanel* size_panel = newd BrushSizePanel(panel);
@@ -146,22 +157,32 @@ PalettePanel* PaletteWindow::CreateHousePalette(wxWindow* parent, const TilesetC
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateWaypointPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateWaypointPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	WaypointPalettePanel* panel = newd WaypointPalettePanel(parent);
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateMonsterPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateZonesPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
+	ZonesPalettePanel* panel = newd ZonesPalettePanel(parent);
+	return panel;
+}
+
+PalettePanel* PaletteWindow::CreateMonsterPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	MonsterPalettePanel* panel = newd MonsterPalettePanel(parent);
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateNpcPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateNpcPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	NpcPalettePanel* panel = newd NpcPalettePanel(parent);
 	return panel;
 }
 
-PalettePanel* PaletteWindow::CreateRAWPalette(wxWindow* parent, const TilesetContainer &tilesets) {
+PalettePanel* PaletteWindow::CreateRAWPalette(wxWindow *parent, const TilesetContainer& tilesets)
+{
 	BrushPalettePanel* panel = newd BrushPalettePanel(parent, tilesets, TILESET_RAW);
 	panel->SetListType(wxstr(g_settings.getString(Config::PALETTE_RAW_STYLE)));
 
@@ -172,37 +193,40 @@ PalettePanel* PaletteWindow::CreateRAWPalette(wxWindow* parent, const TilesetCon
 	return panel;
 }
 
-void PaletteWindow::ReloadSettings(Map* map) {
-	if (terrain_palette) {
+void PaletteWindow::ReloadSettings(Map* map)
+{
+	if(terrain_palette) {
 		terrain_palette->SetListType(wxstr(g_settings.getString(Config::PALETTE_TERRAIN_STYLE)));
 		terrain_palette->SetToolbarIconSize(g_settings.getBoolean(Config::USE_LARGE_TERRAIN_TOOLBAR));
 	}
-	if (doodad_palette) {
+	if(doodad_palette) {
 		doodad_palette->SetListType(wxstr(g_settings.getString(Config::PALETTE_DOODAD_STYLE)));
 		doodad_palette->SetToolbarIconSize(g_settings.getBoolean(Config::USE_LARGE_DOODAD_SIZEBAR));
 	}
-	if (house_palette) {
+	if(house_palette) {
 		house_palette->SetMap(map);
 		house_palette->SetToolbarIconSize(g_settings.getBoolean(Config::USE_LARGE_HOUSE_SIZEBAR));
 	}
-	if (waypoint_palette) {
+	if(waypoint_palette) {
 		waypoint_palette->SetMap(map);
 	}
-	if (item_palette) {
+	if(zones_palette) {
+		zones_palette->SetMap(map);
+	}
+	if(item_palette) {
 		item_palette->SetListType(wxstr(g_settings.getString(Config::PALETTE_ITEM_STYLE)));
 		item_palette->SetToolbarIconSize(g_settings.getBoolean(Config::USE_LARGE_ITEM_SIZEBAR));
 	}
-	if (raw_palette) {
+	if(raw_palette) {
 		raw_palette->SetListType(wxstr(g_settings.getString(Config::PALETTE_RAW_STYLE)));
 		raw_palette->SetToolbarIconSize(g_settings.getBoolean(Config::USE_LARGE_RAW_SIZEBAR));
 	}
 	InvalidateContents();
 }
 
-void PaletteWindow::LoadCurrentContents() {
-	if (!choicebook) {
-		return;
-	}
+void PaletteWindow::LoadCurrentContents()
+{
+	if(!choicebook) return;
 	PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetCurrentPage());
 	panel->LoadCurrentContents();
 	Fit();
@@ -210,119 +234,117 @@ void PaletteWindow::LoadCurrentContents() {
 	Update();
 }
 
-void PaletteWindow::InvalidateContents() {
-	if (!choicebook) {
-		return;
-	}
-	for (size_t iz = 0; iz < choicebook->GetPageCount(); ++iz) {
+void PaletteWindow::InvalidateContents()
+{
+	if(!choicebook) return;
+	for(size_t iz = 0; iz < choicebook->GetPageCount(); ++iz) {
 		PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetPage(iz));
 		panel->InvalidateContents();
 	}
 	LoadCurrentContents();
-	if (monster_palette) {
+	if(monster_palette) {
 		monster_palette->OnUpdate();
 	}
-	if (npc_palette) {
+	if(npc_palette) {
 		npc_palette->OnUpdate();
 	}
-	if (house_palette) {
+	if(house_palette) {
 		house_palette->OnUpdate();
 	}
-	if (waypoint_palette) {
+	if(waypoint_palette) {
 		waypoint_palette->OnUpdate();
 	}
+	if(zones_palette) {
+		zones_palette->OnUpdate();
+	}
 }
 
-void PaletteWindow::SelectPage(PaletteType id) {
-	if (!choicebook) {
-		return;
-	}
-	if (id == GetSelectedPage()) {
+void PaletteWindow::SelectPage(PaletteType id)
+{
+	if(!choicebook) return;
+	if(id == GetSelectedPage()) {
 		return;
 	}
 
-	for (size_t iz = 0; iz < choicebook->GetPageCount(); ++iz) {
+	for(size_t iz = 0; iz < choicebook->GetPageCount(); ++iz) {
 		PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetPage(iz));
-		if (panel->GetType() == id) {
+		if(panel->GetType() == id) {
 			choicebook->SetSelection(iz);
-			// LoadCurrentContents();
+			//LoadCurrentContents();
 			break;
 		}
 	}
 }
 
-Brush* PaletteWindow::GetSelectedBrush() const {
-	if (!choicebook) {
-		return nullptr;
-	}
+Brush* PaletteWindow::GetSelectedBrush() const
+{
+	if(!choicebook) return nullptr;
 	PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetCurrentPage());
 	return panel->GetSelectedBrush();
 }
 
-int PaletteWindow::GetSelectedBrushSize() const {
-	if (!choicebook) {
-		return 0;
-	}
+int PaletteWindow::GetSelectedBrushSize() const
+{
+	if(!choicebook) return 0;
 	PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetCurrentPage());
 	return panel->GetSelectedBrushSize();
 }
 
-PaletteType PaletteWindow::GetSelectedPage() const {
-	if (!choicebook) {
-		return TILESET_UNKNOWN;
-	}
+PaletteType PaletteWindow::GetSelectedPage() const
+{
+	if(!choicebook) return TILESET_UNKNOWN;
 	PalettePanel* panel = dynamic_cast<PalettePanel*>(choicebook->GetCurrentPage());
 	ASSERT(panel);
 	return panel->GetType();
 }
 
-bool PaletteWindow::OnSelectBrush(const Brush* whatbrush, PaletteType primary) {
-	if (!choicebook || !whatbrush) {
+bool PaletteWindow::OnSelectBrush(const Brush* whatbrush, PaletteType primary)
+{
+	if(!choicebook || !whatbrush)
 		return false;
-	}
 
-	if (whatbrush->isHouse() && house_palette) {
+	if(whatbrush->isHouse() && house_palette) {
 		house_palette->SelectBrush(whatbrush);
 		SelectPage(TILESET_HOUSE);
 		return true;
 	}
 
-	switch (primary) {
+	switch(primary) {
 		case TILESET_TERRAIN: {
 			// This is already searched first
 			break;
 		}
 		case TILESET_DOODAD: {
 			// Ok, search doodad before terrain
-			if (doodad_palette && doodad_palette->SelectBrush(whatbrush)) {
+			if(doodad_palette && doodad_palette->SelectBrush(whatbrush)) {
 				SelectPage(TILESET_DOODAD);
 				return true;
 			}
 			break;
 		}
 		case TILESET_ITEM: {
-			if (item_palette && item_palette->SelectBrush(whatbrush)) {
+			if(item_palette && item_palette->SelectBrush(whatbrush)) {
 				SelectPage(TILESET_ITEM);
 				return true;
 			}
 			break;
 		}
 		case TILESET_MONSTER: {
-			if (monster_palette && monster_palette->SelectBrush(whatbrush)) {
+			if(monster_palette && monster_palette->SelectBrush(whatbrush)) {
 				SelectPage(TILESET_MONSTER);
 				return true;
 			}
 			break;
 		}
 		case TILESET_NPC: {
-			if (npc_palette && npc_palette->SelectBrush(whatbrush)) {
+			if(npc_palette && npc_palette->SelectBrush(whatbrush)) {
 				SelectPage(TILESET_NPC);
 				return true;
 			}
 			break;
 		}
 		case TILESET_RAW: {
-			if (raw_palette && raw_palette->SelectBrush(whatbrush)) {
+			if(raw_palette && raw_palette->SelectBrush(whatbrush)) {
 				SelectPage(TILESET_RAW);
 				return true;
 			}
@@ -333,46 +355,46 @@ bool PaletteWindow::OnSelectBrush(const Brush* whatbrush, PaletteType primary) {
 	}
 
 	// Test if it's a terrain brush
-	if (terrain_palette && terrain_palette->SelectBrush(whatbrush)) {
+	if(terrain_palette && terrain_palette->SelectBrush(whatbrush)) {
 		SelectPage(TILESET_TERRAIN);
 		return true;
 	}
 
 	// Test if it's a doodad brush
-	if (primary != TILESET_DOODAD) {
-		if (doodad_palette && doodad_palette->SelectBrush(whatbrush)) {
+	if(primary != TILESET_DOODAD) {
+		if(doodad_palette && doodad_palette->SelectBrush(whatbrush)) {
 			SelectPage(TILESET_DOODAD);
 			return true;
 		}
 	}
 
 	// Test if it's an item brush
-	if (primary != TILESET_ITEM) {
-		if (item_palette && item_palette->SelectBrush(whatbrush)) {
+	if(primary != TILESET_ITEM) {
+		if(item_palette && item_palette->SelectBrush(whatbrush)) {
 			SelectPage(TILESET_ITEM);
 			return true;
 		}
 	}
 
 	// Test if it's a monster brush
-	if (primary != TILESET_MONSTER) {
-		if (monster_palette && monster_palette->SelectBrush(whatbrush)) {
+	if(primary != TILESET_MONSTER) {
+		if(monster_palette && monster_palette->SelectBrush(whatbrush)) {
 			SelectPage(TILESET_MONSTER);
 			return true;
 		}
 	}
 
 	// Test if it's a npc brush
-	if (primary != TILESET_NPC) {
-		if (npc_palette && npc_palette->SelectBrush(whatbrush)) {
+	if(primary != TILESET_NPC) {
+		if(npc_palette && npc_palette->SelectBrush(whatbrush)) {
 			SelectPage(TILESET_NPC);
 			return true;
 		}
 	}
 
 	// Test if it's a raw brush
-	if (primary != TILESET_RAW) {
-		if (raw_palette && raw_palette->SelectBrush(whatbrush)) {
+	if(primary != TILESET_RAW) {
+		if(raw_palette && raw_palette->SelectBrush(whatbrush)) {
 			SelectPage(TILESET_RAW);
 			return true;
 		}
@@ -381,65 +403,69 @@ bool PaletteWindow::OnSelectBrush(const Brush* whatbrush, PaletteType primary) {
 	return false;
 }
 
-void PaletteWindow::OnSwitchingPage(wxChoicebookEvent &event) {
+void PaletteWindow::OnSwitchingPage(wxChoicebookEvent& event)
+{
 	event.Skip();
-	if (!choicebook) {
-		return;
-	}
+	if(!choicebook) return;
 
 	wxWindow* old_page = choicebook->GetPage(choicebook->GetSelection());
 	PalettePanel* old_panel = dynamic_cast<PalettePanel*>(old_page);
-	if (old_panel) {
+	if(old_panel) {
 		old_panel->OnSwitchOut();
 	}
 
 	wxWindow* page = choicebook->GetPage(event.GetSelection());
 	PalettePanel* panel = dynamic_cast<PalettePanel*>(page);
-	if (panel) {
+	if(panel) {
 		panel->OnSwitchIn();
 	}
 }
 
-void PaletteWindow::OnPageChanged(wxChoicebookEvent &event) {
-	if (!choicebook) {
-		return;
-	}
+void PaletteWindow::OnPageChanged(wxChoicebookEvent& event)
+{
+	if(!choicebook) return;
 	g_gui.SelectBrush();
 }
 
-void PaletteWindow::OnUpdateBrushSize(BrushShape shape, int size) {
-	if (!choicebook) {
-		return;
-	}
+void PaletteWindow::OnUpdateBrushSize(BrushShape shape, int size)
+{
+	if(!choicebook) return;
 	PalettePanel* page = dynamic_cast<PalettePanel*>(choicebook->GetCurrentPage());
 	ASSERT(page);
 	page->OnUpdateBrushSize(shape, size);
 }
 
-void PaletteWindow::OnUpdate(Map* map) {
-	if (monster_palette) {
+void PaletteWindow::OnUpdate(Map* map)
+{
+	if(monster_palette) {
 		monster_palette->OnUpdate();
 	}
-	if (npc_palette) {
+	if(npc_palette) {
 		npc_palette->OnUpdate();
 	}
-	if (house_palette) {
+	if(house_palette) {
 		house_palette->SetMap(map);
 	}
-	if (waypoint_palette) {
+	if(waypoint_palette) {
 		waypoint_palette->SetMap(map);
 		waypoint_palette->OnUpdate();
 	}
+	if(zones_palette) {
+		zones_palette->SetMap(map);
+		zones_palette->OnUpdate();
+	}
 }
 
-void PaletteWindow::OnKey(wxKeyEvent &event) {
-	if (g_gui.GetCurrentTab() != nullptr) {
+void PaletteWindow::OnKey(wxKeyEvent& event)
+{
+	if(g_gui.GetCurrentTab() != nullptr) {
 		g_gui.GetCurrentMapTab()->GetEventHandler()->AddPendingEvent(event);
 	}
 }
 
-void PaletteWindow::OnClose(wxCloseEvent &event) {
-	if (!event.CanVeto()) {
+void PaletteWindow::OnClose(wxCloseEvent& event)
+{
+	if(!event.CanVeto()) {
 		// We can't do anything! This sucks!
 		// (application is closed, we have to destroy ourselves)
 		Destroy();
diff --git a/source/palette_window.h b/source/palette_window.h
index 8401b042..baf687b3 100644
--- a/source/palette_window.h
+++ b/source/palette_window.h
@@ -25,10 +25,12 @@ class MonsterPalettePanel;
 class NpcPalettePanel;
 class HousePalettePanel;
 class WaypointPalettePanel;
+class ZonesPalettePanel;
 
-class PaletteWindow : public wxPanel {
+class PaletteWindow : public wxPanel
+{
 public:
-	PaletteWindow(wxWindow* parent, const TilesetContainer &tilesets);
+	PaletteWindow(wxWindow* parent, const TilesetContainer& tilesets);
 	~PaletteWindow();
 
 	// Interface
@@ -57,21 +59,22 @@ class PaletteWindow : public wxPanel {
 	virtual void OnUpdate(Map* map);
 
 	// wxWidgets Event Handlers
-	void OnSwitchingPage(wxChoicebookEvent &event);
-	void OnPageChanged(wxChoicebookEvent &event);
+	void OnSwitchingPage(wxChoicebookEvent& event);
+	void OnPageChanged(wxChoicebookEvent& event);
 	// Forward key events to the parent window (The Map Window)
-	void OnKey(wxKeyEvent &event);
-	void OnClose(wxCloseEvent &);
+	void OnKey(wxKeyEvent& event);
+	void OnClose(wxCloseEvent&);
 
 protected:
-	static PalettePanel* CreateTerrainPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateDoodadPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateItemPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateMonsterPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateNpcPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateHousePalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateWaypointPalette(wxWindow* parent, const TilesetContainer &tilesets);
-	static PalettePanel* CreateRAWPalette(wxWindow* parent, const TilesetContainer &tilesets);
+	static PalettePanel* CreateTerrainPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateDoodadPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateItemPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateMonsterPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateNpcPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateHousePalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateWaypointPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateZonesPalette(wxWindow* parent, const TilesetContainer& tilesets);
+	static PalettePanel* CreateRAWPalette(wxWindow* parent, const TilesetContainer& tilesets);
 
 	wxChoicebook* choicebook;
 
@@ -82,6 +85,7 @@ class PaletteWindow : public wxPanel {
 	NpcPalettePanel* npc_palette;
 	HousePalettePanel* house_palette;
 	WaypointPalettePanel* waypoint_palette;
+	ZonesPalettePanel* zones_palette;
 	BrushPalettePanel* raw_palette;
 
 	DECLARE_EVENT_TABLE()
diff --git a/source/palette_zones.cpp b/source/palette_zones.cpp
new file mode 100644
index 00000000..0b401c6e
--- /dev/null
+++ b/source/palette_zones.cpp
@@ -0,0 +1,231 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// Zone palette
+
+#include "main.h"
+
+#include "gui.h"
+#include "palette_zones.h"
+#include "zone_brush.h"
+#include "map.h"
+
+BEGIN_EVENT_TABLE(ZonesPalettePanel, PalettePanel)
+	EVT_BUTTON(PALETTE_ZONES_ADD_ZONE, ZonesPalettePanel::OnClickAddZone)
+	EVT_BUTTON(PALETTE_ZONES_REMOVE_ZONE, ZonesPalettePanel::OnClickRemoveZone)
+
+	EVT_LIST_BEGIN_LABEL_EDIT(PALETTE_ZONES_LISTBOX, ZonesPalettePanel::OnBeginEditZoneLabel)
+	EVT_LIST_END_LABEL_EDIT(PALETTE_ZONES_LISTBOX, ZonesPalettePanel::OnEditZoneLabel)
+	EVT_LIST_ITEM_SELECTED(PALETTE_ZONES_LISTBOX, ZonesPalettePanel::OnClickZone)
+END_EVENT_TABLE()
+
+ZonesPalettePanel::ZonesPalettePanel(wxWindow* parent, wxWindowID id) :
+	PalettePanel(parent, id),
+	map(nullptr)
+{
+	wxSizer* sidesizer = newd wxStaticBoxSizer(wxVERTICAL, this, "Zones");
+
+	zone_list = newd wxListCtrl(this, PALETTE_ZONES_LISTBOX,
+		wxDefaultPosition, wxDefaultSize,
+		wxLC_REPORT | wxLC_SINGLE_SEL | wxLC_EDIT_LABELS | wxLC_NO_HEADER);
+	zone_list->InsertColumn(0, "UNNAMED", wxLIST_FORMAT_LEFT, 200);
+	sidesizer->Add(zone_list, 1, wxEXPAND);
+
+	wxSizer* tmpsizer = newd wxBoxSizer(wxHORIZONTAL);
+	tmpsizer->Add(add_zone_button = newd wxButton(this, PALETTE_ZONES_ADD_ZONE, "Add", wxDefaultPosition, wxSize(50, -1)), 1, wxEXPAND);
+	tmpsizer->Add(remove_zone_button = newd wxButton(this, PALETTE_ZONES_REMOVE_ZONE, "Remove", wxDefaultPosition, wxSize(70, -1)), 1, wxEXPAND);
+	sidesizer->Add(tmpsizer, 0, wxEXPAND);
+
+	SetSizerAndFit(sidesizer);
+}
+
+ZonesPalettePanel::~ZonesPalettePanel()
+{
+	////
+}
+
+
+void ZonesPalettePanel::OnSwitchIn()
+{
+	PalettePanel::OnSwitchIn();
+}
+
+void ZonesPalettePanel::OnSwitchOut()
+{
+	PalettePanel::OnSwitchOut();
+}
+
+void ZonesPalettePanel::SetMap(Map* m)
+{
+	map = m;
+	this->Enable(m && m->getVersion().otbm >= MAP_OTBM_3);
+}
+
+void ZonesPalettePanel::SelectFirstBrush()
+{
+	//SelectZoneBrush();
+}
+
+Brush* ZonesPalettePanel::GetSelectedBrush() const
+{
+    long item = zone_list->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	g_gui.zone_brush->setZone(
+		item == -1 || !map->zones.hasZone(nstr(zone_list->GetItemText(item)))?
+			0 :
+			map->zones.getZoneID(nstr(zone_list->GetItemText(item)))
+	);
+	return g_gui.zone_brush;
+}
+
+bool ZonesPalettePanel::SelectBrush(const Brush* whatbrush)
+{
+	ASSERT(whatbrush == g_gui.zone_brush);
+	return false;
+}
+
+int ZonesPalettePanel::GetSelectedBrushSize() const
+{
+	return 0;
+}
+
+PaletteType ZonesPalettePanel::GetType() const
+{
+	return TILESET_ZONES;
+}
+
+wxString ZonesPalettePanel::GetName() const
+{
+	return "Zone Palette";
+}
+
+void ZonesPalettePanel::OnUpdate()
+{
+	if(wxTextCtrl* tc = zone_list->GetEditControl()) {
+		std::string name = nstr(tc->GetValue());
+		if(map->zones.hasZone(name)) {
+			map->zones.removeZone(name);
+			map->cleanDeletedZones();
+		}
+	}
+	zone_list->DeleteAllItems();
+
+	if(!map){
+		zone_list->Enable(false);
+		add_zone_button->Enable(false);
+		remove_zone_button->Enable(false);
+	} else {
+		zone_list->Enable(true);
+		add_zone_button->Enable(true);
+		remove_zone_button->Enable(true);
+
+		Zones& zones = map->zones;
+
+		for(ZoneMap::const_iterator iter = zones.begin(); iter != zones.end(); ++iter) {
+			zone_list->InsertItem(0, wxstr(iter->first));
+		}
+	}
+}
+
+void ZonesPalettePanel::OnClickZone(wxListEvent& event)
+{
+	if(!map)
+		return;
+
+	std::string name = nstr(event.GetText());
+	if(map->zones.hasZone(name)) {
+		auto zoneId = map->zones.getZoneID(name);
+		g_gui.zone_brush->setZone(zoneId);
+	}
+}
+
+void ZonesPalettePanel::OnBeginEditZoneLabel(wxListEvent& event)
+{
+	// We need to disable all hotkeys, so we can type properly
+	g_gui.DisableHotkeys();
+}
+
+void ZonesPalettePanel::OnEditZoneLabel(wxListEvent& event)
+{
+	std::string name = nstr(event.GetLabel());
+	std::string oldName = nstr(zone_list->GetItemText(event.GetIndex()));
+
+	if(event.IsEditCancelled())
+		return;
+
+	if(name == "") {
+		map->zones.removeZone(oldName);
+		g_gui.RefreshPalettes();
+	} else {
+		if(name == oldName) {
+			; // do nothing
+		} else {
+			if(map->zones.hasZone(name)) {
+				// Already exists a zone with this name!
+				g_gui.SetStatusText("There already is a zone with this name.");
+				event.Veto();
+				if(oldName == "") {
+					map->zones.removeZone(oldName);
+					g_gui.RefreshPalettes();
+				}
+			} else {
+				map->zones.removeZone(oldName);
+				map->zones.addZone(name);
+				auto zoneId = map->zones.getZoneID(name);
+				g_gui.zone_brush->setZone(zoneId);
+
+				// Refresh other palettes
+				refresh_timer.Start(300, true);
+			}
+		}
+	}
+
+	if(event.IsAllowed())
+		g_gui.EnableHotkeys();
+}
+
+void ZonesPalettePanel::OnClickAddZone(wxCommandEvent& event)
+{
+	if(map) {
+		if (map->zones.addZone("")) {
+			long i = zone_list->InsertItem(0, "");
+			zone_list->EditLabel(i);
+		} else {
+			long i = zone_list->FindItem(-1, "");
+			zone_list->EditLabel(i);
+		}
+
+		//g_gui.RefreshPalettes();
+	}
+}
+
+void ZonesPalettePanel::OnClickRemoveZone(wxCommandEvent& event)
+{
+	if(!map)
+		return;
+
+    long item = zone_list->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
+	if(item != -1) {
+		std::string name = nstr(zone_list->GetItemText(item));
+		if(map->zones.hasZone(name)) {
+			map->zones.removeZone(name);
+			map->cleanDeletedZones();
+		}
+		zone_list->DeleteItem(item);
+		refresh_timer.Start(300, true);
+	}
+}
diff --git a/source/palette_zones.h b/source/palette_zones.h
new file mode 100644
index 00000000..f8f6b28b
--- /dev/null
+++ b/source/palette_zones.h
@@ -0,0 +1,67 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+#ifndef RME_PALETTE_ZONES_H_
+#define RME_PALETTE_ZONES_H_
+
+#include <wx/listctrl.h>
+
+#include "zones.h"
+#include "palette_common.h"
+
+class ZonesPalettePanel : public PalettePanel {
+public:
+	ZonesPalettePanel(wxWindow* parent, wxWindowID id = wxID_ANY);
+	~ZonesPalettePanel();
+
+	wxString GetName() const;
+	PaletteType GetType() const;
+
+	// Select the first brush
+	void SelectFirstBrush();
+	// Returns the currently selected brush (first brush if panel is not loaded)
+	Brush* GetSelectedBrush() const;
+	// Returns the currently selected brush size
+	int GetSelectedBrushSize() const;
+	// Select the brush in the parameter, this only changes the look of the panel
+	bool SelectBrush(const Brush* whatbrush);
+
+	// Called sometimes?
+	void OnUpdate();
+	// Called when this page is about to be displayed
+	void OnSwitchIn();
+	// Called when this page is hidden
+	void OnSwitchOut();
+public:
+	// wxWidgets event handling
+	void OnClickZone(wxListEvent& event);
+	void OnBeginEditZoneLabel(wxListEvent& event);
+	void OnEditZoneLabel(wxListEvent& event);
+	void OnClickAddZone(wxCommandEvent& event);
+	void OnClickRemoveZone(wxCommandEvent& event);
+
+	void SetMap(Map* map);
+protected:
+	Map* map;
+	wxListCtrl* zone_list;
+	wxButton* add_zone_button;
+	wxButton* remove_zone_button;
+
+	DECLARE_EVENT_TABLE()
+};
+
+#endif
diff --git a/source/preferences.cpp b/source/preferences.cpp
index 358bd722..f2267f38 100644
--- a/source/preferences.cpp
+++ b/source/preferences.cpp
@@ -15,6 +15,7 @@
 // along with this program. If not, see <http://www.gnu.org/licenses/>.
 //////////////////////////////////////////////////////////////////////
 
+
 #include "main.h"
 
 #include "settings.h"
@@ -26,43 +27,45 @@
 #include "preferences.h"
 
 BEGIN_EVENT_TABLE(PreferencesWindow, wxDialog)
-EVT_BUTTON(wxID_OK, PreferencesWindow::OnClickOK)
-EVT_BUTTON(wxID_CANCEL, PreferencesWindow::OnClickCancel)
-EVT_BUTTON(wxID_APPLY, PreferencesWindow::OnClickApply)
-EVT_COLLAPSIBLEPANE_CHANGED(wxID_ANY, PreferencesWindow::OnCollapsiblePane)
+	EVT_BUTTON(wxID_OK, PreferencesWindow::OnClickOK)
+	EVT_BUTTON(wxID_CANCEL, PreferencesWindow::OnClickCancel)
+	EVT_BUTTON(wxID_APPLY, PreferencesWindow::OnClickApply)
+	EVT_COLLAPSIBLEPANE_CHANGED(wxID_ANY, PreferencesWindow::OnCollapsiblePane)
 END_EVENT_TABLE()
 
-PreferencesWindow::PreferencesWindow(wxWindow* parent, bool clientVersionSelected = false) :
-	wxDialog(parent, wxID_ANY, "Preferences", wxDefaultPosition, wxSize(400, 400), wxCAPTION | wxCLOSE_BOX) {
-	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
+PreferencesWindow::PreferencesWindow(wxWindow *parent, bool clientVersionSelected = false)
+        : wxDialog(parent, wxID_ANY, "Preferences", wxDefaultPosition, wxSize(400, 400), wxCAPTION | wxCLOSE_BOX) {
+    wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 
-	book = newd wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_TOP);
-	// book->SetPadding(4);
+    book = newd wxNotebook(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxBK_TOP);
+    //book->SetPadding(4);
 
-	book->AddPage(CreateGeneralPage(), "General", true);
-	book->AddPage(CreateEditorPage(), "Editor");
-	book->AddPage(CreateGraphicsPage(), "Graphics");
-	book->AddPage(CreateUIPage(), "Interface");
-	book->AddPage(CreateClientPage(), "Client Version", clientVersionSelected);
+    book->AddPage(CreateGeneralPage(), "General", true);
+    book->AddPage(CreateEditorPage(), "Editor");
+    book->AddPage(CreateGraphicsPage(), "Graphics");
+    book->AddPage(CreateUIPage(), "Interface");
+    book->AddPage(CreateClientPage(), "Client Version", clientVersionSelected);
 
-	sizer->Add(book, 1, wxEXPAND | wxALL, 10);
+    sizer->Add(book, 1, wxEXPAND | wxALL, 10);
 
-	wxSizer* subsizer = newd wxBoxSizer(wxHORIZONTAL);
-	subsizer->Add(newd wxButton(this, wxID_OK, "OK"), wxSizerFlags(1).Center());
-	subsizer->Add(newd wxButton(this, wxID_CANCEL, "Cancel"), wxSizerFlags(1).Border(wxALL, 5).Left().Center());
-	subsizer->Add(newd wxButton(this, wxID_APPLY, "Apply"), wxSizerFlags(1).Center());
-	sizer->Add(subsizer, 0, wxCENTER | wxLEFT | wxBOTTOM | wxRIGHT, 10);
+    wxSizer* subsizer = newd wxBoxSizer(wxHORIZONTAL);
+    subsizer->Add(newd wxButton(this, wxID_OK, "OK"), wxSizerFlags(1).Center());
+    subsizer->Add(newd wxButton(this, wxID_CANCEL, "Cancel"), wxSizerFlags(1).Border(wxALL, 5).Left().Center());
+    subsizer->Add(newd wxButton(this, wxID_APPLY, "Apply"), wxSizerFlags(1).Center());
+    sizer->Add(subsizer, 0, wxCENTER | wxLEFT | wxBOTTOM | wxRIGHT, 10);
 
-	SetSizerAndFit(sizer);
-	Centre(wxBOTH);
-	// FindWindowById(PANE_ADVANCED_GRAPHICS, this)->GetParent()->Fit();
+    SetSizerAndFit(sizer);
+    Centre(wxBOTH);
+    // FindWindowById(PANE_ADVANCED_GRAPHICS, this)->GetParent()->Fit();
 }
 
-PreferencesWindow::~PreferencesWindow() {
+PreferencesWindow::~PreferencesWindow()
+{
 	////
 }
 
-wxNotebookPage* PreferencesWindow::CreateGeneralPage() {
+wxNotebookPage* PreferencesWindow::CreateGeneralPage()
+{
 	wxNotebookPage* general_page = newd wxPanel(book, wxID_ANY);
 
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
@@ -88,7 +91,7 @@ wxNotebookPage* PreferencesWindow::CreateGeneralPage() {
 
 	sizer->AddSpacer(10);
 
-	auto* grid_sizer = newd wxFlexGridSizer(2, 10, 10);
+    auto * grid_sizer = newd wxFlexGridSizer(2, 10, 10);
 	grid_sizer->AddGrowableCol(1);
 
 	grid_sizer->Add(tmptext = newd wxStaticText(general_page, wxID_ANY, "Undo queue size: "), 0);
@@ -115,7 +118,7 @@ wxNotebookPage* PreferencesWindow::CreateGeneralPage() {
 	sizer->AddSpacer(10);
 
 	wxString position_choices[] = { "  {x = 0, y = 0, z = 0}",
-									R"(  {"x":0,"y":0,"z":0})",
+                                    R"(  {"x":0,"y":0,"z":0})",
 									"  x, y, z",
 									"  (x, y, z)",
 									"  Position(x, y, z)" };
@@ -125,12 +128,36 @@ wxNotebookPage* PreferencesWindow::CreateGeneralPage() {
 	sizer->Add(position_format, 0, wxALL | wxEXPAND, 5);
 	SetWindowToolTip(tmptext, position_format, "The position format when copying from the map.");
 
+		// clip << "{";
+		// clip << "fromx = " << minPos.x << ", ";
+		// clip << "tox = " << maxPos.x << ", ";
+		// clip << "fromy = " << minPos.y << ", ";
+		// clip << "toy = " << maxPos.y << ", ";
+		// if(minPos.z != maxPos.z) {
+		// 	clip << "fromz = " << minPos.z << ", ";
+		// 	clip << "toz = " << maxPos.z;
+		// }
+		// else
+		// 	clip << "z = " << minPos.z;
+		// clip << "}";
+
+	wxString area_choices[] = { "  {fromx = 0, tox = 0, fromy = 0, toy = 0, fromz = 0, toz = 0}",
+								"  { x = 0, y = 0, z = 0 }, { x = 0, y = 0, z = 0 }",
+								"  Position(x, y, z), Position(x, y, z)" };
+	int area_radio_choices = sizeof(area_choices) / sizeof(wxString);
+	area_format = newd wxRadioBox(general_page, wxID_ANY, "Copy Area Format", wxDefaultPosition, wxDefaultSize, area_radio_choices, area_choices, 1, wxRA_SPECIFY_COLS);
+	area_format->SetSelection(g_settings.getInteger(Config::COPY_POSITION_FORMAT));
+	sizer->Add(area_format, 0, wxALL | wxEXPAND, 5);
+	SetWindowToolTip(tmptext, area_format, "The area format when copying from the map.");
+
+
 	general_page->SetSizerAndFit(sizer);
 
 	return general_page;
 }
 
-wxNotebookPage* PreferencesWindow::CreateEditorPage() {
+wxNotebookPage* PreferencesWindow::CreateEditorPage()
+{
 	wxNotebookPage* editor_page = newd wxPanel(book, wxID_ANY);
 
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
@@ -197,7 +224,8 @@ wxNotebookPage* PreferencesWindow::CreateEditorPage() {
 	return editor_page;
 }
 
-wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
+wxNotebookPage* PreferencesWindow::CreateGraphicsPage()
+{
 	wxWindow* tmp;
 	wxNotebookPage* graphics_page = newd wxPanel(book, wxID_ANY);
 
@@ -220,7 +248,7 @@ wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
 
 	sizer->AddSpacer(10);
 
-	auto* subsizer = newd wxFlexGridSizer(2, 10, 10);
+    auto * subsizer = newd wxFlexGridSizer(2, 10, 10);
 	subsizer->AddGrowableCol(1);
 
 	// Icon background color
@@ -228,9 +256,9 @@ wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
 	icon_background_choice->Append("Black background");
 	icon_background_choice->Append("Gray background");
 	icon_background_choice->Append("White background");
-	if (g_settings.getInteger(Config::ICON_BACKGROUND) == 255) {
+	if(g_settings.getInteger(Config::ICON_BACKGROUND) == 255) {
 		icon_background_choice->SetSelection(2);
-	} else if (g_settings.getInteger(Config::ICON_BACKGROUND) == 88) {
+	} else if(g_settings.getInteger(Config::ICON_BACKGROUND) == 88) {
 		icon_background_choice->SetSelection(1);
 	} else {
 		icon_background_choice->SetSelection(0);
@@ -242,12 +270,22 @@ wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
 
 	// Cursor colors
 	subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Cursor color: "), 0);
-	subsizer->Add(cursor_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(g_settings.getInteger(Config::CURSOR_RED), g_settings.getInteger(Config::CURSOR_GREEN), g_settings.getInteger(Config::CURSOR_BLUE), g_settings.getInteger(Config::CURSOR_ALPHA))), 0);
+	subsizer->Add(cursor_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(
+		g_settings.getInteger(Config::CURSOR_RED),
+		g_settings.getInteger(Config::CURSOR_GREEN),
+		g_settings.getInteger(Config::CURSOR_BLUE),
+		g_settings.getInteger(Config::CURSOR_ALPHA)
+		)), 0);
 	SetWindowToolTip(icon_background_choice, tmp, "The color of the main cursor on the map (while in drawing mode).");
 
 	// Alternate cursor color
 	subsizer->Add(tmp = newd wxStaticText(graphics_page, wxID_ANY, "Secondary cursor color: "), 0);
-	subsizer->Add(cursor_alt_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(g_settings.getInteger(Config::CURSOR_ALT_RED), g_settings.getInteger(Config::CURSOR_ALT_GREEN), g_settings.getInteger(Config::CURSOR_ALT_BLUE), g_settings.getInteger(Config::CURSOR_ALT_ALPHA))), 0);
+	subsizer->Add(cursor_alt_color_pick = newd wxColourPickerCtrl(graphics_page, wxID_ANY, wxColor(
+		g_settings.getInteger(Config::CURSOR_ALT_RED),
+		g_settings.getInteger(Config::CURSOR_ALT_GREEN),
+		g_settings.getInteger(Config::CURSOR_ALT_BLUE),
+		g_settings.getInteger(Config::CURSOR_ALT_ALPHA)
+		)), 0);
 	SetWindowToolTip(icon_background_choice, tmp, "The color of the secondary cursor on the map (for houses and flags).");
 
 	// Screenshot dir
@@ -264,13 +302,13 @@ wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
 	screenshot_format_choice->Append("JPG");
 	screenshot_format_choice->Append("TGA");
 	screenshot_format_choice->Append("BMP");
-	if (g_settings.getString(Config::SCREENSHOT_FORMAT) == "png") {
+	if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "png") {
 		screenshot_format_choice->SetSelection(0);
-	} else if (g_settings.getString(Config::SCREENSHOT_FORMAT) == "jpg") {
+	} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "jpg") {
 		screenshot_format_choice->SetSelection(1);
-	} else if (g_settings.getString(Config::SCREENSHOT_FORMAT) == "tga") {
+	} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "tga") {
 		screenshot_format_choice->SetSelection(2);
-	} else if (g_settings.getString(Config::SCREENSHOT_FORMAT) == "bmp") {
+	} else if(g_settings.getString(Config::SCREENSHOT_FORMAT) == "bmp") {
 		screenshot_format_choice->SetSelection(3);
 	} else {
 		screenshot_format_choice->SetSelection(0);
@@ -336,7 +374,8 @@ wxNotebookPage* PreferencesWindow::CreateGraphicsPage() {
 	return graphics_page;
 }
 
-wxChoice* PreferencesWindow::AddPaletteStyleChoice(wxWindow* parent, wxSizer* sizer, const wxString &short_description, const wxString &description, const std::string &setting) {
+wxChoice* PreferencesWindow::AddPaletteStyleChoice(wxWindow* parent, wxSizer* sizer, const wxString& short_description, const wxString& description, const std::string& setting)
+{
 	wxStaticText* text;
 	sizer->Add(text = newd wxStaticText(parent, wxID_ANY, short_description), 0);
 
@@ -350,58 +389,56 @@ wxChoice* PreferencesWindow::AddPaletteStyleChoice(wxWindow* parent, wxSizer* si
 	text->SetToolTip(description);
 	choice->SetToolTip(description);
 
-	if (setting == "large icons") {
+	if(setting == "large icons") {
 		choice->SetSelection(0);
-	} else if (setting == "small icons") {
+	} else if(setting == "small icons") {
 		choice->SetSelection(1);
-	} else if (setting == "listbox") {
+	} else if(setting == "listbox") {
 		choice->SetSelection(2);
 	}
 
 	return choice;
 }
 
-void PreferencesWindow::SetPaletteStyleChoice(wxChoice* ctrl, int key) {
-	if (ctrl->GetSelection() == 0) {
+void PreferencesWindow::SetPaletteStyleChoice(wxChoice* ctrl, int key)
+{
+	if(ctrl->GetSelection() == 0) {
 		g_settings.setString(key, "large icons");
-	} else if (ctrl->GetSelection() == 1) {
+	} else if(ctrl->GetSelection() == 1) {
 		g_settings.setString(key, "small icons");
-	} else if (ctrl->GetSelection() == 2) {
+	} else if(ctrl->GetSelection() == 2) {
 		g_settings.setString(key, "listbox");
 	}
 }
 
-wxNotebookPage* PreferencesWindow::CreateUIPage() {
+wxNotebookPage* PreferencesWindow::CreateUIPage()
+{
 	wxNotebookPage* ui_page = newd wxPanel(book, wxID_ANY);
 
 	wxSizer* sizer = newd wxBoxSizer(wxVERTICAL);
 
-	auto* subsizer = newd wxFlexGridSizer(2, 10, 10);
+    auto * subsizer = newd wxFlexGridSizer(2, 10, 10);
 	subsizer->AddGrowableCol(1);
 	terrain_palette_style_choice = AddPaletteStyleChoice(
 		ui_page, subsizer,
 		"Terrain Palette Style:",
 		"Configures the look of the terrain palette.",
-		g_settings.getString(Config::PALETTE_TERRAIN_STYLE)
-	);
+		g_settings.getString(Config::PALETTE_TERRAIN_STYLE));
 	doodad_palette_style_choice = AddPaletteStyleChoice(
 		ui_page, subsizer,
 		"Doodad Palette Style:",
 		"Configures the look of the doodad palette.",
-		g_settings.getString(Config::PALETTE_DOODAD_STYLE)
-	);
+		g_settings.getString(Config::PALETTE_DOODAD_STYLE));
 	item_palette_style_choice = AddPaletteStyleChoice(
 		ui_page, subsizer,
 		"Item Palette Style:",
 		"Configures the look of the item palette.",
-		g_settings.getString(Config::PALETTE_ITEM_STYLE)
-	);
+		g_settings.getString(Config::PALETTE_ITEM_STYLE));
 	raw_palette_style_choice = AddPaletteStyleChoice(
 		ui_page, subsizer,
 		"RAW Palette Style:",
 		"Configures the look of the raw palette.",
-		g_settings.getString(Config::PALETTE_RAW_STYLE)
-	);
+		g_settings.getString(Config::PALETTE_RAW_STYLE));
 
 	sizer->Add(subsizer, 0, wxALL, 5);
 
@@ -456,14 +493,14 @@ wxNotebookPage* PreferencesWindow::CreateUIPage() {
 
 	sizer->Add(newd wxStaticText(ui_page, wxID_ANY, "Scroll speed: "), 0, wxLEFT | wxTOP, 5);
 
-	auto true_scrollspeed = int(std::abs(g_settings.getFloat(Config::SCROLL_SPEED)) * 10);
+    auto true_scrollspeed = int(std::abs(g_settings.getFloat(Config::SCROLL_SPEED)) * 10);
 	scroll_speed_slider = newd wxSlider(ui_page, wxID_ANY, true_scrollspeed, 1, std::max(true_scrollspeed, 100));
 	scroll_speed_slider->SetToolTip("This controls how fast the map will scroll when you hold down the center mouse button and move it around.");
 	sizer->Add(scroll_speed_slider, 0, wxEXPAND, 5);
 
 	sizer->Add(newd wxStaticText(ui_page, wxID_ANY, "Zoom speed: "), 0, wxLEFT | wxTOP, 5);
 
-	auto true_zoomspeed = int(g_settings.getFloat(Config::ZOOM_SPEED) * 10);
+    auto true_zoomspeed = int(g_settings.getFloat(Config::ZOOM_SPEED) * 10);
 	zoom_speed_slider = newd wxSlider(ui_page, wxID_ANY, true_zoomspeed, 1, std::max(true_zoomspeed, 100));
 	zoom_speed_slider->SetToolTip("This controls how fast you will zoom when you scroll the center mouse button.");
 	sizer->Add(zoom_speed_slider, 0, wxEXPAND, 5);
@@ -473,7 +510,8 @@ wxNotebookPage* PreferencesWindow::CreateUIPage() {
 	return ui_page;
 }
 
-wxNotebookPage* PreferencesWindow::CreateClientPage() {
+wxNotebookPage* PreferencesWindow::CreateClientPage()
+{
 	wxNotebookPage* client_page = newd wxPanel(book, wxID_ANY);
 
 	// Refresh g_settings
@@ -482,7 +520,7 @@ wxNotebookPage* PreferencesWindow::CreateClientPage() {
 
 	wxSizer* topsizer = newd wxBoxSizer(wxVERTICAL);
 
-	auto* options_sizer = newd wxFlexGridSizer(2, 10, 10);
+    auto * options_sizer = newd wxFlexGridSizer(2, 10, 10);
 	options_sizer->AddGrowableCol(1);
 
 	// Default client version choice control
@@ -502,20 +540,19 @@ wxNotebookPage* PreferencesWindow::CreateClientPage() {
 	topsizer->Add(options_sizer, wxSizerFlags(0).Expand());
 	topsizer->AddSpacer(10);
 
-	wxScrolledWindow* client_list_window = newd wxScrolledWindow(client_page, wxID_ANY, wxDefaultPosition, wxDefaultSize);
+	wxScrolledWindow *client_list_window = newd wxScrolledWindow(client_page, wxID_ANY, wxDefaultPosition, wxDefaultSize);
 	client_list_window->SetMinSize(FROM_DIP(this, wxSize(450, 450)));
-	auto* client_list_sizer = newd wxFlexGridSizer(2, 10, 10);
+    auto * client_list_sizer = newd wxFlexGridSizer(2, 10, 10);
 	client_list_sizer->AddGrowableCol(1);
 
-	int version_counter = 0;
+    int version_counter = 0;
 	for (auto version : versions) {
-		if (!version->isVisible()) {
+        if(!version->isVisible())
 			continue;
-		}
 
 		default_version_choice->Append(wxstr(version->getName()));
 
-		wxStaticText* tmp_text = newd wxStaticText(client_list_window, wxID_ANY, wxString(version->getName()));
+		wxStaticText *tmp_text = newd wxStaticText(client_list_window, wxID_ANY, wxString(version->getName()));
 		client_list_sizer->Add(tmp_text, wxSizerFlags(0).Expand());
 
 		wxDirPickerCtrl* dir_picker = newd wxDirPickerCtrl(client_list_window, wxID_ANY, version->getClientPath().GetFullPath());
@@ -527,9 +564,8 @@ wxNotebookPage* PreferencesWindow::CreateClientPage() {
 		tmp_text->SetToolTip(tooltip);
 		dir_picker->SetToolTip(tooltip);
 
-		if (version->getID() == g_settings.getInteger(Config::DEFAULT_CLIENT_VERSION)) {
+		if(version->getID() == g_settings.getInteger(Config::DEFAULT_CLIENT_VERSION))
 			default_version_choice->SetSelection(version_counter);
-		}
 
 		version_counter++;
 	}
@@ -546,27 +582,32 @@ wxNotebookPage* PreferencesWindow::CreateClientPage() {
 
 // Event handlers!
 
-void PreferencesWindow::OnClickOK(wxCommandEvent &WXUNUSED(event)) {
+void PreferencesWindow::OnClickOK(wxCommandEvent& WXUNUSED(event))
+{
 	Apply();
 	EndModal(0);
 }
 
-void PreferencesWindow::OnClickCancel(wxCommandEvent &WXUNUSED(event)) {
+void PreferencesWindow::OnClickCancel(wxCommandEvent& WXUNUSED(event))
+{
 	EndModal(0);
 }
 
-void PreferencesWindow::OnClickApply(wxCommandEvent &WXUNUSED(event)) {
+void PreferencesWindow::OnClickApply(wxCommandEvent& WXUNUSED(event))
+{
 	Apply();
 }
 
-void PreferencesWindow::OnCollapsiblePane(wxCollapsiblePaneEvent &event) {
-	auto* win = (wxWindow*)event.GetEventObject();
+void PreferencesWindow::OnCollapsiblePane(wxCollapsiblePaneEvent& event)
+{
+    auto * win = (wxWindow*)event.GetEventObject();
 	win->GetParent()->Fit();
 }
 
 // Stuff
 
-void PreferencesWindow::Apply() {
+void PreferencesWindow::Apply()
+{
 	bool must_restart = false;
 	// General
 	g_settings.setInteger(Config::WELCOME_DIALOG, show_welcome_dialog_chkbox->GetValue());
@@ -578,6 +619,7 @@ void PreferencesWindow::Apply() {
 	g_settings.setInteger(Config::WORKER_THREADS, worker_threads_spin->GetValue());
 	g_settings.setInteger(Config::REPLACE_SIZE, replace_size_spin->GetValue());
 	g_settings.setInteger(Config::COPY_POSITION_FORMAT, position_format->GetSelection());
+	g_settings.setInteger(Config::COPY_AREA_FORMAT, area_format->GetSelection());
 
 	// Editor
 	g_settings.setInteger(Config::GROUP_ACTIONS, group_actions_chkbox->GetValue());
@@ -594,22 +636,22 @@ void PreferencesWindow::Apply() {
 
 	// Graphics
 	g_settings.setInteger(Config::USE_GUI_SELECTION_SHADOW, icon_selection_shadow_chkbox->GetValue());
-	if (g_settings.getBoolean(Config::USE_MEMCACHED_SPRITES) != use_memcached_chkbox->GetValue()) {
+	if(g_settings.getBoolean(Config::USE_MEMCACHED_SPRITES) != use_memcached_chkbox->GetValue()) {
 		must_restart = true;
 	}
 	g_settings.setInteger(Config::USE_MEMCACHED_SPRITES_TO_SAVE, use_memcached_chkbox->GetValue());
-	if (icon_background_choice->GetSelection() == 0) {
-		if (g_settings.getInteger(Config::ICON_BACKGROUND) != 0) {
+	if(icon_background_choice->GetSelection() == 0) {
+		if(g_settings.getInteger(Config::ICON_BACKGROUND) != 0) {
 			g_gui.gfx.cleanSoftwareSprites();
 		}
 		g_settings.setInteger(Config::ICON_BACKGROUND, 0);
-	} else if (icon_background_choice->GetSelection() == 1) {
-		if (g_settings.getInteger(Config::ICON_BACKGROUND) != 88) {
+	} else if(icon_background_choice->GetSelection() == 1) {
+		if(g_settings.getInteger(Config::ICON_BACKGROUND) != 88) {
 			g_gui.gfx.cleanSoftwareSprites();
 		}
 		g_settings.setInteger(Config::ICON_BACKGROUND, 88);
-	} else if (icon_background_choice->GetSelection() == 2) {
-		if (g_settings.getInteger(Config::ICON_BACKGROUND) != 255) {
+	} else if(icon_background_choice->GetSelection() == 2) {
+		if(g_settings.getInteger(Config::ICON_BACKGROUND) != 255) {
 			g_gui.gfx.cleanSoftwareSprites();
 		}
 		g_settings.setInteger(Config::ICON_BACKGROUND, 255);
@@ -619,27 +661,27 @@ void PreferencesWindow::Apply() {
 	g_settings.setString(Config::SCREENSHOT_DIRECTORY, nstr(screenshot_directory_picker->GetPath()));
 
 	std::string new_format = nstr(screenshot_format_choice->GetStringSelection());
-	if (new_format == "PNG") {
+	if(new_format == "PNG") {
 		g_settings.setString(Config::SCREENSHOT_FORMAT, "png");
-	} else if (new_format == "TGA") {
+	} else if(new_format == "TGA") {
 		g_settings.setString(Config::SCREENSHOT_FORMAT, "tga");
-	} else if (new_format == "JPG") {
+	} else if(new_format == "JPG") {
 		g_settings.setString(Config::SCREENSHOT_FORMAT, "jpg");
-	} else if (new_format == "BMP") {
+	} else if(new_format == "BMP") {
 		g_settings.setString(Config::SCREENSHOT_FORMAT, "bmp");
 	}
 
 	wxColor clr = cursor_color_pick->GetColour();
-	g_settings.setInteger(Config::CURSOR_RED, clr.Red());
-	g_settings.setInteger(Config::CURSOR_GREEN, clr.Green());
-	g_settings.setInteger(Config::CURSOR_BLUE, clr.Blue());
-	// g_settings.setInteger(Config::CURSOR_ALPHA, clr.Alpha());
+		g_settings.setInteger(Config::CURSOR_RED, clr.Red());
+		g_settings.setInteger(Config::CURSOR_GREEN, clr.Green());
+		g_settings.setInteger(Config::CURSOR_BLUE, clr.Blue());
+		//g_settings.setInteger(Config::CURSOR_ALPHA, clr.Alpha());
 
 	clr = cursor_alt_color_pick->GetColour();
-	g_settings.setInteger(Config::CURSOR_ALT_RED, clr.Red());
-	g_settings.setInteger(Config::CURSOR_ALT_GREEN, clr.Green());
-	g_settings.setInteger(Config::CURSOR_ALT_BLUE, clr.Blue());
-	// g_settings.setInteger(Config::CURSOR_ALT_ALPHA, clr.Alpha());
+		g_settings.setInteger(Config::CURSOR_ALT_RED, clr.Red());
+		g_settings.setInteger(Config::CURSOR_ALT_GREEN, clr.Green());
+		g_settings.setInteger(Config::CURSOR_ALT_BLUE, clr.Blue());
+		//g_settings.setInteger(Config::CURSOR_ALT_ALPHA, clr.Alpha());
 
 	g_settings.setInteger(Config::HIDE_ITEMS_WHEN_ZOOMED, hide_items_when_zoomed_chkbox->GetValue());
 	/*
@@ -664,29 +706,28 @@ void PreferencesWindow::Apply() {
 	g_settings.setInteger(Config::USE_LARGE_CONTAINER_ICONS, large_container_icons_chkbox->GetValue());
 	g_settings.setInteger(Config::USE_LARGE_CHOOSE_ITEM_ICONS, large_pick_item_icons_chkbox->GetValue());
 
+
 	g_settings.setInteger(Config::SWITCH_MOUSEBUTTONS, switch_mousebtn_chkbox->GetValue());
 	g_settings.setInteger(Config::DOUBLECLICK_PROPERTIES, doubleclick_properties_chkbox->GetValue());
 
 	float scroll_mul = 1.0;
-	if (inversed_scroll_chkbox->GetValue()) {
+	if(inversed_scroll_chkbox->GetValue()) {
 		scroll_mul = -1.0;
 	}
-	g_settings.setFloat(Config::SCROLL_SPEED, scroll_mul * scroll_speed_slider->GetValue() / 10.f);
-	g_settings.setFloat(Config::ZOOM_SPEED, zoom_speed_slider->GetValue() / 10.f);
+	g_settings.setFloat(Config::SCROLL_SPEED, scroll_mul * scroll_speed_slider->GetValue()/10.f);
+	g_settings.setFloat(Config::ZOOM_SPEED, zoom_speed_slider->GetValue()/10.f);
 
 	// Client
 	ClientVersionList versions = ClientVersion::getAllVisible();
 	int version_counter = 0;
 	for (auto version : versions) {
-		wxString dir = version_dir_pickers[version_counter]->GetPath();
-		if (dir.Length() > 0 && dir.Last() != '/' && dir.Last() != '\\') {
-			dir.Append("/");
-		}
+        auto dir = version_dir_pickers[version_counter]->GetPath().ToStdString();
+		if(dir.size() > 0 && dir.back() != '/' && dir.back() != '\\')
+			dir.push_back('/');
 		version->setClientPath(FileName(dir));
 
-		if (version->getName() == default_version_choice->GetStringSelection()) {
+		if(version->getName() == default_version_choice->GetStringSelection())
 			g_settings.setInteger(Config::DEFAULT_CLIENT_VERSION, version->getID());
-		}
 
 		version_counter++;
 	}
@@ -698,7 +739,7 @@ void PreferencesWindow::Apply() {
 
 	g_settings.save();
 
-	if (must_restart) {
+	if(must_restart) {
 		g_gui.PopupDialog(this, "Notice", "You must restart the editor for the changes to take effect.", wxOK);
 	}
 	g_gui.RebuildPalettes();
diff --git a/source/preferences.h b/source/preferences.h
index 3ffb9cc3..ff6b725e 100644
--- a/source/preferences.h
+++ b/source/preferences.h
@@ -51,6 +51,7 @@ class PreferencesWindow : public wxDialog {
 	wxSpinCtrl* worker_threads_spin;
 	wxSpinCtrl* replace_size_spin;
 	wxRadioBox* position_format;
+	wxRadioBox* area_format;
 
 	// Editor
 	wxCheckBox* group_actions_chkbox;
diff --git a/source/settings.cpp b/source/settings.cpp
index 839add4d..b950674f 100644
--- a/source/settings.cpp
+++ b/source/settings.cpp
@@ -256,6 +256,7 @@ void Settings::IO(IOMode mode) {
 	Int(WARN_FOR_DUPLICATE_ID, 1);
 	Int(AUTO_CREATE_SPAWN_MONSTER, 1);
 	Int(DEFAULT_SPAWN_MONSTER_TIME, 60);
+	Int(SPAWN_MONSTER_DENSITY, 10);
 	Int(MAX_SPAWN_MONSTER_RADIUS, 30);
 	Int(CURRENT_SPAWN_MONSTER_RADIUS, 1);
 	Int(AUTO_CREATE_SPAWN_NPC, 1);
@@ -270,6 +271,7 @@ void Settings::IO(IOMode mode) {
 	Int(SAVE_WITH_OTB_MAGIC_NUMBER, 0);
 	Int(REPLACE_SIZE, 500);
 	Int(COPY_POSITION_FORMAT, 0);
+	Int(COPY_AREA_FORMAT, 0);
 
 	section("Graphics");
 	Int(TEXTURE_MANAGEMENT, 1);
diff --git a/source/settings.h b/source/settings.h
index c678920c..26f60540 100644
--- a/source/settings.h
+++ b/source/settings.h
@@ -127,6 +127,7 @@ namespace Config {
 		CURRENT_SPAWN_MONSTER_RADIUS,
 		AUTO_CREATE_SPAWN_MONSTER,
 		DEFAULT_SPAWN_MONSTER_TIME,
+		SPAWN_MONSTER_DENSITY,
 
 		MAX_SPAWN_NPC_RADIUS,
 		CURRENT_SPAWN_NPC_RADIUS,
@@ -139,6 +140,7 @@ namespace Config {
 		RAW_LIKE_SIMONE,
 		WORKER_THREADS,
 		COPY_POSITION_FORMAT,
+		COPY_AREA_FORMAT,
 
 		GOTO_WEBSITE_ON_BOOT,
 		INDIRECTORY_INSTALLATION,
diff --git a/source/spawn_monster_brush.cpp b/source/spawn_monster_brush.cpp
index 018bc4bf..6e4630e9 100644
--- a/source/spawn_monster_brush.cpp
+++ b/source/spawn_monster_brush.cpp
@@ -20,46 +20,73 @@
 #include "spawn_monster_brush.h"
 #include "basemap.h"
 #include "spawn_monster.h"
+#include "monster_brush.h"
 
 //=============================================================================
 // SpawnMonster brush
 
 SpawnMonsterBrush::SpawnMonsterBrush() :
-	Brush() {
+	Brush()
+{
 	////
 }
 
-SpawnMonsterBrush::~SpawnMonsterBrush() {
+SpawnMonsterBrush::~SpawnMonsterBrush()
+{
 	////
 }
 
-int SpawnMonsterBrush::getLookID() const {
+int SpawnMonsterBrush::getLookID() const
+{
 	return 0;
 }
 
-std::string SpawnMonsterBrush::getName() const {
+std::string SpawnMonsterBrush::getName() const
+{
 	return "SpawnMonster Brush";
 }
 
-bool SpawnMonsterBrush::canDraw(BaseMap* map, const Position &position) const {
+bool SpawnMonsterBrush::canDraw(BaseMap* map, const Position& position) const
+{
 	Tile* tile = map->getTile(position);
-	if (tile) {
-		if (tile->spawnMonster) {
+	if(tile) {
+		if(tile->spawnMonster) {
 			return false;
 		}
 	}
 	return true;
 }
 
-void SpawnMonsterBrush::undraw(BaseMap* map, Tile* tile) {
+void SpawnMonsterBrush::undraw(BaseMap* map, Tile* tile)
+{
 	delete tile->spawnMonster;
 	tile->spawnMonster = nullptr;
 }
 
-void SpawnMonsterBrush::draw(BaseMap* map, Tile* tile, void* parameter) {
+void SpawnMonsterBrush::draw(BaseMap* map, Tile* tile, void* parameter)
+{
 	ASSERT(tile);
 	ASSERT(parameter); // Should contain an int which is the size of the newd monster spawn
+	auto size  = std::max(1, *(int*)parameter);
+	auto side = size * 2 + 1;
+	int time = g_settings.getInteger(Config::DEFAULT_SPAWN_MONSTER_TIME);
+	int density = g_settings.getInteger(Config::SPAWN_MONSTER_DENSITY);
 	if (tile->spawnMonster == nullptr) {
-		tile->spawnMonster = newd SpawnMonster(std::max(1, *(int*)parameter));
+		tile->spawnMonster = newd SpawnMonster(size);
+		auto toSpawn = (int)std::ceil((side * side) * (density / 100.0));
+		std::set<Position> positions;
+		for (int i = 0; i < side; i++) {
+			for (int j = 0; j < side; j++) {
+				positions.insert(Position(tile->getPosition().x - size + i, tile->getPosition().y - size + j, tile->getPosition().z));
+			}
+		}
+
+		for (int i = 0; i < toSpawn; ++i) {
+			auto iter = positions.begin();
+			std::advance(iter, rand() % positions.size());
+			auto monsterBrush = monsters[rand() % monsters.size()];
+			monsterBrush->drawMonster(map, map->getTile(*iter), &time);
+			positions.erase(iter);
+		}
 	}
 }
diff --git a/source/spawn_monster_brush.h b/source/spawn_monster_brush.h
index 894aa6e6..b4477c08 100644
--- a/source/spawn_monster_brush.h
+++ b/source/spawn_monster_brush.h
@@ -23,33 +23,29 @@
 //=============================================================================
 // SpawnMonsterBrush, place monster spawn
 
-class SpawnMonsterBrush : public Brush {
+class SpawnMonsterBrush : public Brush
+{
 public:
 	SpawnMonsterBrush(); // Create a RAWBrush of the specified type
 	virtual ~SpawnMonsterBrush();
 
-	bool isSpawnMonster() const {
-		return true;
-	}
-	SpawnMonsterBrush* asSpawnMonster() {
-		return static_cast<SpawnMonsterBrush*>(this);
-	}
+	bool isSpawnMonster() const { return true; }
+	SpawnMonsterBrush* asSpawnMonster() { return static_cast<SpawnMonsterBrush*>(this); }
 
-	virtual bool canDraw(BaseMap* map, const Position &position) const;
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
 	virtual void draw(BaseMap* map, Tile* tile, void* parameter); // parameter is brush size
 	virtual void undraw(BaseMap* map, Tile* tile);
 
 	virtual int getLookID() const; // We don't have a look, sorry!
 	virtual std::string getName() const;
-	virtual bool canDrag() const {
-		return true;
-	}
-	virtual bool canSmear() const {
-		return false;
-	}
-	virtual bool oneSizeFitsAll() const {
-		return true;
-	}
+	virtual bool canDrag() const { return true; }
+	virtual bool canSmear() const { return false; }
+	virtual bool oneSizeFitsAll() const { return true; }
+
+	void setMonsters(std::vector<MonsterBrush*>& monsters) { this->monsters = monsters; }
+
+private:
+	std::vector<MonsterBrush*> monsters;
 };
 
 #endif
diff --git a/source/tile.cpp b/source/tile.cpp
index 52116357..3bcb05b9 100644
--- a/source/tile.cpp
+++ b/source/tile.cpp
@@ -96,6 +96,9 @@ Tile* Tile::deepCopy(BaseMap &map) const {
 	for (const Item* item : items) {
 		copy->items.push_back(item->deepCopy());
 	}
+	for (unsigned int zone : zones) {
+		copy->zones.insert(zone);
+	}
 	return copy;
 }
 
diff --git a/source/tile.h b/source/tile.h
index 92370ffe..c47cf8f3 100644
--- a/source/tile.h
+++ b/source/tile.h
@@ -57,6 +57,7 @@ class Tile {
 	Npc* npc;
 	SpawnNpc* spawnNpc;
 	uint32_t house_id; // House id for this tile (pointer not safe)
+	std::set<unsigned int> zones;
 
 public:
 	// ALWAYS use this constructor if the Tile is EVER going to be placed on a map
@@ -248,6 +249,18 @@ class Tile {
 	void unsetStatFlags(uint16_t flags);
 	uint16_t getStatFlags() const noexcept;
 
+	bool hasZone(unsigned int zone) const {
+		return zones.find(zone) != zones.end();
+	}
+
+	void addZone(unsigned int zone) {
+		zones.insert(zone);
+	}
+
+	void removeZone(unsigned int zone) {
+		zones.erase(zone);
+	}
+
 protected:
 	union {
 		struct {
diff --git a/source/tileset.h b/source/tileset.h
index 0afee2a1..af4e5bc7 100644
--- a/source/tileset.h
+++ b/source/tileset.h
@@ -30,6 +30,7 @@ enum TilesetCategoryType {
 	TILESET_RAW,
 	TILESET_HOUSE,
 	TILESET_WAYPOINT,
+	TILESET_ZONES,
 };
 
 class TilesetCategory {
diff --git a/source/zone_brush.cpp b/source/zone_brush.cpp
new file mode 100644
index 00000000..31e3d0af
--- /dev/null
+++ b/source/zone_brush.cpp
@@ -0,0 +1,56 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+#include "main.h"
+
+#include "zone_brush.h"
+#include "zones.h"
+#include "basemap.h"
+
+//=============================================================================
+// Zone Brush
+
+ZoneBrush::ZoneBrush() :
+	FlagBrush(0) {
+	////
+}
+
+ZoneBrush::~ZoneBrush() {
+	////
+}
+
+void ZoneBrush::setZone(unsigned int id) {
+	zoneId = id;
+}
+
+unsigned int ZoneBrush::getZone() const {
+	return zoneId;
+}
+
+bool ZoneBrush::canDraw(BaseMap* map, const Position &position) const {
+	return map->getTile(position) != nullptr && zoneId != 0;
+}
+
+void ZoneBrush::undraw(BaseMap* map, Tile* tile) {
+	tile->removeZone(zoneId);
+}
+
+void ZoneBrush::draw(BaseMap* map, Tile* tile, void* parameter) {
+	if (tile->hasGround()) {
+		tile->addZone(zoneId);
+	}
+}
diff --git a/source/zone_brush.h b/source/zone_brush.h
new file mode 100644
index 00000000..1aa8f012
--- /dev/null
+++ b/source/zone_brush.h
@@ -0,0 +1,51 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+#ifndef RME_ZONE_BRUSH_H
+#define RME_ZONE_BRUSH_H
+
+#include "brush.h"
+
+//=============================================================================
+// ZoneBrush, draws zones simply
+
+class ZoneBrush : public FlagBrush
+{
+public:
+	ZoneBrush();
+	virtual ~ZoneBrush();
+
+	bool isZone() const { return true; }
+	ZoneBrush* asZone() { return static_cast<ZoneBrush*>(this); }
+
+	// Not used
+	virtual bool load(pugi::xml_node node, wxArrayString& warnings) { return true; }
+
+	virtual bool canDraw(BaseMap* map, const Position& position) const;
+	virtual void draw(BaseMap* map, Tile* tile, void* parameter);
+	virtual void undraw(BaseMap* map, Tile* tile);
+
+	unsigned int getZone() const;
+	void setZone(unsigned int id);
+	virtual int getLookID() const { return 0; } // We don't have a graphic
+	virtual std::string getName() const { return "Zone Brush"; }
+
+protected:
+	unsigned int zoneId;
+};
+
+#endif
diff --git a/source/zones.cpp b/source/zones.cpp
new file mode 100644
index 00000000..d2393fd5
--- /dev/null
+++ b/source/zones.cpp
@@ -0,0 +1,70 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+#include "main.h"
+
+#include "zones.h"
+#include "map.h"
+
+Zones::~Zones()
+{
+	zones.clear();
+}
+
+bool Zones::addZone(std::string name, unsigned int id)
+{
+	if (hasZone(name))
+		return false;
+	if (used_ids.find(id) != used_ids.end())
+		return false;
+	zones.emplace(name, id);
+	used_ids.insert(id);
+	return true;
+}
+
+bool Zones::addZone(std::string name)
+{
+	return addZone(name, generateID());
+}
+
+bool Zones::hasZone(std::string name)
+{
+	to_lower_str(name);
+	return zones.find(name) != zones.end();
+}
+
+bool Zones::hasZone(unsigned int id)
+{
+	return used_ids.find(id) != used_ids.end();
+}
+
+void Zones::removeZone(std::string name)
+{
+	to_lower_str(name);
+	if (!hasZone(name))
+		return;
+	used_ids.erase(zones[name]);
+	zones.erase(name);
+}
+
+unsigned int Zones::generateID()
+{
+	unsigned int id = 1;
+	while (used_ids.find(id) != used_ids.end())
+		id++;
+	return id;
+}
diff --git a/source/zones.h b/source/zones.h
new file mode 100644
index 00000000..e0cc774a
--- /dev/null
+++ b/source/zones.h
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////
+// This file is part of Remere's Map Editor
+//////////////////////////////////////////////////////////////////////
+// Remere's Map Editor is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// Remere's Map Editor is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//////////////////////////////////////////////////////////////////////
+
+#ifndef RME_ZONES_H_
+#define RME_ZONES_H_
+
+typedef std::map<std::string, unsigned int> ZoneMap;
+
+class Zones
+{
+public:
+	Zones(Map& map) : map(map) {}
+	virtual ~Zones();
+
+	unsigned int getZoneID(std::string name) const {
+		auto it = zones.find(name);
+		if (it == zones.end())
+			return 0;
+		return it->second;
+	}
+	bool addZone(std::string name);
+	bool addZone(std::string name, unsigned int id);
+	bool hasZone(std::string name);
+	bool hasZone(unsigned int id);
+	void removeZone(std::string name);
+
+	ZoneMap zones;
+
+	ZoneMap::iterator begin() { return zones.begin(); }
+	ZoneMap::const_iterator begin() const { return zones.begin(); }
+	ZoneMap::iterator end() { return zones.end(); }
+	ZoneMap::const_iterator end() const { return zones.end(); }
+
+private:
+	Map& map;
+	std::unordered_set<unsigned int> used_ids;
+
+	unsigned int generateID();
+};
+
+#endif
diff --git a/vcproj/Project/RME.vcxproj b/vcproj/Project/RME.vcxproj
index 9f5b06f8..de70b1c0 100644
--- a/vcproj/Project/RME.vcxproj
+++ b/vcproj/Project/RME.vcxproj
@@ -22,6 +22,7 @@
     <ProjectGuid>{7AA6C5AC-C8C4-40EF-A0B3-3569B9819163}</ProjectGuid>
     <RootNamespace>RME</RootNamespace>
     <Keyword>Win32Proj</Keyword>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
@@ -95,6 +96,11 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <TargetName>$(ProjectName)_x64</TargetName>
+    <OutDir>$(SolutionDir)\..</OutDir>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <OutDir>$(SolutionDir)\..</OutDir>
+    <TargetName>$(ProjectName)_Debug</TargetName>
   </PropertyGroup>
   <PropertyGroup Label="Vcpkg">
     <VcpkgEnableManifest>true</VcpkgEnableManifest>
@@ -140,16 +146,17 @@
       <PrecompiledHeaderFile>main.h</PrecompiledHeaderFile>
       <AdditionalOptions>/bigobj %(AdditionalOptions)</AdditionalOptions>
       <LanguageStandard>stdcpp20</LanguageStandard>
+      <TreatWChar_tAsBuiltInType>true</TreatWChar_tAsBuiltInType>
     </ClCompile>
     <Link>
       <AdditionalDependencies>comctl32.lib;Rpcrt4.lib;WS2_32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <AdditionalLibraryDirectories>$(SolutionDir)..\dependencies\vs\lib\</AdditionalLibraryDirectories>
+      <AdditionalLibraryDirectories>$(SolutionDir)..\dependencies\vs\lib\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <GenerateMapFile>true</GenerateMapFile>
       <MapFileName>$(TargetName).map</MapFileName>
       <MapExports>true</MapExports>
       <SubSystem>Windows</SubSystem>
-      <IgnoreSpecificDefaultLibraries>wxscintillad.lib;freeglutd.lib</IgnoreSpecificDefaultLibraries>
+      <IgnoreSpecificDefaultLibraries>freeglutd.lib</IgnoreSpecificDefaultLibraries>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -221,8 +228,11 @@
     <ClCompile Include="..\..\source\find_item_window.cpp" />
     <ClCompile Include="..\..\source\light_drawer.cpp" />
     <ClCompile Include="..\..\source\iominimap.cpp" />
+    <ClCompile Include="..\..\source\palette_zones.cpp" />
     <ClCompile Include="..\..\source\replace_items_window.cpp" />
     <ClCompile Include="..\..\source\welcome_dialog.cpp" />
+    <ClCompile Include="..\..\source\zones.cpp" />
+    <ClCompile Include="..\..\source\zone_brush.cpp" />
     <ClInclude Include="..\..\source\actions_history_window.h" />
     <ClInclude Include="..\..\source\artprovider.h" />
     <ClInclude Include="..\..\source\const.h" />
@@ -232,6 +242,7 @@
     <ClInclude Include="..\..\source\browse_tile_window.h" />
     <ClCompile Include="..\..\source\browse_tile_window.cpp" />
     <ClInclude Include="..\..\source\iominimap.h" />
+    <ClInclude Include="..\..\source\palette_zones.h" />
     <ClInclude Include="..\..\source\positionctrl.h" />
     <ClCompile Include="..\..\source\main_toolbar.cpp" />
     <ClCompile Include="..\..\source\positionctrl.cpp" />
@@ -423,6 +434,8 @@
     <ClCompile Include="..\..\source\waypoint_brush.cpp" />
     <ClInclude Include="..\..\source\find_item_window.h" />
     <ClInclude Include="..\..\source\welcome_dialog.h" />
+    <ClInclude Include="..\..\source\zones.h" />
+    <ClInclude Include="..\..\source\zone_brush.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\..\source\mkpch.cpp">