Merge lp:~janosch-peters-deactivatedaccount/widelands/editor-remove-invalid-resources into lp:widelands

[xxx-deleted]

1. Map::change_terrain verifies now if the new terrain matches the current resource. If it doesen't, the resource is deleted. This fixes the bug in the editor.

2. A new method Map::check_res_consistency is called when a map is loaded. The method looks for invalid resources on every node and if present, deletes them. This "fixes" broken maps on load and affects both the editor and the game.

Sidenote: I introduced a new special index for "No Resource" (until now fields without resources were set to (type:0,amount:0), which is confusing)

Testing:
1. Start the editor. Add "water" resource on a grass terrain. Then, change the terrain to mountain. The water resource should vanish.

2. I attached the map "invalid_resources.wmf" on #977980. If you load the map the invalid resource "water" on a mountain terrain node (7,5) are removed. Likewise, the invalid resource "gold" is removed from (2,3), a water node.

[kaputtnik (franku)]

I got a total crash of the editor if i try to place fish on water... No output in console, just a total crash.

review: Needs Fixing

[Tino (tino79)]

Looks good and compiles fine.
But now, when I start the editor and increase a resource on any field I get a segfault.

review: Needs Fixing

[xxx-deleted (janosch-peters-deactivatedaccount)]

@kaputtnik,Tino: I missed a check for a nullptr. I fixed it in my latest push.

[Tino (tino79)]

Now it only segfaults when you decrease (shift-click) a resource or set to 0 (ctrl-click) on a field without a resource.

review: Needs Fixing

[bunnybot (widelandsofficial)]

Hi, I am bunnybot (https://github.com/widelands/bunnybot).

I am keeping the source branch lp:~janosch-peters/widelands/editor-remove-invalid-resources mirrored to https://github.com/widelands/widelands/tree/_janosch_peters_widelands_editor_remove_invalid_resources

The latest continuous integration build can always be found here: https://travis-ci.org/widelands/widelands/branches. Please do not merge without making sure that it passes.

You can give me commands by starting a line with @bunnybot <command>. I understand:
 merge: Merges the source branch into the target branch, closing the pull request.

[Tino (tino79)]

I've created a merge request for the last mentioned bug.

And I've noticed another inconsistency:
A field with e.g. a gold resource amount of 5. Now i cannot change the resource amount with the coal increase/decrease tool. But with coal-set-to amount (alt-click) tool i can "overwrite" the gold resource.
Of course this is no issue of this branch, but i was thinking perhaps we could find a better solution for this. Or is this the intentioned behavior?

[bunnybot (widelandsofficial)]

Travis build 132 has changed state to: failed. Details: https://travis-ci.org/widelands/widelands/builds/99834203.

[TiborB (tiborb95)]

Well now I dont know which branch is the "right" one, but still, I attached a custom map into bug - the one with problematic behavior, also see my comment in the diff

[TiborB (tiborb95)]

inserting comment into diff

[xxx-deleted (janosch-peters-deactivatedaccount)]

Please note: I found out that there was duplicated code in increase/decrease/set-methods. I extracted a method to remove the duplication. However, this will lead to a conflict with your fix in rev 7665. So I dont really know what to do with your merge proposal.

And I am really confused about your rev 7666. You changed 100+ files and I dont see the connection to my bugfix. Are all those changes neccessary to make travis work?

[bunnybot (widelandsofficial)]

Travis build 155 has changed state to: created. Details: https://travis-ci.org/widelands/widelands/builds/99868658.

[Tino (tino79)]

I've merged trunk. Although it does not conflict with your current status of the branch it contains some fixes that this branch can be build by travis-ci.
Just merge trunk before resubmitting this merge request.

And if your last fix includes the fix i've done, just dissapprove it (my merge request).

[bunnybot (widelandsofficial)]

Travis build 155 has changed state to: started. Details: https://travis-ci.org/widelands/widelands/builds/99868658.

[bunnybot (widelandsofficial)]

Travis build 155 has changed state to: failed. Details: https://travis-ci.org/widelands/widelands/builds/99868658.

[bunnybot (widelandsofficial)]

Travis build 155 has changed state to: failed. Details: https://travis-ci.org/widelands/widelands/builds/99868658.

[bunnybot (widelandsofficial)]

Travis build 176 has changed state to: passed. Details: https://travis-ci.org/widelands/widelands/builds/100024382.

[SirVer (sirver)]

I think this is good to go. I have a couple of nits in the code still - most of them are your call, I do not feel strongly about them. Janosch, once you are happy with this change, please merge it by writing a comment on a line of its own: @bunnybot merge.

review: Approve

[xxx-deleted (janosch-peters-deactivatedaccount)]

@bunnybot merge

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

'Branch' object has no attribute '_lp_object'

[SirVer (sirver)]

A bug in bunnybot :/. Let's try that again.

@bunnybot merge

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr merge ../_janosch_peters_widelands_editor_remove_invalid_resources' failed. Output:

bzr: ERROR: Working tree "/home/bunnybot/bunnybot/data/bzr_repo/_widelands_dev_widelands_trunk/" has uncommitted changes (See bzr status).

[SirVer (sirver)]

Three times a charm.

@bunnybot merge

=== modified file 'src/editor/map_generator.cc'
--- src/editor/map_generator.cc	2015-11-11 09:56:22 +0000
+++ src/editor/map_generator.cc	2016-01-04 21:01:25 +0000
@@ -133,7 +133,7 @@
 		uint8_t res_val = static_cast<uint8_t>(random_value / (kMaxElevation / max_amount));
 		res_val *= static_cast<uint8_t>(map_info_.resource_amount) + 1;
 		res_val /= 3;
-		if (editor_change_resource_tool_callback(fc, map_, world, res_idx)) {
+		if (map_.is_resource_valid(world, fc, res_idx)) {
 			fc.field->set_resources(res_idx, res_val);
 			fc.field->set_initial_res_amount(res_val);
 		}

=== modified file 'src/editor/tools/editor_decrease_height_tool.cc'
--- src/editor/tools/editor_decrease_height_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_decrease_height_tool.cc	2016-01-04 21:01:25 +0000
@@ -27,47 +27,47 @@
 #include "logic/mapregion.h"
 
 /// Decreases the heights by a value. Chages surrounding nodes if necessary.
-int32_t EditorDecreaseHeightTool::handle_click_impl(Widelands::Map& map,
-                                                       const Widelands::World& world,
-                                                       Widelands::NodeAndTriangle<> center,
-                                                       EditorInteractive& /* parent */,
-                                                       EditorActionArgs& args) {
-	if (args.origHights.empty()) {
+int32_t EditorDecreaseHeightTool::handle_click_impl(const Widelands::World& world,
+													Widelands::NodeAndTriangle<> center,
+                                                    EditorInteractive& /* parent */,
+                                                    EditorActionArgs* args,
+													Widelands::Map* map) {
+	if (args->origHights.empty()) {
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
-		do args.origHights.push_back(mr.location().field->get_height());
-		while (mr.advance(map));
+		 (map->get_fcoords(center.node), args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+		do args->origHights.push_back(mr.location().field->get_height());
+		while (mr.advance(*map));
 	}
 
-	return map.change_height(
+	return map->change_height(
 	   world,
-	   Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius),
-	   -args.change_by);
+	   Widelands::Area<Widelands::FCoords>(map->get_fcoords(center.node), args->sel_radius),
+	   -args->change_by);
 }
 
 int32_t EditorDecreaseHeightTool::handle_undo_impl
-	(Widelands::Map & map,
-	 const Widelands::World& world,
+	(const Widelands::World& world,
 	Widelands::NodeAndTriangle<> center,
 	EditorInteractive & /* parent */,
-	EditorActionArgs & args)
+	EditorActionArgs* args,
+	Widelands::Map* map)
 {
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
-	std::list<Widelands::Field::Height>::iterator i = args.origHights.begin();
+	 (map->get_fcoords(center.node), args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+	std::list<Widelands::Field::Height>::iterator i = args->origHights.begin();
 
 	do {
 		mr.location().field->set_height(*i); ++i;
-	} while (mr.advance(map));
+	} while (mr.advance(*map));
 
-	map.recalc_for_field_area(world,
+	map->recalc_for_field_area(world,
 	                          Widelands::Area<Widelands::FCoords>(
-	                             map.get_fcoords(center.node),
-	                             args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 2));
+	                             map->get_fcoords(center.node),
+	                             args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 2));
 
 	return mr.radius() + 1;
 }

=== modified file 'src/editor/tools/editor_decrease_height_tool.h'
--- src/editor/tools/editor_decrease_height_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_decrease_height_tool.h	2016-01-04 21:01:25 +0000
@@ -27,16 +27,18 @@
 	EditorDecreaseHeightTool() : EditorTool(*this, *this), m_change_by(1) {}
 
 	int32_t handle_click_impl
-		(Widelands::Map & map,
-		 const Widelands::World& world,
+		(const Widelands::World& world,
 		 Widelands::NodeAndTriangle<> center,
-		 EditorInteractive & parent, EditorActionArgs & args) override;
+		 EditorInteractive & parent,
+		 EditorActionArgs* args,
+		 Widelands::Map* map) override;
 
 	int32_t handle_undo_impl
-		(Widelands::Map & map,
-		 const Widelands::World& world,
+		(const Widelands::World& world,
 		 Widelands::NodeAndTriangle<> center,
-		 EditorInteractive & parent, EditorActionArgs & args) override;
+		 EditorInteractive& parent,
+		 EditorActionArgs* args,
+		 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_decrease_resources_tool.cc'
--- src/editor/tools/editor_decrease_resources_tool.cc	2015-03-01 09:21:20 +0000
+++ src/editor/tools/editor_decrease_resources_tool.cc	2016-01-04 21:01:25 +0000
@@ -36,59 +36,40 @@
  * there is not already another resource there.
 */
 int32_t
-EditorDecreaseResourcesTool::handle_click_impl(Widelands::Map& map,
-                                                  const Widelands::World& world,
-                                                  Widelands::NodeAndTriangle<> const center,
-                                                  EditorInteractive& /* parent */,
-                                                  EditorActionArgs& args) {
+EditorDecreaseResourcesTool::handle_click_impl(const Widelands::World& world,
+                                               Widelands::NodeAndTriangle<> const center,
+                                               EditorInteractive& /* parent */,
+                                               EditorActionArgs* args,
+											   Widelands::Map* map) {
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	Widelands::Area<Widelands::FCoords>
-	(map.get_fcoords(center.node), args.sel_radius));
+	(map->get_fcoords(center.node), args->sel_radius));
 	do {
-		int32_t res    = mr.location().field->get_resources();
 		int32_t amount = mr.location().field->get_resources_amount();
 
-		amount -= args.change_by;
+		amount -= args->change_by;
 		if (amount < 0)
 			amount = 0;
 
-		args.orgResT.push_back(res);
-		args.orgRes.push_back(mr.location().field->get_resources_amount());
-
-		if (res == args.cur_res &&
-		    editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res)) {
-			//  Ok, we're doing something. First remove the current overlays.
-			std::string str =
-			    world.get_resource(res)->get_editor_pic
-			    (mr.location().field->get_resources_amount());
-			const Image* pic = g_gr->images().get(str);
-			map.overlay_manager().remove_overlay(mr.location(), pic);
-			if (!amount) {
-				mr.location().field->set_resources(0, 0);
-				mr.location().field->set_initial_res_amount(0);
-			} else {
-				mr.location().field->set_resources(args.cur_res, amount);
-				mr.location().field->set_initial_res_amount(amount);
-				//  set new overlay
-				str = world.get_resource(args.cur_res)->get_editor_pic(amount);
-				pic = g_gr->images().get(str);
-				map.overlay_manager().register_overlay(mr.location(), pic, 4);
-				map.recalc_for_field_area(
-				   world, Widelands::Area<Widelands::FCoords>(mr.location(), 0));
-			}
+		if (mr.location().field->get_resources() == args->cur_res &&
+			map->is_resource_valid(world, mr.location(), args->cur_res)) {
+			args->orgResT.push_back(mr.location().field->get_resources());
+			args->orgRes.push_back(mr.location().field->get_resources_amount());
+			EditorSetResourcesTool::set_res_and_overlay(world, amount, args->cur_res, &mr, args, map);
 		}
-	} while (mr.advance(map));
+
+
+	} while (mr.advance(*map));
 	return mr.radius();
 }
 
-int32_t EditorDecreaseResourcesTool::handle_undo_impl(
-   Widelands::Map& map,
-   const Widelands::World& world,
-   Widelands::NodeAndTriangle<Widelands::Coords> center,
-   EditorInteractive& parent,
-   EditorActionArgs& args) {
-	return parent.tools.set_resources.handle_undo_impl(map, world, center, parent, args);
+int32_t EditorDecreaseResourcesTool::handle_undo_impl(const Widelands::World& world,
+													  Widelands::NodeAndTriangle<> center,
+													  EditorInteractive& parent,
+													  EditorActionArgs* args,
+													  Widelands::Map* map) {
+	return parent.tools.set_resources.handle_undo_impl(world, center, parent, args, map);
 }
 
 EditorActionArgs EditorDecreaseResourcesTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_decrease_resources_tool.h'
--- src/editor/tools/editor_decrease_resources_tool.h	2015-11-11 09:56:22 +0000
+++ src/editor/tools/editor_decrease_resources_tool.h	2016-01-04 21:01:25 +0000
@@ -28,17 +28,17 @@
 		: EditorTool(*this, *this), m_cur_res(0), m_change_by(1)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_delete_bob_tool.cc'
--- src/editor/tools/editor_delete_bob_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_delete_bob_tool.cc	2016-01-04 21:01:25 +0000
@@ -28,37 +28,37 @@
  * Deletes the bob at the given location
 */
 int32_t
-EditorDeleteBobTool::handle_click_impl(Widelands::Map& map,
-                                          const Widelands::World&,
-                                          Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                          EditorInteractive& parent,
-                                          EditorActionArgs& args) {
+EditorDeleteBobTool::handle_click_impl(const Widelands::World&,
+                                       Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                       EditorInteractive& parent,
+                                       EditorActionArgs* args,
+									   Widelands::Map* map) {
 	Widelands::EditorGameBase & egbase = parent.egbase();
-	const int32_t radius = args.sel_radius;
+	const int32_t radius = args->sel_radius;
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), radius));
+	 (map->get_fcoords(center.node), radius));
 
 	do if (Widelands::Bob * const bob = mr.location().field->get_first_bob()) {
-			args.obob_type.push_back(&bob->descr());
+			args->obob_type.push_back(&bob->descr());
 			bob->remove(egbase);
 		} else {
-			args.obob_type.push_back(nullptr);
+			args->obob_type.push_back(nullptr);
 		}
-	while (mr.advance(map));
+	while (mr.advance(*map));
 	return radius + 2;
 }
 
 int32_t
-EditorDeleteBobTool::handle_undo_impl(Widelands::Map& map,
-                                         const Widelands::World& world,
-                                         Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                         EditorInteractive& parent,
-                                         EditorActionArgs& args) {
+EditorDeleteBobTool::handle_undo_impl(const Widelands::World& world,
+                                      Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                      EditorInteractive& parent,
+                                      EditorActionArgs* args,
+									  Widelands::Map* map) {
 
-	uint32_t ret = parent.tools.place_bob.handle_undo_impl(map, world, center, parent, args);
-	args.obob_type.clear();
+	uint32_t ret = parent.tools.place_bob.handle_undo_impl(world, center, parent, args, map);
+	args->obob_type.clear();
 	return ret;
 }
 

=== modified file 'src/editor/tools/editor_delete_bob_tool.h'
--- src/editor/tools/editor_delete_bob_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_delete_bob_tool.h	2016-01-04 21:01:25 +0000
@@ -26,17 +26,17 @@
 struct EditorDeleteBobTool : public EditorTool {
 	EditorDeleteBobTool() : EditorTool(*this, *this) {}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_delete_immovable_tool.cc'
--- src/editor/tools/editor_delete_immovable_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_delete_immovable_tool.cc	2016-01-04 21:01:25 +0000
@@ -28,38 +28,37 @@
 /**
  * Deletes the immovable at the given location
 */
-int32_t EditorDeleteImmovableTool::handle_click_impl(Widelands::Map& map,
-                                                        const Widelands::World&,
-                                                        Widelands::NodeAndTriangle<> const center,
-                                                        EditorInteractive& parent,
-                                                        EditorActionArgs& args) {
+int32_t EditorDeleteImmovableTool::handle_click_impl(const Widelands::World&,
+                                                     Widelands::NodeAndTriangle<> const center,
+                                                     EditorInteractive& parent,
+                                                     EditorActionArgs* args,
+													 Widelands::Map* map) {
 	Widelands::EditorGameBase & egbase = parent.egbase();
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), args.sel_radius));
+	 (map->get_fcoords(center.node), args->sel_radius));
 	do if
 		(upcast
 		        (Widelands::Immovable,
 		         immovable,
 		         mr.location().field->get_immovable()))
 		{
-			args.oimmov_types.push_back(immovable->descr().name());
+			args->oimmov_types.push_back(immovable->descr().name());
 			immovable->remove(egbase); //  Delete no buildings or stuff.
 		} else {
-			args.oimmov_types.push_back("");
+			args->oimmov_types.push_back("");
 		}
-	while (mr.advance(map));
+	while (mr.advance(*map));
 	return mr.radius() + 2;
 }
 
-int32_t EditorDeleteImmovableTool::handle_undo_impl(
-   Widelands::Map& map,
-   const Widelands::World& world,
-   Widelands::NodeAndTriangle<Widelands::Coords> center,
-   EditorInteractive& parent,
-   EditorActionArgs& args) {
-	return parent.tools.place_immovable.handle_undo_impl(map, world, center, parent, args);
+int32_t EditorDeleteImmovableTool::handle_undo_impl(const Widelands::World& world,
+													Widelands::NodeAndTriangle<Widelands::Coords> center,
+													EditorInteractive& parent,
+													EditorActionArgs* args,
+													Widelands::Map* map) {
+	return parent.tools.place_immovable.handle_undo_impl(world, center, parent, args, map);
 }
 
 EditorActionArgs EditorDeleteImmovableTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_delete_immovable_tool.h'
--- src/editor/tools/editor_delete_immovable_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_delete_immovable_tool.h	2016-01-04 21:01:25 +0000
@@ -26,17 +26,17 @@
 struct EditorDeleteImmovableTool : public EditorTool {
 	EditorDeleteImmovableTool() : EditorTool(*this, *this) {}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_draw_tool.cc'
--- src/editor/tools/editor_draw_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_draw_tool.cc	2016-01-04 21:01:25 +0000
@@ -34,40 +34,40 @@
 }
 
 int32_t
-EditorDrawTool::handle_click_impl(Widelands::Map& /* map */,
-                                    const Widelands::World& world,
-                                    Widelands::NodeAndTriangle<Widelands::Coords> /* center */,
-                                    EditorInteractive& /* parent */,
-                                    EditorActionArgs& args) {
+EditorDrawTool::handle_click_impl(const Widelands::World& world,
+                                  Widelands::NodeAndTriangle<Widelands::Coords> /* center */,
+                                  EditorInteractive& /* parent */,
+                                  EditorActionArgs* args,
+								  Widelands::Map* /* map */) {
 
 	for
-		(std::list<EditorToolAction *>::iterator i = args.draw_actions.begin();
-	        i != args.draw_actions.end();
+		(std::list<EditorToolAction *>::iterator i = args->draw_actions.begin();
+	        i != args->draw_actions.end();
 	        ++i)
 	{
 		(*i)->tool.handle_click
 			(static_cast<EditorTool::ToolIndex>((*i)->i),
-				(*i)->map, world, (*i)->center, (*i)->parent, *((*i)->args));
+				world, (*i)->center, (*i)->parent, (*i)->args, &((*i)->map));
 	}
-	return args.draw_actions.size();
+	return args->draw_actions.size();
 }
 
 int32_t
-EditorDrawTool::handle_undo_impl(Widelands::Map& /* map */,
-                                   const Widelands::World& world,
-                                   Widelands::NodeAndTriangle<Widelands::Coords> /* center */,
-                                   EditorInteractive& /* parent */,
-                                   EditorActionArgs& args) {
+EditorDrawTool::handle_undo_impl(const Widelands::World& world,
+                                 Widelands::NodeAndTriangle<Widelands::Coords> /* center */,
+                                 EditorInteractive& /* parent */,
+                                 EditorActionArgs* args,
+								 Widelands::Map* /* map */) {
 	for
-		(std::list<EditorToolAction *>::reverse_iterator i = args.draw_actions.rbegin();
-	        i != args.draw_actions.rend();
+		(std::list<EditorToolAction *>::reverse_iterator i = args->draw_actions.rbegin();
+	        i != args->draw_actions.rend();
 	        ++i)
 	{
 		(*i)->tool.handle_undo
 		(static_cast<EditorTool::ToolIndex>((*i)->i),
-			(*i)->map, world, (*i)->center, (*i)->parent, *((*i)->args));
+			world, (*i)->center, (*i)->parent, (*i)->args, &((*i)->map));
 	}
-	return args.draw_actions.size();
+	return args->draw_actions.size();
 }
 
 EditorActionArgs EditorDrawTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_draw_tool.h'
--- src/editor/tools/editor_draw_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_draw_tool.h	2016-01-04 21:01:25 +0000
@@ -28,17 +28,17 @@
 struct EditorDrawTool : public EditorTool {
 	EditorDrawTool() : EditorTool(*this, *this) {}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_history.cc'
--- src/editor/tools/editor_history.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_history.cc	2016-01-04 21:01:25 +0000
@@ -67,11 +67,11 @@
 	m_redo_button.set_enabled(true);
 
 	return uac.tool.handle_undo(static_cast<EditorTool::ToolIndex>(uac.i),
-	                            uac.map,
 	                            world,
 	                            uac.center,
 	                            uac.parent,
-	                            *uac.args);
+	                            uac.args,
+								&(uac.map));
 }
 
 uint32_t EditorHistory::redo_action(const Widelands::World& world) {
@@ -86,11 +86,11 @@
 	m_redo_button.set_enabled(!redo_stack.empty());
 
 	return rac.tool.handle_click(static_cast<EditorTool::ToolIndex>(rac.i),
-	                             rac.map,
 	                             world,
 	                             rac.center,
 	                             rac.parent,
-	                             *rac.args);
+	                             rac.args,
+								 &(rac.map));
 }
 
 uint32_t EditorHistory::do_action(EditorTool& tool,
@@ -131,7 +131,7 @@
 		m_undo_button.set_enabled(true);
 		m_redo_button.set_enabled(false);
 	}
-	return tool.handle_click(ind, map, world, center, parent, *ac.args);
+	return tool.handle_click(ind, world, center, parent, ac.args, &map);
 }
 
 

=== modified file 'src/editor/tools/editor_increase_height_tool.cc'
--- src/editor/tools/editor_increase_height_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_increase_height_tool.cc	2016-01-04 21:01:25 +0000
@@ -24,35 +24,35 @@
 #include "logic/map.h"
 #include "logic/mapregion.h"
 
-/// Increases the heights by a value. Chages surrounding nodes if necessary.
-int32_t EditorIncreaseHeightTool::handle_click_impl(Widelands::Map& map,
-                                                       const Widelands::World& world,
-                                                       Widelands::NodeAndTriangle<> center,
-                                                       EditorInteractive& /* parent */,
-                                                       EditorActionArgs& args) {
-	if (args.origHights.empty()) {
+/// Increases the heights by a value. Changes surrounding nodes if necessary.
+int32_t EditorIncreaseHeightTool::handle_click_impl(const Widelands::World& world,
+                                                    Widelands::NodeAndTriangle<> center,
+                                                    EditorInteractive& /* parent */,
+                                                    EditorActionArgs* args,
+													Widelands::Map* map) {
+	if (args->origHights.empty()) {
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords>> mr(
-		   map,
+		   *map,
 		   Widelands::Area<Widelands::FCoords>(
-		      map.get_fcoords(center.node),
-		      args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+		      map->get_fcoords(center.node),
+		      args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
 		do {
-			args.origHights.push_back(mr.location().field->get_height());
-		} while (mr.advance(map));
+			args->origHights.push_back(mr.location().field->get_height());
+		} while (mr.advance(*map));
 	}
 
-	return map.change_height(
+	return map->change_height(
 	   world,
-	   Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius),
-	   args.change_by);
+	   Widelands::Area<Widelands::FCoords>(map->get_fcoords(center.node), args->sel_radius),
+	   args->change_by);
 }
 
-int32_t EditorIncreaseHeightTool::handle_undo_impl(Widelands::Map& map,
-                                                      const Widelands::World& world,
-                                                      Widelands::NodeAndTriangle<> center,
-                                                      EditorInteractive& parent,
-                                                      EditorActionArgs& args) {
-	return m_decrease_tool.handle_undo_impl(map, world, center, parent, args);
+int32_t EditorIncreaseHeightTool::handle_undo_impl(const Widelands::World& world,
+                                                   Widelands::NodeAndTriangle<> center,
+                                                   EditorInteractive& parent,
+                                                   EditorActionArgs* args,
+												   Widelands::Map* map) {
+	return m_decrease_tool.handle_undo_impl(world, center, parent, args, map);
 }
 
 EditorActionArgs EditorIncreaseHeightTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_increase_height_tool.h'
--- src/editor/tools/editor_increase_height_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_increase_height_tool.h	2016-01-04 21:01:25 +0000
@@ -34,17 +34,17 @@
 		m_change_by(1)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_increase_resources_tool.cc'
--- src/editor/tools/editor_increase_resources_tool.cc	2015-12-05 10:59:02 +0000
+++ src/editor/tools/editor_increase_resources_tool.cc	2016-01-04 21:01:25 +0000
@@ -30,120 +30,44 @@
 
 using Widelands::TCoords;
 
-namespace  {
-
-int32_t resource_value(const Widelands::TerrainDescription& terrain,
-                       const Widelands::DescriptionIndex resource) {
-	if (!terrain.is_resource_valid(resource)) {
-		return -1;
-	}
-	if (terrain.get_is() & Widelands::TerrainDescription::Is::kUnwalkable) {
-		return 8;
-	}
-	return 1;
-}
-
-}  // namespace
-
-
-int32_t editor_change_resource_tool_callback
-	(const TCoords<Widelands::FCoords>& c, Widelands::Map& map,
-	 const Widelands::World& world, int32_t const curres)
-{
-	Widelands::FCoords f(c, &map[c]);
-
-	Widelands::FCoords f1;
-	int32_t count = 0;
-
-	//  this field
-	count += resource_value(world.terrain_descr(f.field->terrain_r()), curres);
-	count += resource_value(world.terrain_descr(f.field->terrain_d()), curres);
-
-	//  If one of the neighbours is unwalkable, count its resource stronger.
-	//  top left neigbour
-	map.get_neighbour(f, Widelands::WALK_NW, &f1);
-	count += resource_value(world.terrain_descr(f1.field->terrain_r()), curres);
-	count += resource_value(world.terrain_descr(f1.field->terrain_d()), curres);
-
-	//  top right neigbour
-	map.get_neighbour(f, Widelands::WALK_NE, &f1);
-	count += resource_value(world.terrain_descr(f1.field->terrain_d()), curres);
-
-	//  left neighbour
-	map.get_neighbour(f, Widelands::WALK_W, &f1);
-	count += resource_value(world.terrain_descr(f1.field->terrain_r()), curres);
-
-	return count <= 3 ? 0 : f.field->nodecaps();
-}
-
-/*
-===========
-EditorIncreaseResourcesTool::handle_click_impl()
-
-increase the resources of the current field by one if
-there is not already another resource there.
-===========
-*/
 int32_t
-EditorIncreaseResourcesTool::handle_click_impl(Widelands::Map& map,
-                                                  const Widelands::World& world,
-                                                  Widelands::NodeAndTriangle<> const center,
-                                                  EditorInteractive& /* parent */,
-                                                  EditorActionArgs& args) {
-	OverlayManager & overlay_manager = map.overlay_manager();
+EditorIncreaseResourcesTool::handle_click_impl(const Widelands::World& world,
+                                               Widelands::NodeAndTriangle<> const center,
+                                               EditorInteractive& /* parent */,
+                                               EditorActionArgs* args,
+											   Widelands::Map* map) {
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 			Widelands::Area<Widelands::FCoords>
-				(map.get_fcoords(center.node), args.sel_radius));
+				(map->get_fcoords(center.node), args->sel_radius));
 	do {
-		int32_t res = mr.location().field->get_resources();
 		int32_t amount = mr.location().field->get_resources_amount();
-		int32_t max_amount = world.get_resource(args.cur_res)->max_amount();
+		int32_t max_amount = args->cur_res != Widelands::kNoResource ?
+							 world.get_resource(args->cur_res)->max_amount() : 0;
 
-		amount += args.change_by;
+		amount += args->change_by;
 		if (amount > max_amount)
 			amount = max_amount;
 
-		args.orgResT.push_back(res);
-		args.orgRes.push_back(mr.location().field->get_resources_amount());
-
-		if
-		((res == args.cur_res || !mr.location().field->get_resources_amount())
-		        &&
-				  editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res))
-		{
-			//  Ok, we're doing something. First remove the current overlays.
-			const Image* pic =
-			    g_gr->images().get
-			    (world.get_resource(res)->get_editor_pic
-			     (mr.location().field->get_resources_amount()));
-			overlay_manager.remove_overlay(mr.location(), pic);
-
-			if (!amount) {
-				mr.location().field->set_resources(0, 0);
-				mr.location().field->set_initial_res_amount(0);
-			} else {
-				mr.location().field->set_resources(args.cur_res, amount);
-				mr.location().field->set_initial_res_amount(amount);
-				//  set new overlay
-				pic = g_gr->images().get
-				        (world.get_resource(args.cur_res)->get_editor_pic(amount));
-				overlay_manager.register_overlay(mr.location(), pic, 4);
-				map.recalc_for_field_area(
-				   world, Widelands::Area<Widelands::FCoords>(mr.location(), 0));
-			}
+		if ((mr.location().field->get_resources() == args->cur_res ||
+				!mr.location().field->get_resources_amount()) &&
+				map->is_resource_valid(world, mr.location(), args->cur_res)) {
+			args->orgResT.push_back(mr.location().field->get_resources());
+			args->orgRes.push_back(mr.location().field->get_resources_amount());
+			EditorSetResourcesTool::set_res_and_overlay(world, amount, args->cur_res, &mr, args, map);
 		}
-	} while (mr.advance(map));
+
+
+	} while (mr.advance(*map));
 	return mr.radius();
 }
 
-int32_t EditorIncreaseResourcesTool::handle_undo_impl(
-   Widelands::Map& map,
-   const Widelands::World& world,
-   Widelands::NodeAndTriangle<Widelands::Coords> center,
-   EditorInteractive& parent,
-   EditorActionArgs& args) {
-	return m_set_tool.handle_undo_impl(map, world, center, parent, args);
+int32_t EditorIncreaseResourcesTool::handle_undo_impl(const Widelands::World& world,
+		                                              Widelands::NodeAndTriangle<Widelands::Coords> center,
+													  EditorInteractive& parent,
+													  EditorActionArgs* args,
+													  Widelands::Map* map) {
+	return m_set_tool.handle_undo_impl(world, center, parent, args, map);
 }
 
 EditorActionArgs EditorIncreaseResourcesTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_increase_resources_tool.h'
--- src/editor/tools/editor_increase_resources_tool.h	2015-11-11 09:56:22 +0000
+++ src/editor/tools/editor_increase_resources_tool.h	2016-01-04 21:01:25 +0000
@@ -35,17 +35,21 @@
 	     m_cur_res(0) {
 	}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	/***
+	 * Increase the resources of the current field by one if there is not already
+	 * another resource there.
+	 */
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 
@@ -72,8 +76,5 @@
 	Widelands::DescriptionIndex m_cur_res;
 };
 
-int32_t editor_change_resource_tool_callback
-	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map,
-	 const Widelands::World& world, int32_t const curres);
 
 #endif  // end of include guard: WL_EDITOR_TOOLS_EDITOR_INCREASE_RESOURCES_TOOL_H

=== modified file 'src/editor/tools/editor_info_tool.cc'
--- src/editor/tools/editor_info_tool.cc	2015-12-05 10:59:02 +0000
+++ src/editor/tools/editor_info_tool.cc	2016-01-04 21:01:25 +0000
@@ -34,11 +34,11 @@
 #include "ui_basic/window.h"
 
 /// Show a window with information about the pointed at node and triangle.
-int32_t EditorInfoTool::handle_click_impl(Widelands::Map& map,
-					    const Widelands::World& world,
-					    Widelands::NodeAndTriangle<> center,
-					    EditorInteractive& parent,
-					    EditorActionArgs& /* args */) {
+int32_t EditorInfoTool::handle_click_impl(const Widelands::World& world,
+										 Widelands::NodeAndTriangle<> center,
+										 EditorInteractive& parent,
+										 EditorActionArgs* /* args */,
+										 Widelands::Map* map) {
 	UI::Window * const w =
 	    new UI::Window
 	(&parent, "field_information", 30, 30, 400, 200,
@@ -47,7 +47,7 @@
 	    new UI::MultilineTextarea
 	(w, 0, 0, w->get_inner_w(), w->get_inner_h());
 
-	Widelands::Field & f = map[center.node];
+	Widelands::Field & f = (*map)[center.node];
 
 	// *** Node info
 	std::string buf = _("Node:");
@@ -101,7 +101,7 @@
 	// *** Terrain info
 	buf += std::string("\n") + _("Terrain:") + "\n";
 
-	const Widelands::Field         & tf  = map[center.triangle];
+	const Widelands::Field         & tf  = (*map)[center.triangle];
 	const Widelands::TerrainDescription& ter = world.terrain_descr(
 	   center.triangle.t == Widelands::TCoords<>::D ? tf.terrain_d() : tf.terrain_r());
 
@@ -135,20 +135,20 @@
 
 	// *** Map info
 	buf += std::string("\n") + _("Map:") + "\n";
-	buf += "• " + (boost::format(pgettext("map_name", "Name: %s")) % map.get_name().c_str()).str() + "\n";
+	buf += "• " + (boost::format(pgettext("map_name", "Name: %s")) % map->get_name().c_str()).str() + "\n";
 	buf += "• " + (boost::format(_("Size: %1$ix%2$i"))
-					 % map.get_width() % map.get_height()).str() + "\n";
+					 % map->get_width() % map->get_height()).str() + "\n";
 
-	if (map.get_nrplayers() > 0) {
+	if (map->get_nrplayers() > 0) {
 		buf += "• " +
-				 (boost::format(_("Players: %u")) % static_cast<unsigned int>(map.get_nrplayers())).str() + "\n";
+				 (boost::format(_("Players: %u")) % static_cast<unsigned int>(map->get_nrplayers())).str() + "\n";
 	}
 	else {
 		buf += "• " + std::string(_("Players: -")) + "\n";
 	}
 
-	buf += "• " + (boost::format(_("Author: %s")) % map.get_author()).str() + "\n";
-	buf += "• " + (boost::format(_("Descr: %s")) % map.get_description().c_str()).str() + "\n";
+	buf += "• " + (boost::format(_("Author: %s")) % map->get_author()).str() + "\n";
+	buf += "• " + (boost::format(_("Descr: %s")) % map->get_description().c_str()).str() + "\n";
 
 	multiline_textarea->set_text(buf.c_str());
 

=== modified file 'src/editor/tools/editor_info_tool.h'
--- src/editor/tools/editor_info_tool.h	2015-07-25 19:25:00 +0000
+++ src/editor/tools/editor_info_tool.h	2016-01-04 21:01:25 +0000
@@ -27,11 +27,11 @@
 	EditorInfoTool() : EditorTool(*this, *this, false) {
 	}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
 	char const* get_sel_impl() const override {
 		return "pics/fsel_editor_info.png";

=== modified file 'src/editor/tools/editor_make_infrastructure_tool.cc'
--- src/editor/tools/editor_make_infrastructure_tool.cc	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_make_infrastructure_tool.cc	2016-01-04 21:01:25 +0000
@@ -46,11 +46,11 @@
  *
  * Obviously, this function ignores the sel radius
 */
-int32_t EditorMakeInfrastructureTool::handle_click_impl(Widelands::Map&,
-                                                           const Widelands::World&,
-                                                           Widelands::NodeAndTriangle<> const,
-                                                           EditorInteractive& parent,
-                                                           EditorActionArgs& /* args */) {
+int32_t EditorMakeInfrastructureTool::handle_click_impl(const Widelands::World&,
+                                                        Widelands::NodeAndTriangle<> const,
+                                                        EditorInteractive& parent,
+                                                        EditorActionArgs* /* args */,
+														Widelands::Map*) {
 	show_field_action
 	(&parent, parent.egbase().get_player(m_player), &m_registry);
 

=== modified file 'src/editor/tools/editor_make_infrastructure_tool.h'
--- src/editor/tools/editor_make_infrastructure_tool.h	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_make_infrastructure_tool.h	2016-01-04 21:01:25 +0000
@@ -39,11 +39,11 @@
 	Widelands::PlayerNumber get_player() const
 		{return m_player;}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
 	const char * get_sel_impl() const override
 		{return "pics/fsel.png";} //  Standard sel icon, most complex tool of all

=== modified file 'src/editor/tools/editor_noise_height_tool.cc'
--- src/editor/tools/editor_noise_height_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_noise_height_tool.cc	2016-01-04 21:01:25 +0000
@@ -27,47 +27,47 @@
 #include "logic/mapregion.h"
 
 /// Sets the heights to random values. Changes surrounding nodes if necessary.
-int32_t EditorNoiseHeightTool::handle_click_impl(Widelands::Map& map,
-                                                    const Widelands::World& world,
-                                                    Widelands::NodeAndTriangle<> const center,
-                                                    EditorInteractive& /* parent */,
-                                                    EditorActionArgs& args) {
-	if (args.origHights.empty()) {
+int32_t EditorNoiseHeightTool::handle_click_impl(const Widelands::World& world,
+                                                 Widelands::NodeAndTriangle<> const center,
+                                                 EditorInteractive& /* parent */,
+                                                 EditorActionArgs* args,
+												 Widelands::Map* map) {
+	if (args->origHights.empty()) {
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node),
-		  args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
-		do args.origHights.push_back(mr.location().field->get_height());
-		while (mr.advance(map));
+		 (map->get_fcoords(center.node),
+		  args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+		do args->origHights.push_back(mr.location().field->get_height());
+		while (mr.advance(*map));
 	}
 
 	uint32_t max = 0;
 
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), args.sel_radius));
+	 (map->get_fcoords(center.node), args->sel_radius));
 	do {
 		max = std::max(
 		   max,
-		   map.set_height(world,
+		   map->set_height(world,
 		                  mr.location(),
-		                  args.m_interval.min +
+		                  args->m_interval.min +
 		                     static_cast<int32_t>(
-		                        static_cast<double>(args.m_interval.max - args.m_interval.min + 1) *
+		                        static_cast<double>(args->m_interval.max - args->m_interval.min + 1) *
 		                        rand() / (RAND_MAX + 1.0))));
-	} while (mr.advance(map));
+	} while (mr.advance(*map));
 	return mr.radius() + max;
 }
 
 int32_t
-EditorNoiseHeightTool::handle_undo_impl(Widelands::Map& map,
-                                           const Widelands::World& world,
-                                           Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                           EditorInteractive& parent,
-                                           EditorActionArgs& args) {
-	return m_set_tool.handle_undo_impl(map, world, center, parent, args);
+EditorNoiseHeightTool::handle_undo_impl(const Widelands::World& world,
+                                        Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                        EditorInteractive& parent,
+                                        EditorActionArgs* args,
+										Widelands::Map* map) {
+	return m_set_tool.handle_undo_impl(world, center, parent, args, map);
 }
 
 EditorActionArgs EditorNoiseHeightTool::format_args_impl(EditorInteractive & parent)

=== modified file 'src/editor/tools/editor_noise_height_tool.h'
--- src/editor/tools/editor_noise_height_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_noise_height_tool.h	2016-01-04 21:01:25 +0000
@@ -34,17 +34,17 @@
 		m_interval(the_interval)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_place_bob_tool.cc'
--- src/editor/tools/editor_place_bob_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_place_bob_tool.cc	2016-01-04 21:01:25 +0000
@@ -30,31 +30,31 @@
  * Choses an object to place randomly from all enabled
  * and places this on the current field
 */
-int32_t EditorPlaceBobTool::handle_click_impl(Widelands::Map& map,
-                                                 const Widelands::World& world,
-                                                 Widelands::NodeAndTriangle<> const center,
-                                                 EditorInteractive& parent,
-                                                 EditorActionArgs& args) {
+int32_t EditorPlaceBobTool::handle_click_impl(const Widelands::World& world,
+                                              Widelands::NodeAndTriangle<> const center,
+                                              EditorInteractive& parent,
+                                              EditorActionArgs* args,
+											  Widelands::Map* map) {
 
-	if (get_nr_enabled() && args.obob_type.empty()) {
+	if (get_nr_enabled() && args->obob_type.empty()) {
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), args.sel_radius));
+		 (map->get_fcoords(center.node), args->sel_radius));
 		do {
 			Widelands::Bob * const mbob = mr.location().field->get_first_bob();
-			args.obob_type.push_back((mbob ? &mbob->descr() : nullptr));
-			args.nbob_type.push_back(world.get_bob_descr(get_random_enabled()));
-		} while (mr.advance(map));
+			args->obob_type.push_back((mbob ? &mbob->descr() : nullptr));
+			args->nbob_type.push_back(world.get_bob_descr(get_random_enabled()));
+		} while (mr.advance(*map));
 	}
 
-	if (!args.nbob_type.empty()) {
+	if (!args->nbob_type.empty()) {
 		Widelands::EditorGameBase & egbase = parent.egbase();
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), args.sel_radius));
-		std::list< const Widelands::BobDescr * >::iterator i = args.nbob_type.begin();
+		 (map->get_fcoords(center.node), args->sel_radius));
+		std::list< const Widelands::BobDescr * >::iterator i = args->nbob_type.begin();
 		do {
 			const Widelands::BobDescr & descr = *(*i);
 			if (mr.location().field->nodecaps() & descr.movecaps()) {
@@ -63,25 +63,25 @@
 				descr.create(egbase, nullptr, mr.location());
 			}
 			++i;
-		} while (mr.advance(map));
+		} while (mr.advance(*map));
 		return mr.radius() + 2;
 	} else
 		return 0;
 }
 
 int32_t
-EditorPlaceBobTool::handle_undo_impl(Widelands::Map& map,
-                                        const Widelands::World&,
-                                        Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                        EditorInteractive& parent,
-                                        EditorActionArgs& args) {
-	if (!args.nbob_type.empty()) {
+EditorPlaceBobTool::handle_undo_impl(const Widelands::World&,
+                                     Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                     EditorInteractive& parent,
+                                     EditorActionArgs* args,
+									 Widelands::Map* map) {
+	if (!args->nbob_type.empty()) {
 		Widelands::EditorGameBase & egbase = parent.egbase();
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), args.sel_radius));
-		std::list<const Widelands::BobDescr *>::iterator i = args.obob_type.begin();
+		 (map->get_fcoords(center.node), args->sel_radius));
+		std::list<const Widelands::BobDescr *>::iterator i = args->obob_type.begin();
 		do {
 			if (*i) {
 				const Widelands::BobDescr & descr = *(*i);
@@ -94,7 +94,7 @@
 				bob->remove(egbase);
 			}
 			++i;
-		} while (mr.advance(map));
+		} while (mr.advance(*map));
 		return mr.radius() + 2;
 	} else
 		return 0;

=== modified file 'src/editor/tools/editor_place_bob_tool.h'
--- src/editor/tools/editor_place_bob_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_place_bob_tool.h	2016-01-04 21:01:25 +0000
@@ -29,17 +29,17 @@
 		: EditorTool(tool, tool)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_place_immovable_tool.cc'
--- src/editor/tools/editor_place_immovable_tool.cc	2015-01-25 12:02:06 +0000
+++ src/editor/tools/editor_place_immovable_tool.cc	2016-01-04 21:01:25 +0000
@@ -32,35 +32,35 @@
  * Choses an object to place randomly from all enabled
  * and places this on the current field
 */
-int32_t EditorPlaceImmovableTool::handle_click_impl(Widelands::Map& map,
-                                                       const Widelands::World&,
-                                                       Widelands::NodeAndTriangle<> const center,
-                                                       EditorInteractive& parent,
-                                                       EditorActionArgs& args) {
-	const int32_t radius = args.sel_radius;
+int32_t EditorPlaceImmovableTool::handle_click_impl(const Widelands::World&,
+                                                    Widelands::NodeAndTriangle<> const center,
+                                                    EditorInteractive& parent,
+                                                    EditorActionArgs* args,
+													Widelands::Map* map) {
+	const int32_t radius = args->sel_radius;
 	if (!get_nr_enabled())
 		return radius;
 	Widelands::EditorGameBase & egbase = parent.egbase();
-	if (args.oimmov_types.empty())
+	if (args->oimmov_types.empty())
 	{
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), radius));
+		 (map->get_fcoords(center.node), radius));
 		do {
 			const Widelands::BaseImmovable * im = mr.location().field->get_immovable();
-			args.oimmov_types.push_back((im ? im->descr().name() : ""));
-			args.nimmov_types.push_back(get_random_enabled());
-		} while (mr.advance(map));
+			args->oimmov_types.push_back((im ? im->descr().name() : ""));
+			args->nimmov_types.push_back(get_random_enabled());
+		} while (mr.advance(*map));
 	}
 
-	if (!args.nimmov_types.empty())
+	if (!args->nimmov_types.empty())
 	{
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), radius));
-		std::list<int32_t>::iterator i = args.nimmov_types.begin();
+		 (map->get_fcoords(center.node), radius));
+		std::list<int32_t>::iterator i = args->nimmov_types.begin();
 		do {
 			if
 			(!mr.location().field->get_immovable()
@@ -68,27 +68,26 @@
 			        (mr.location().field->nodecaps() & Widelands::MOVECAPS_WALK))
 				egbase.create_immovable(mr.location(), *i);
 			++i;
-		} while (mr.advance(map));
+		} while (mr.advance(*map));
 	}
 	return radius + 2;
 }
 
-int32_t EditorPlaceImmovableTool::handle_undo_impl(
-   Widelands::Map& map,
-   const Widelands::World&,
-   Widelands::NodeAndTriangle<Widelands::Coords> center,
-   EditorInteractive& parent,
-   EditorActionArgs& args) {
-	const int32_t radius = args.sel_radius;
-	if (args.oimmov_types.empty())
+int32_t EditorPlaceImmovableTool::handle_undo_impl(const Widelands::World&,
+												   Widelands::NodeAndTriangle<Widelands::Coords> center,
+												   EditorInteractive& parent,
+												   EditorActionArgs* args,
+												   Widelands::Map* map) {
+	const int32_t radius = args->sel_radius;
+	if (args->oimmov_types.empty())
 		return radius;
 
 	Widelands::EditorGameBase & egbase = parent.egbase();
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), radius));
-	std::list<std::string>::iterator i = args.oimmov_types.begin();
+	 (map->get_fcoords(center.node), radius));
+	std::list<std::string>::iterator i = args->oimmov_types.begin();
 	do {
 		if
 			(upcast(Widelands::Immovable, immovable,
@@ -100,7 +99,7 @@
 			egbase.create_immovable(mr.location(), *i);
 
 		++i;
-	} while (mr.advance(map));
+	} while (mr.advance(*map));
 	return radius + 2;
 }
 

=== modified file 'src/editor/tools/editor_place_immovable_tool.h'
--- src/editor/tools/editor_place_immovable_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_place_immovable_tool.h	2016-01-04 21:01:25 +0000
@@ -31,17 +31,17 @@
 		: EditorTool(tool, tool)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_set_height_tool.cc'
--- src/editor/tools/editor_set_height_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_height_tool.cc	2016-01-04 21:01:25 +0000
@@ -26,48 +26,48 @@
 #include "logic/map.h"
 #include "logic/mapregion.h"
 
-int32_t EditorSetHeightTool::handle_click_impl(Widelands::Map& map,
-                                                  const Widelands::World& world,
-                                                  Widelands::NodeAndTriangle<> const center,
-                                                  EditorInteractive& /* parent */,
-                                                  EditorActionArgs& args) {
-	if (args.origHights.empty())
+int32_t EditorSetHeightTool::handle_click_impl(const Widelands::World& world,
+                                               Widelands::NodeAndTriangle<> const center,
+                                               EditorInteractive& /* parent */,
+                                               EditorActionArgs* args,
+											   Widelands::Map* map) {
+	if (args->origHights.empty())
 	{
 		Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<Widelands::FCoords>
-		 (map.get_fcoords(center.node), args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
-		do args.origHights.push_back(mr.location().field->get_height());
-		while (mr.advance(map));
+		 (map->get_fcoords(center.node), args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+		do args->origHights.push_back(mr.location().field->get_height());
+		while (mr.advance(*map));
 	}
-	return map.set_height(
+	return map->set_height(
 	   world,
-	   Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius),
-	   args.m_interval);
+	   Widelands::Area<Widelands::FCoords>(map->get_fcoords(center.node), args->sel_radius),
+	   args->m_interval);
 }
 
 int32_t
-EditorSetHeightTool::handle_undo_impl(Widelands::Map& map,
-                                         const Widelands::World& world,
-                                         Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                         EditorInteractive& /* parent */,
-                                         EditorActionArgs& args) {
+EditorSetHeightTool::handle_undo_impl(const Widelands::World& world,
+                                      Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                      EditorInteractive& /* parent */,
+                                      EditorActionArgs* args,
+									  Widelands::Map* map) {
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	Widelands::Area<Widelands::FCoords>
-	(map.get_fcoords(center.node),
-	args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
+	(map->get_fcoords(center.node),
+	args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 1));
 
-	std::list<Widelands::Field::Height>::iterator i = args.origHights.begin();
+	std::list<Widelands::Field::Height>::iterator i = args->origHights.begin();
 
 	do {
 		mr.location().field->set_height(*i); ++i;
-	} while (mr.advance(map));
+	} while (mr.advance(*map));
 
-	map.recalc_for_field_area
+	map->recalc_for_field_area
 		(world, Widelands::Area<Widelands::FCoords>
-		(map.get_fcoords(center.node),
-		args.sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 2));
+		(map->get_fcoords(center.node),
+		args->sel_radius + MAX_FIELD_HEIGHT / MAX_FIELD_HEIGHT_DIFF + 2));
 
 	return mr.radius() + 1;
 }

=== modified file 'src/editor/tools/editor_set_height_tool.h'
--- src/editor/tools/editor_set_height_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_height_tool.h	2016-01-04 21:01:25 +0000
@@ -30,17 +30,17 @@
 		: EditorTool(*this, *this), m_interval(10, 10)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_set_origin_tool.cc'
--- src/editor/tools/editor_set_origin_tool.cc	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_origin_tool.cc	2016-01-04 21:01:25 +0000
@@ -24,12 +24,12 @@
 #include "wui/mapviewpixelconstants.h"
 #include "wui/overlay_manager.h"
 
-int32_t EditorSetOriginTool::handle_click_impl(Widelands::Map& map,
-                                                  const Widelands::World&,
-                                                  Widelands::NodeAndTriangle<> const center,
-                                                  EditorInteractive& eia,
-                                                  EditorActionArgs& /* args */) {
-	map.set_origin(center.node);
+int32_t EditorSetOriginTool::handle_click_impl(const Widelands::World&,
+                                               Widelands::NodeAndTriangle<> const center,
+                                               EditorInteractive& eia,
+                                               EditorActionArgs* /* args */,
+											   Widelands::Map* map) {
+	map->set_origin(center.node);
 	eia.register_overlays();
 	eia.set_rel_viewpoint
 	(Point
@@ -40,15 +40,15 @@
 }
 
 int32_t
-EditorSetOriginTool::handle_undo_impl(Widelands::Map& map,
-                                         const Widelands::World&,
-                                         Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                         EditorInteractive& parent,
-                                         EditorActionArgs& /* args */) {
+EditorSetOriginTool::handle_undo_impl(const Widelands::World&,
+                                      Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                      EditorInteractive& parent,
+                                      EditorActionArgs* /* args */,
+									  Widelands::Map* map) {
 	Widelands::Coords nc
-		(map.get_width()  - center.node.x,
-		 map.get_height() - center.node.y);
-	map.set_origin(nc);
+		(map->get_width()  - center.node.x,
+		 map->get_height() - center.node.y);
+	map->set_origin(nc);
 	parent.register_overlays();
 	parent.set_rel_viewpoint
 	(Point

=== modified file 'src/editor/tools/editor_set_origin_tool.h'
--- src/editor/tools/editor_set_origin_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_origin_tool.h	2016-01-04 21:01:25 +0000
@@ -27,17 +27,17 @@
 struct EditorSetOriginTool : public EditorTool {
 	EditorSetOriginTool() : EditorTool(*this, *this) {}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& eia,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_set_port_space_tool.cc'
--- src/editor/tools/editor_set_port_space_tool.cc	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_set_port_space_tool.cc	2016-01-04 21:01:25 +0000
@@ -31,7 +31,7 @@
 
 /// static callback function for overlay calculation
 int32_t editor_Tool_set_port_space_callback
-	(const Widelands::TCoords<Widelands::FCoords>& c, Map& map)
+	(const Widelands::TCoords<Widelands::FCoords>& c, const Map& map)
 {
 	NodeCaps const caps = c.field->nodecaps();
 	FCoords f = map.get_fcoords(*c.field);
@@ -55,72 +55,72 @@
 	EditorTool(*this, *this)
 {}
 
-int32_t EditorSetPortSpaceTool::handle_click_impl(Map& map,
-                                                      const Widelands::World& world,
-                                                      Widelands::NodeAndTriangle<> const center,
-                                                      EditorInteractive&,
-                                                      EditorActionArgs& args) {
-	assert(0 <= center.node.x);
-	assert(center.node.x < map.get_width());
-	assert(0 <= center.node.y);
-	assert(center.node.y < map.get_height());
-
-	uint32_t nr = 0;
-
-	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map, Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius));
-	do {
-		//  check if field is valid
-		if (editor_Tool_set_port_space_callback(mr.location(), map)) {
-			map.set_port_space(mr.location(), true);
-			Area<FCoords> a(mr.location(), 0);
-			map.recalc_for_field_area(world, a);
-			++nr;
-		}
-	} while (mr.advance(map));
-
-	return nr;
-}
-
-int32_t EditorSetPortSpaceTool::handle_undo_impl(Map& map,
-                                                     const Widelands::World& world,
-                                                     NodeAndTriangle<Coords> center,
-                                                     EditorInteractive& parent,
-                                                     EditorActionArgs& args) {
-	return parent.tools.unset_port_space.handle_click_impl(map, world, center, parent, args);
-}
-
-int32_t EditorUnsetPortSpaceTool::handle_click_impl(Map& map,
-                                                        const Widelands::World& world,
-                                                        NodeAndTriangle<> const center,
-                                                        EditorInteractive&,
-                                                        EditorActionArgs& args) {
-	assert(0 <= center.node.x);
-	assert(center.node.x < map.get_width());
-	assert(0 <= center.node.y);
-	assert(center.node.y < map.get_height());
-
-	uint32_t nr = 0;
-
-	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-		(map, Widelands::Area<Widelands::FCoords>(map.get_fcoords(center.node), args.sel_radius));
-	do {
-		//  check if field is valid
-		if (editor_Tool_set_port_space_callback(mr.location(), map)) {
-			map.set_port_space(mr.location(), false);
-			Area<FCoords> a(mr.location(), 0);
-			map.recalc_for_field_area(world, a);
-			++nr;
-		}
-	} while (mr.advance(map));
-
-	return nr;
-}
-
-int32_t EditorUnsetPortSpaceTool::handle_undo_impl(Map& map,
-                                                       const Widelands::World& world,
-                                                       NodeAndTriangle<Coords> center,
-                                                       EditorInteractive& parent,
-                                                       EditorActionArgs& args) {
-	return parent.tools.set_port_space.handle_click_impl(map, world, center, parent, args);
+int32_t EditorSetPortSpaceTool::handle_click_impl(const Widelands::World& world,
+                                                  Widelands::NodeAndTriangle<> const center,
+                                                  EditorInteractive&,
+                                                  EditorActionArgs* args,
+												  Map* map) {
+	assert(0 <= center.node.x);
+	assert(center.node.x < map->get_width());
+	assert(0 <= center.node.y);
+	assert(center.node.y < map->get_height());
+
+	uint32_t nr = 0;
+
+	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
+		(*map, Widelands::Area<Widelands::FCoords>(map->get_fcoords(center.node), args->sel_radius));
+	do {
+		//  check if field is valid
+		if (editor_Tool_set_port_space_callback(mr.location(), *map)) {
+			map->set_port_space(mr.location(), true);
+			Area<FCoords> a(mr.location(), 0);
+			map->recalc_for_field_area(world, a);
+			++nr;
+		}
+	} while (mr.advance(*map));
+
+	return nr;
+}
+
+int32_t EditorSetPortSpaceTool::handle_undo_impl(const Widelands::World& world,
+                                                 NodeAndTriangle<Coords> center,
+                                                 EditorInteractive& parent,
+                                                 EditorActionArgs* args,
+												 Map* map) {
+	return parent.tools.unset_port_space.handle_click_impl(world, center, parent, args, map);
+}
+
+int32_t EditorUnsetPortSpaceTool::handle_click_impl(const Widelands::World& world,
+                                                    NodeAndTriangle<> const center,
+                                                    EditorInteractive&,
+                                                    EditorActionArgs* args,
+													Map* map) {
+	assert(0 <= center.node.x);
+	assert(center.node.x < map->get_width());
+	assert(0 <= center.node.y);
+	assert(center.node.y < map->get_height());
+
+	uint32_t nr = 0;
+
+	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
+		(*map, Widelands::Area<Widelands::FCoords>(map->get_fcoords(center.node), args->sel_radius));
+	do {
+		//  check if field is valid
+		if (editor_Tool_set_port_space_callback(mr.location(), *map)) {
+			map->set_port_space(mr.location(), false);
+			Area<FCoords> a(mr.location(), 0);
+			map->recalc_for_field_area(world, a);
+			++nr;
+		}
+	} while (mr.advance(*map));
+
+	return nr;
+}
+
+int32_t EditorUnsetPortSpaceTool::handle_undo_impl(const Widelands::World& world,
+                                                   NodeAndTriangle<Coords> center,
+                                                   EditorInteractive& parent,
+                                                   EditorActionArgs* args,
+												   Map* map) {
+	return parent.tools.set_port_space.handle_click_impl(world, center, parent, args, map);
 }

=== modified file 'src/editor/tools/editor_set_port_space_tool.h'
--- src/editor/tools/editor_set_port_space_tool.h	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_set_port_space_tool.h	2016-01-04 21:01:25 +0000
@@ -31,17 +31,17 @@
 public:
 	EditorUnsetPortSpaceTool();
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	char const * get_sel_impl() const override {return FSEL_EUPS_FILENAME;}
 };
@@ -52,22 +52,22 @@
 public:
 	EditorSetPortSpaceTool(EditorUnsetPortSpaceTool &);
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	char const * get_sel_impl() const override {return FSEL_ESPS_FILENAME;}
 };
 
 int32_t editor_Tool_set_port_space_callback
-	(const Widelands::TCoords<Widelands::FCoords>& c, Widelands::Map& map);
+	(const Widelands::TCoords<Widelands::FCoords>& c, const Widelands::Map& map);
 
 #endif  // end of include guard: WL_EDITOR_TOOLS_EDITOR_SET_PORT_SPACE_TOOL_H

=== modified file 'src/editor/tools/editor_set_resources_tool.cc'
--- src/editor/tools/editor_set_resources_tool.cc	2014-12-01 21:47:22 +0000
+++ src/editor/tools/editor_set_resources_tool.cc	2016-01-04 21:01:25 +0000
@@ -29,98 +29,66 @@
 #include "logic/world/world.h"
 #include "wui/overlay_manager.h"
 
-/**
- * Sets the resources of the current to a fixed value
-*/
-int32_t EditorSetResourcesTool::handle_click_impl(Widelands::Map& map,
-                                                     const Widelands::World& world,
+
+int32_t EditorSetResourcesTool::handle_click_impl(const Widelands::World& world,
                                                      Widelands::NodeAndTriangle<> const center,
                                                      EditorInteractive& /* parent */,
-                                                     EditorActionArgs& args) {
-	OverlayManager & overlay_manager = map.overlay_manager();
+                                                     EditorActionArgs* args,
+													 Widelands::Map* map)
+{
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), args.sel_radius));
+	 (map->get_fcoords(center.node), args->sel_radius));
 	do {
-		int32_t res        = mr.location().field->get_resources();
-		int32_t amount     = args.set_to;
-		int32_t max_amount = world.get_resource(args.cur_res)->max_amount();
-
+		int32_t amount     = args->set_to;
+		int32_t max_amount = args->cur_res != Widelands::kNoResource ?
+							 world.get_resource(args->cur_res)->max_amount() : 0;
 		if (amount < 0)
 			amount = 0;
-		if (amount > max_amount)
+		else if (amount > max_amount)
 			amount = max_amount;
 
-		args.orgResT.push_back(res);
-		args.orgRes.push_back(mr.location().field->get_resources_amount());
-
-		if (editor_change_resource_tool_callback(mr.location(), map, world, args.cur_res)) {
-			//  Ok, we're doing something. First remove the current overlays.
-			const Image* pic = g_gr->images().get
-				(world.get_resource(res)->get_editor_pic (mr.location().field->get_resources_amount()));
-			overlay_manager.remove_overlay(mr.location(), pic);
-
-			if (!amount) {
-				mr.location().field->set_resources(0, 0);
-				mr.location().field->set_initial_res_amount(0);
-			} else {
-				mr.location().field->set_resources(args.cur_res, amount);
-				mr.location().field->set_initial_res_amount(amount);
-				//  set new overlay
-				pic =
-				    g_gr->images().get(world.get_resource(args.cur_res)->get_editor_pic(amount));
-				overlay_manager.register_overlay(mr.location(), pic, 4);
-				map.recalc_for_field_area(world, Widelands::Area<Widelands::FCoords>(mr.location(), 0));
-			}
+		if (map->is_resource_valid(world, mr.location(), args->cur_res)) {
+			args->orgResT.push_back(mr.location().field->get_resources());
+			args->orgRes.push_back(mr.location().field->get_resources_amount());
+			set_res_and_overlay(world, amount, args->cur_res, &mr, args, map);
 		}
-	} while (mr.advance(map));
+
+
+	} while (mr.advance(*map));
 	return mr.radius();
 }
 
 int32_t
-EditorSetResourcesTool::handle_undo_impl(Widelands::Map& map,
-                                            const Widelands::World& world,
+EditorSetResourcesTool::handle_undo_impl(const Widelands::World& world,
                                             Widelands::NodeAndTriangle<Widelands::Coords> center,
                                             EditorInteractive& /* parent */,
-                                            EditorActionArgs& args) {
-	OverlayManager & overlay_manager = map.overlay_manager();
+                                            EditorActionArgs* args,
+											Widelands::Map* map) {
+	OverlayManager & overlay_manager = map->overlay_manager();
 	Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > mr
-	(map,
+	(*map,
 	 Widelands::Area<Widelands::FCoords>
-	 (map.get_fcoords(center.node), args.sel_radius));
-	std::list<uint8_t>::iterator ir = args.orgRes.begin(), it = args.orgResT.begin();
+	 (map->get_fcoords(center.node), args->sel_radius));
+	std::list<uint8_t>::iterator ir = args->orgRes.begin(), it = args->orgResT.begin();
 	do {
 		int32_t res        = mr.location().field->get_resources();
 		int32_t amount     = *ir;
-		int32_t max_amount = world.get_resource(args.cur_res)->max_amount();
+		int32_t max_amount = world.get_resource(args->cur_res)->max_amount();
 
 		if (amount < 0)
 			amount = 0;
 		if (amount > max_amount)
 			amount = max_amount;
 
-		const Image* pic =
-		    g_gr->images().get
-		    (world.get_resource(res)->get_editor_pic(mr.location().field->get_resources_amount()));
-		overlay_manager.remove_overlay(mr.location(), pic);
+		set_res_and_overlay(world, amount, *ir, &mr, args, map);
 
-		if (!amount) {
-			mr.location().field->set_resources(0, 0);
-			mr.location().field->set_initial_res_amount(0);
-		} else {
-			mr.location().field->set_resources(*it, amount);
-			mr.location().field->set_initial_res_amount(amount);
-			//  set new overlay
-			pic = g_gr->images().get(world.get_resource(*it)->get_editor_pic(amount));
-			overlay_manager.register_overlay(mr.location(), pic, 4);
-			map.recalc_for_field_area(world, Widelands::Area<Widelands::FCoords>(mr.location(), 0));
-		}
 		++ir;
 		++it;
-	} while (mr.advance(map));
-	args.orgRes.clear();
-	args.orgResT.clear();
+	} while (mr.advance(*map));
+	args->orgRes.clear();
+	args->orgResT.clear();
 	return mr.radius();
 }
 
@@ -131,3 +99,34 @@
 	a.set_to = m_set_to;
 	return a;
 }
+
+void EditorSetResourcesTool::set_res_and_overlay(const Widelands::World& world,
+											int32_t amount, uint8_t new_res,
+											Widelands::MapRegion<Widelands::Area<Widelands::FCoords> >* mr,
+											EditorActionArgs* args,
+											Widelands::Map* map) {
+	int32_t old_res = mr->location().field->get_resources();
+
+	//  Ok, we're doing something. First remove the current overlays.
+	if (old_res != Widelands::kNoResource) {
+		std::string str = world.get_resource(old_res)->get_editor_pic(
+				mr->location().field->get_resources_amount());
+		const Image* pic = g_gr->images().get(str);
+		map->overlay_manager().remove_overlay(mr->location(), pic);
+	}
+
+	if (!amount) {
+		mr->location().field->set_resources(Widelands::kNoResource, 0);
+		mr->location().field->set_initial_res_amount(0);
+	} else {
+		mr->location().field->set_resources(new_res, amount);
+		mr->location().field->set_initial_res_amount(amount);
+		//  set new overlay
+		std::string str = world.get_resource(new_res)->get_editor_pic(amount);
+		const Image* pic = g_gr->images().get(str);
+		map->overlay_manager().register_overlay(mr->location(), pic, 4);
+		map->recalc_for_field_area(
+				world, Widelands::Area<Widelands::FCoords>(mr->location(), 0));
+	}
+}
+

=== modified file 'src/editor/tools/editor_set_resources_tool.h'
--- src/editor/tools/editor_set_resources_tool.h	2015-11-11 09:56:22 +0000
+++ src/editor/tools/editor_set_resources_tool.h	2016-01-04 21:01:25 +0000
@@ -20,6 +20,8 @@
 #ifndef WL_EDITOR_TOOLS_EDITOR_SET_RESOURCES_TOOL_H
 #define WL_EDITOR_TOOLS_EDITOR_SET_RESOURCES_TOOL_H
 
+#include "logic/mapregion.h"
+#include "logic/widelands.h"
 #include "editor/tools/editor_tool.h"
 
 ///  Decreases the resources of a node by a value.
@@ -28,20 +30,30 @@
 		: EditorTool(*this, *this), m_cur_res(0), m_set_to(0)
 	{}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	/**
+	 * Sets the resources of the current to a fixed value
+	*/
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 
+	/**
+	 * Sets the resource amount and updates the overlay.
+	 */
+	static void set_res_and_overlay(const Widelands::World& world, int32_t amount, uint8_t resIx,
+			Widelands::MapRegion<Widelands::Area<Widelands::FCoords> > *mr,
+			EditorActionArgs* args, Widelands::Map* map);
+
 	char const * get_sel_impl() const override {
 		return "pics/fsel_editor_set_resources.png";
 	}
@@ -57,4 +69,5 @@
 	uint8_t m_set_to;
 };
 
+
 #endif  // end of include guard: WL_EDITOR_TOOLS_EDITOR_SET_RESOURCES_TOOL_H

=== modified file 'src/editor/tools/editor_set_starting_pos_tool.cc'
--- src/editor/tools/editor_set_starting_pos_tool.cc	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_set_starting_pos_tool.cc	2016-01-04 21:01:25 +0000
@@ -62,17 +62,17 @@
 	strcpy(fsel_picsname, FSEL_PIC_FILENAME);
 }
 
-int32_t EditorSetStartingPosTool::handle_click_impl(Widelands::Map& map,
-                                                        const Widelands::World&,
-                                                        Widelands::NodeAndTriangle<> const center,
-                                                        EditorInteractive&,
-                                                        EditorActionArgs&) {
+int32_t EditorSetStartingPosTool::handle_click_impl(const Widelands::World&,
+                                                    Widelands::NodeAndTriangle<> const center,
+                                                    EditorInteractive&,
+                                                    EditorActionArgs*,
+													Widelands::Map* map) {
 	assert(0 <= center.node.x);
-	assert(center.node.x < map.get_width());
+	assert(center.node.x < map->get_width());
 	assert(0 <= center.node.y);
-	assert(center.node.y < map.get_height());
+	assert(center.node.y < map->get_height());
 	if (m_current_player) {
-		if (map.get_nrplayers() < m_current_player) {
+		if (map->get_nrplayers() < m_current_player) {
 			//  Mmh, my current player is not valid. Maybe the user has loaded a
 			//  new map while this tool was active. We set the new player to a
 			//  valid one. The sel pointer is the only thing that stays wrong, but
@@ -80,7 +80,7 @@
 			m_current_player = 1;
 		}
 
-		Widelands::Coords const old_sp = map.get_starting_pos(m_current_player);
+		Widelands::Coords const old_sp = map->get_starting_pos(m_current_player);
 
 		char picname[] = "pics/editor_player_00_starting_pos.png";
 		picname[19] += m_current_player / 10;
@@ -88,8 +88,8 @@
 		const Image* pic = g_gr->images().get(picname);
 
 		//  check if field is valid
-		if (editor_tool_set_starting_pos_callback(map.get_fcoords(center.node), map)) {
-			OverlayManager & overlay_manager = map.overlay_manager();
+		if (editor_tool_set_starting_pos_callback(map->get_fcoords(center.node), *map)) {
+			OverlayManager & overlay_manager = map->overlay_manager();
 			//  remove old overlay if any
 			overlay_manager.remove_overlay(old_sp, pic);
 
@@ -98,7 +98,7 @@
 			(center.node, pic, 8, Point(pic->width() / 2, STARTING_POS_HOTSPOT_Y));
 
 			//  set new player pos
-			map.set_starting_pos(m_current_player, center.node);
+			map->set_starting_pos(m_current_player, center.node);
 
 		}
 	}

=== modified file 'src/editor/tools/editor_set_starting_pos_tool.h'
--- src/editor/tools/editor_set_starting_pos_tool.h	2014-09-20 09:37:47 +0000
+++ src/editor/tools/editor_set_starting_pos_tool.h	2016-01-04 21:01:25 +0000
@@ -34,11 +34,11 @@
 struct EditorSetStartingPosTool : public EditorTool {
 	EditorSetStartingPosTool();
 
-	int32_t handle_click_impl(Widelands::Map&,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<>,
 	                          EditorInteractive&,
-	                          EditorActionArgs&) override;
+	                          EditorActionArgs*,
+							  Widelands::Map*) override;
 	char const * get_sel_impl() const override
 		{return m_current_sel_pic;}
 

=== modified file 'src/editor/tools/editor_set_terrain_tool.cc'
--- src/editor/tools/editor_set_terrain_tool.cc	2015-11-11 09:54:53 +0000
+++ src/editor/tools/editor_set_terrain_tool.cc	2016-01-04 21:01:25 +0000
@@ -25,74 +25,74 @@
 
 using Widelands::TCoords;
 
-int32_t EditorSetTerrainTool::handle_click_impl(Widelands::Map& map,
-                                                   const Widelands::World& world,
-                                                   Widelands::NodeAndTriangle<> const center,
-                                                   EditorInteractive& /* parent */,
-                                                   EditorActionArgs& args) {
+int32_t EditorSetTerrainTool::handle_click_impl(const Widelands::World& world,
+                                                Widelands::NodeAndTriangle<> const center,
+                                                EditorInteractive& /* parent */,
+                                                EditorActionArgs* args,
+												Widelands::Map* map) {
 	assert
 	(center.triangle.t == TCoords<>::D || center.triangle.t == TCoords<>::R);
-	uint16_t const radius = args.sel_radius;
+	uint16_t const radius = args->sel_radius;
 	int32_t max = 0;
 
-	if (get_nr_enabled() && args.terrainType.empty()) {
+	if (get_nr_enabled() && args->terrainType.empty()) {
 		Widelands::MapTriangleRegion<TCoords<Widelands::FCoords> > mr
-		(map, Widelands::Area<TCoords<Widelands::FCoords> >
+		(*map, Widelands::Area<TCoords<Widelands::FCoords> >
 		 (TCoords<Widelands::FCoords>
-		  (Widelands::FCoords(map.get_fcoords(center.triangle)),
+		  (Widelands::FCoords(map->get_fcoords(center.triangle)),
 		   static_cast<TCoords<Widelands::FCoords>::TriangleIndex>(center.triangle.t)),
 		  radius));
 		do {
-			args.origTerrainType.push_back
+			args->origTerrainType.push_back
 				((mr.location().t == TCoords<Widelands::FCoords>::D)
 					? mr.location().field->terrain_d() : mr.location().field->terrain_r());
-			args.terrainType.push_back(get_random_enabled());
-		} while (mr.advance(map));
+			args->terrainType.push_back(get_random_enabled());
+		} while (mr.advance(*map));
 	}
 
-	if (!args.terrainType.empty()) {
+	if (!args->terrainType.empty()) {
 		Widelands::MapTriangleRegion<TCoords<Widelands::FCoords> > mr
-		(map, Widelands::Area<TCoords<Widelands::FCoords> >
+		(*map, Widelands::Area<TCoords<Widelands::FCoords> >
 		 (TCoords<Widelands::FCoords>
-		  (Widelands::FCoords(map.get_fcoords(center.triangle)),
+		  (Widelands::FCoords(map->get_fcoords(center.triangle)),
 		   static_cast<TCoords<Widelands::FCoords>::TriangleIndex>(center.triangle.t)),
 		    radius));
-		std::list<Widelands::DescriptionIndex>::iterator i = args.terrainType.begin();
+		std::list<Widelands::DescriptionIndex>::iterator i = args->terrainType.begin();
 		do {
 			max = std::max
-			      (max, map.change_terrain(world, mr.location(), *i));
+			      (max, map->change_terrain(world, mr.location(), *i));
 			++i;
-		} while (mr.advance(map));
+		} while (mr.advance(*map));
 	}
 	return radius + max;
 }
 
 int32_t
-EditorSetTerrainTool::handle_undo_impl(Widelands::Map& map,
-                                          const Widelands::World& world,
-                                          Widelands::NodeAndTriangle<Widelands::Coords> center,
-                                          EditorInteractive& /* parent */,
-                                          EditorActionArgs& args) {
+EditorSetTerrainTool::handle_undo_impl(const Widelands::World& world,
+                                       Widelands::NodeAndTriangle<Widelands::Coords> center,
+                                       EditorInteractive& /* parent */,
+                                       EditorActionArgs* args,
+									   Widelands::Map* map) {
 	assert
 	(center.triangle.t == TCoords<>::D || center.triangle.t == TCoords<>::R);
-	uint16_t const radius = args.sel_radius;
-	if (!args.terrainType.empty()) {
+	uint16_t const radius = args->sel_radius;
+	if (!args->terrainType.empty()) {
 		int32_t max = 0;
 		Widelands::MapTriangleRegion<TCoords<Widelands::FCoords> > mr
-		(map,
+		(*map,
 		 Widelands::Area<TCoords<Widelands::FCoords> >
 		 (TCoords<Widelands::FCoords>
-		  (Widelands::FCoords(map.get_fcoords(center.triangle)),
+		  (Widelands::FCoords(map->get_fcoords(center.triangle)),
 		   static_cast<TCoords<Widelands::FCoords>::TriangleIndex>
 		   (center.triangle.t)),
 		  radius));
 
-		std::list<Widelands::DescriptionIndex>::iterator i = args.origTerrainType.begin();
+		std::list<Widelands::DescriptionIndex>::iterator i = args->origTerrainType.begin();
 		do {
 			max = std::max
-			      (max, map.change_terrain(world, mr.location(), *i));
+			      (max, map->change_terrain(world, mr.location(), *i));
 			++i;
-		} while (mr.advance(map));
+		} while (mr.advance(*map));
 		return radius + max;
 	} else return radius;
 }

=== modified file 'src/editor/tools/editor_set_terrain_tool.h'
--- src/editor/tools/editor_set_terrain_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_set_terrain_tool.h	2016-01-04 21:01:25 +0000
@@ -26,17 +26,17 @@
 struct EditorSetTerrainTool : public EditorTool, public MultiSelect {
 	EditorSetTerrainTool() : EditorTool(*this, *this) {}
 
-	int32_t handle_click_impl(Widelands::Map& map,
-	                          const Widelands::World& world,
+	int32_t handle_click_impl(const Widelands::World& world,
 	                          Widelands::NodeAndTriangle<> center,
 	                          EditorInteractive& parent,
-	                          EditorActionArgs& args) override;
+	                          EditorActionArgs* args,
+							  Widelands::Map* map) override;
 
-	int32_t handle_undo_impl(Widelands::Map& map,
-	                         const Widelands::World& world,
+	int32_t handle_undo_impl(const Widelands::World& world,
 	                         Widelands::NodeAndTriangle<> center,
 	                         EditorInteractive& parent,
-	                         EditorActionArgs& args) override;
+	                         EditorActionArgs* args,
+							 Widelands::Map* map) override;
 
 	EditorActionArgs format_args_impl(EditorInteractive & parent) override;
 

=== modified file 'src/editor/tools/editor_tool.h'
--- src/editor/tools/editor_tool.h	2014-09-10 14:08:25 +0000
+++ src/editor/tools/editor_tool.h	2016-01-04 21:01:25 +0000
@@ -48,22 +48,22 @@
 	enum ToolIndex {First, Second, Third};
 	int32_t handle_click
 		(const ToolIndex i,
-		Widelands::Map & map, const Widelands::World& world, Widelands::NodeAndTriangle<> const center,
-		EditorInteractive & parent, EditorActionArgs & args)
+		const Widelands::World& world, Widelands::NodeAndTriangle<> const center,
+		EditorInteractive& parent, EditorActionArgs* args, Widelands::Map* map)
 	{
 		return
 		    (i == First ? *this : i == Second ? m_second : m_third)
-		    .handle_click_impl(map, world, center, parent, args);
+		    .handle_click_impl(world, center, parent, args, map);
 	}
 
 	int32_t handle_undo
 		(const ToolIndex i,
-		Widelands::Map & map, const Widelands::World& world, Widelands::NodeAndTriangle<> const center,
-		EditorInteractive & parent, EditorActionArgs & args)
+		const Widelands::World& world, Widelands::NodeAndTriangle<> const center,
+		EditorInteractive& parent, EditorActionArgs* args, Widelands::Map* map)
 	{
 		return
 		    (i == First ? *this : i == Second ? m_second : m_third)
-		    .handle_undo_impl(map, world, center, parent, args);
+		    .handle_undo_impl(world, center, parent, args, map);
 	}
 
 	const char * get_sel(const ToolIndex i) {
@@ -83,16 +83,16 @@
 	virtual EditorActionArgs format_args_impl(EditorInteractive & parent) {
 		return EditorActionArgs(parent);
 	}
-	virtual int32_t handle_click_impl(Widelands::Map&,
-	                                  const Widelands::World& world,
+	virtual int32_t handle_click_impl(const Widelands::World& world,
 	                                  Widelands::NodeAndTriangle<>,
 	                                  EditorInteractive&,
-	                                  EditorActionArgs&) = 0;
-	virtual int32_t handle_undo_impl(Widelands::Map&,
-	                                 const Widelands::World&,
+	                                  EditorActionArgs*,
+									  Widelands::Map*) = 0;
+	virtual int32_t handle_undo_impl(const Widelands::World&,
 	                                 Widelands::NodeAndTriangle<>,
 	                                 EditorInteractive&,
-	                                 EditorActionArgs&) {
+	                                 EditorActionArgs*,
+									 Widelands::Map*) {
 		return 0;
 	}  // non unduable tools don't need to implement this.
 	virtual const char * get_sel_impl() const = 0;

=== modified file 'src/editor/ui_menus/editor_tool_change_resources_options_menu.cc'
--- src/editor/ui_menus/editor_tool_change_resources_options_menu.cc	2015-11-11 09:56:22 +0000
+++ src/editor/ui_menus/editor_tool_change_resources_options_menu.cc	2016-01-04 21:01:25 +0000
@@ -31,6 +31,7 @@
 #include "logic/widelands.h"
 #include "logic/world/resource_description.h"
 #include "logic/world/world.h"
+#include "logic/widelands_geometry.h"
 #include "ui_basic/button.h"
 #include "wui/overlay_manager.h"
 
@@ -212,16 +213,18 @@
  * called when a resource has been selected
  */
 void EditorToolChangeResourcesOptionsMenu::selected() {
-	const int32_t n = m_radiogroup.get_state();
+	const int32_t resIx = m_radiogroup.get_state();
 
-	m_increase_tool.set_tool().set_cur_res(n);
-	m_increase_tool.set_cur_res(n);
-	m_increase_tool.decrease_tool().set_cur_res(n);
+	m_increase_tool.set_tool().set_cur_res(resIx);
+	m_increase_tool.set_cur_res(resIx);
+	m_increase_tool.decrease_tool().set_cur_res(resIx);
 
 	Widelands::EditorGameBase& egbase = eia().egbase();
 	Widelands::Map & map = egbase.map();
 	map.overlay_manager().register_overlay_callback_function(
-	   boost::bind(&editor_change_resource_tool_callback, _1, boost::ref(map), boost::ref(egbase.world()), n));
+			[&] (const Widelands::TCoords<Widelands::FCoords>& coords)
+			{return map.is_resource_valid(egbase.world(), coords, resIx);});
+
 	map.recalc_whole_map(egbase.world());
 	select_correct_tool();
 

=== modified file 'src/logic/bob.h'
--- src/logic/bob.h	2016-01-03 22:05:49 +0000
+++ src/logic/bob.h	2016-01-04 21:01:25 +0000
@@ -258,7 +258,7 @@
 	// default tasks
 	void reset_tasks(Game &);
 
-        // TODO correct (?) Send a signal that may switch to some other \ref Task
+        // TODO(feature-Hasi50): correct (?) Send a signal that may switch to some other \ref Task
 	void send_signal(Game &, char const *);
 	void start_task_idle(Game &, uint32_t anim, int32_t timeout);
 

=== modified file 'src/logic/game_controller.h'
--- src/logic/game_controller.h	2016-01-02 12:36:38 +0000
+++ src/logic/game_controller.h	2016-01-04 21:01:25 +0000
@@ -95,7 +95,7 @@
 	 * by the win_condition scripts.
 	 * \param player : the player idx;
 	 * \param result : the player result
-	 * \param info : The info string (\see \struct PlayerEndStatus) 
+	 * \param info : The info string (\see \struct PlayerEndStatus)
 	 */
 	virtual void report_result
 	    (uint8_t /* player */,

=== modified file 'src/logic/map.cc'
--- src/logic/map.cc	2015-12-11 20:12:29 +0000
+++ src/logic/map.cc	2016-01-04 21:01:25 +0000
@@ -172,26 +172,19 @@
 			recalc_nodecaps_pass2(world, f);
 		}
 
-	//  Now only recaluclate the overlays.
+	//  Now only recalculate the overlays.
 	for (int16_t y = 0; y < m_height; ++y)
 		for (int16_t x = 0; x < m_width; ++x)
 			overlay_manager().recalc_field_overlays(get_fcoords(Coords(x, y)));
 }
 
-/*
- * recalculates all default resources.
- *
- * This just needed for the game, not for
- * the editor. Since there, default resources
- * are not shown.
- */
 void Map::recalc_default_resources(const World& world) {
 	for (int16_t y = 0; y < m_height; ++y)
 		for (int16_t x = 0; x < m_width; ++x) {
 			FCoords f, f1;
 			f = get_fcoords(Coords(x, y));
 			//  only on unset nodes
-			if (f.field->get_resources() != 0 || f.field->get_resources_amount())
+			if (f.field->get_resources() != Widelands::kNoResource || f.field->get_resources_amount())
 				continue;
 			std::map<int32_t, int32_t> m;
 			int32_t amount = 0;
@@ -272,7 +265,7 @@
 			amount /= 6;
 
 			if (res == -1 || !amount) {
-				f.field->set_resources(0, 0);
+				f.field->set_resources(Widelands::kNoResource, 0);
 				f.field->set_initial_res_amount(0);
 			} else {
 				f.field->set_resources(res, amount);
@@ -350,6 +343,7 @@
 		for (; field < fields_end; ++field) {
 			field->set_height(10);
 			field->set_terrains(default_terrains);
+			field->set_resources(Widelands::kNoResource, 0);
 		}
 	}
 	recalc_whole_map(world);
@@ -1855,22 +1849,34 @@
 	return false;
 }
 
-/*
-===========
-changes the given triangle's terrain.
-this happens in the editor and might happen in the game
-too if some kind of land increasement is implemented (like
-drying swamps).
-The nodecaps need to be recalculated
-
-returns the radius of changes (which are always 2)
-===========
-*/
 int32_t Map::change_terrain
 	(const World& world, TCoords<FCoords> const c, DescriptionIndex const terrain)
 {
 	c.field->set_terrain(c.t, terrain);
 
+	// remove invalid resources if necessary
+	// check vertex to which the triangle belongs
+	if (!is_resource_valid(world, c, c.field->get_resources())){
+		c.field->set_resources(Widelands::kNoResource, 0);
+		overlay_manager().remove_overlay(c, NULL);
+	}
+
+	// always check south-east vertex
+	Widelands::FCoords f_se(c, c.field);
+	get_neighbour(f_se, Widelands::WALK_SE, &f_se);
+	if (!is_resource_valid(world, f_se, f_se.field->get_resources())){
+		f_se.field->set_resources(Widelands::kNoResource, 0);
+		overlay_manager().remove_overlay(f_se, NULL);
+	}
+
+	// check south-west vertex if d-Triangle is changed, check east vertex if r-Triangle is changed
+	Widelands::FCoords f_sw_e(c, c.field);
+	get_neighbour(f_sw_e, c.t == TCoords<FCoords>::D ? Widelands::WALK_SW : Widelands::WALK_E, &f_sw_e);
+	if (!is_resource_valid(world, f_sw_e, f_sw_e.field->get_resources())){
+		f_sw_e.field->set_resources(Widelands::kNoResource, 0);
+		overlay_manager().remove_overlay(f_sw_e, NULL);
+	}
+
 	Notifications::publish(NoteFieldTransformed(c, c.field - &m_fields[0]));
 
 	recalc_for_field_area(world, Area<FCoords>(c, 2));
@@ -1878,6 +1884,45 @@
 	return 2;
 }
 
+bool Map::is_resource_valid
+	(const Widelands::World& world, const TCoords<Widelands::FCoords>& c, int32_t const curres)
+{
+	if (curres == Widelands::kNoResource)
+		return true;
+
+	Widelands::FCoords f(c, c.field);
+	Widelands::FCoords f1;
+
+	int32_t count = 0;
+
+	//  this field
+	count += world.terrain_descr(f.field->terrain_r()).is_resource_valid(curres);
+	count += world.terrain_descr(f.field->terrain_d()).is_resource_valid(curres);
+
+	//  If one of the neighbours is impassable, count its resource stronger.
+	//  top left neigbour
+	get_neighbour(f, Widelands::WALK_NW, &f1);
+	count += world.terrain_descr(f1.field->terrain_r()).is_resource_valid(curres);
+	count += world.terrain_descr(f1.field->terrain_d()).is_resource_valid(curres);
+
+	//  top right neigbour
+	get_neighbour(f, Widelands::WALK_NE, &f1);
+	count += world.terrain_descr(f1.field->terrain_d()).is_resource_valid(curres);
+
+	//  left neighbour
+	get_neighbour(f, Widelands::WALK_W, &f1);
+	count += world.terrain_descr(f1.field->terrain_r()).is_resource_valid(curres);
+
+	return count > 1;
+}
+
+void Map::ensure_resource_consistency(const World& world)
+{
+	for (MapIndex i = 0; i < max_index(); ++i)
+		if (!is_resource_valid(world, get_fcoords(m_fields[i]), m_fields[i].get_resources()))
+			m_fields[i].set_resources(Widelands::kNoResource, 0);
+}
+
 
 uint32_t Map::set_height(const World& world, const FCoords fc, uint8_t const new_value) {
 	assert(new_value <= MAX_FIELD_HEIGHT);

=== modified file 'src/logic/map.h'
--- src/logic/map.h	2015-12-04 17:58:39 +0000
+++ src/logic/map.h	2016-01-04 21:01:25 +0000
@@ -184,6 +184,19 @@
 
 	void recalc_whole_map(const World& world);
 	virtual void recalc_for_field_area(const World& world, Area<FCoords>);
+
+	/***
+	 * Ensures that resources match their adjacent terrains.
+	 */
+	void ensure_resource_consistency(const World& world);
+
+	/***
+	 * Recalculates all default resources.
+	 *
+	 * This is just needed for the game, not for
+	 * the editor. Since there, default resources
+	 * are not shown.
+	 */
 	void recalc_default_resources(const World& world);
 
 	void set_nrplayers(PlayerNumber);
@@ -370,9 +383,24 @@
 	 */
 	uint32_t set_height(const World& world, Area<FCoords>, HeightInterval height_interval);
 
-	//  change terrain of a triangle, recalculate buildcaps
+	/***
+	 * Changes the given triangle's terrain. This happens in the editor and might
+	 * happen in the game too if some kind of land increasement is implemented (like
+	 * drying swamps). The nodecaps need to be recalculated
+	 *
+	 * @return the radius of changes (which are always 2)
+	 */
 	int32_t change_terrain(const World& world, TCoords<FCoords>, DescriptionIndex);
 
+	/***
+	 * Verify if a resource attached to a vertex has enough adjacent matching terrains to be valid.
+	 *
+	 * To qualify as valid, resources need to be surrounded by at least two matching terrains.
+	 */
+	bool is_resource_valid
+		(const Widelands::World& world, const Widelands::TCoords<Widelands::FCoords>& c,
+		int32_t const curres);
+
 	// The objectives that are defined in this map if it is a scenario.
 	const Objectives& objectives() const {
 		return objectives_;
@@ -448,10 +476,8 @@
 		 bool consider_mobs = true, NodeCaps initcaps = CAPS_NONE);
 	bool is_cycle_connected
 		(const FCoords & start, uint32_t length, const WalkingDir * dirs);
-
 	template<typename functorT>
 		void find_reachable(Area<FCoords>, const CheckStep &, functorT &);
-
 	template<typename functorT> void find(const Area<FCoords>, functorT &) const;
 
 	MapVersion m_map_version;
@@ -545,7 +571,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::l_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -567,7 +593,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x - 1, f.y), f.field - 1);
 	if (result.x == -1) {
 		result.x = m_width - 1;
@@ -578,7 +604,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 
@@ -615,7 +641,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::r_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -637,7 +663,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x + 1, f.y), f.field + 1);
 	if (result.x == m_width) {result.x = 0; result.field -= m_width;}
 	assert(0 <= result.x);
@@ -645,7 +671,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 
@@ -676,7 +702,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	o->y = f.y - 1;
 	o->x = f.x;
 	o->field = f.field - m_width;
@@ -697,7 +723,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::tl_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -724,7 +750,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x, f.y - 1), f.field - m_width);
 	if (result.y & 1) {
 		if (result.y == -1) {
@@ -743,7 +769,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 
@@ -774,7 +800,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	o->x = f.x;
 	o->field = f.field - m_width;
 	if (f.y & 1) {
@@ -795,7 +821,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::tr_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -822,7 +848,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x, f.y - 1), f.field - m_width);
 	if (f.y & 1) {
 		++result.x;
@@ -841,7 +867,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 
@@ -871,7 +897,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	o->y = f.y + 1;
 	o->x = f.x;
 	o->field = f.field + m_width;
@@ -892,7 +918,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::bl_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -919,7 +945,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x, f.y + 1), f.field + m_width);
 	if (result.y == m_height) {
 		result.y = 0;
@@ -938,7 +964,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 
@@ -971,7 +997,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	o->x = f.x;
 	o->field = f.field + m_width;
 	if (f.y & 1) {
@@ -992,7 +1018,7 @@
 	assert(0 <= o->y);
 	assert(o->y < m_height);
 	assert(m_fields.get() <= o->field);
-	assert            (o->field < m_fields.get() + max_index());
+	assert(o->field < m_fields.get() + max_index());
 }
 inline Coords Map::br_n(const Coords & f) const {
 	assert(0 <= f.x);
@@ -1019,7 +1045,7 @@
 	assert(0 <= f.y);
 	assert(f.y < m_height);
 	assert(m_fields.get() <= f.field);
-	assert            (f.field < m_fields.get() + max_index());
+	assert(f.field < m_fields.get() + max_index());
 	FCoords result(Coords(f.x, f.y + 1), f.field + m_width);
 	if (f.y & 1) {
 		++result.x;
@@ -1038,7 +1064,7 @@
 	assert(0 <= result.y);
 	assert(result.y < m_height);
 	assert(m_fields.get() <= result.field);
-	assert            (result.field < m_fields.get() + max_index());
+	assert(result.field < m_fields.get() + max_index());
 	return result;
 }
 

=== modified file 'src/logic/widelands.h'
--- src/logic/widelands.h	2015-11-11 09:56:22 +0000
+++ src/logic/widelands.h	2016-01-04 21:01:25 +0000
@@ -62,6 +62,7 @@
 using Direction = uint8_t;
 constexpr uint8_t INVALID_INDEX = std::numeric_limits<uint8_t>::max();
 constexpr DescriptionIndex kInvalidWare = INVALID_INDEX - 1;
+constexpr DescriptionIndex kNoResource = INVALID_INDEX - 1;
 
 struct SoldierStrength {
 	uint8_t hp, attack, defense, evade;

=== modified file 'src/logic/worker.cc'
--- src/logic/worker.cc	2015-12-05 10:59:02 +0000
+++ src/logic/worker.cc	2016-01-04 21:01:25 +0000
@@ -945,26 +945,23 @@
 	BaseImmovable const * const imm = position.field->get_immovable();
 	const World & world = game.world();
 
-	if (imm && imm->get_size() > BaseImmovable::NONE) {
-		//NoLog("  Field is no longer empty\n");
-	} else if
-		(const ResourceDescription * const rdescr =
-			world.get_resource(position.field->get_resources()))
-	{
+	if (!(imm && imm->get_size() > BaseImmovable::NONE)) {
+
+		const ResourceDescription * const rdescr =
+				world.get_resource(position.field->get_resources());
 		const TribeDescr & t = owner().tribe();
 		const Immovable& ri = game.create_immovable
-			(position,
-			 t.get_resource_indicator
-				(rdescr,
-				rdescr->detectable() ?
-				position.field->get_resources_amount() : 0),
-			 MapObjectDescr::OwnerType::kTribe);
+				(position,
+				 t.get_resource_indicator
+						 (rdescr,
+						  (rdescr && rdescr->detectable()) ?
+						  position.field->get_resources_amount() : 0),
+				 MapObjectDescr::OwnerType::kTribe);
 
 		// Geologist also sends a message notifying the player
-		if (rdescr->detectable() && position.field->get_resources_amount()) {
+		if (rdescr && rdescr->detectable() && position.field->get_resources_amount()) {
 			const std::string message =
-					(boost::format("<rt image=%s>"
-										"<p font-face=serif font-size=14>%s</p></rt>")
+					(boost::format("<rt image=%s><p font-face=serif font-size=14>%s</p></rt>")
 					 % rdescr->get_editor_pic(rdescr->max_amount())
 					 % _("A geologist found resources.")).str();
 
@@ -983,18 +980,17 @@
 			//  We should add a message to the player's message queue - but only,
 			//  if there is not already a similar one in list.
 			owner().add_message_with_timeout
-				(game,
-				 *new Message
-					(message_type,
-					 game.get_gametime(),
-					 rdescr->descname(),
-					 ri.descr().representative_image_filename(),
-					 rdescr->descname(),
-					 message,
-					 position,
-					 m_serial
-					),
-				 300000, 8);
+					(game,
+					 *new Message
+							 (message_type,
+							  game.get_gametime(),
+							  rdescr->descname(),
+							  ri.descr().representative_image_filename(),
+							  rdescr->descname(),
+							  message,
+							  position,
+							  m_serial),
+					 300000, 8);
 		}
 	}
 

=== modified file 'src/logic/world/world.cc'
--- src/logic/world/world.cc	2015-11-11 10:03:41 +0000
+++ src/logic/world/world.cc	2016-01-04 21:01:25 +0000
@@ -172,11 +172,14 @@
 }
 
 DescriptionIndex World::get_resource(const char* const name) const {
-	return resources_->get_index(name);
+	return strcmp(name, "none") ? resources_->get_index(name): Widelands::kNoResource;
 }
 
+/***
+ * @return The ResourceDescription for the given index. Returns Nullptr for kNoResource.
+ */
 ResourceDescription const* World::get_resource(DescriptionIndex const res) const {
-	assert(res < resources_->size());
+	assert(res < resources_->size() || res == Widelands::kNoResource);
 	return resources_->get_mutable(res);
 }
 

=== modified file 'src/map_io/widelands_map_loader.cc'
--- src/map_io/widelands_map_loader.cc	2015-09-18 18:17:01 +0000
+++ src/map_io/widelands_map_loader.cc	2016-01-04 21:01:25 +0000
@@ -290,6 +290,8 @@
 
 	m_map.recalc_whole_map(egbase.world());
 
+	m_map.ensure_resource_consistency(egbase.world());
+
 	set_state(STATE_LOADED);
 
 	return 0;

=== modified file 'src/scripting/lua_map.cc'
--- src/scripting/lua_map.cc	2015-12-09 17:39:11 +0000
+++ src/scripting/lua_map.cc	2016-01-04 21:01:25 +0000
@@ -4432,9 +4432,12 @@
 		:see also: :attr:`resource_amount`
 */
 int LuaField::get_resource(lua_State * L) {
+
+	const ResourceDescription* rDesc = get_egbase(L).world().get_resource
+			(fcoords(L).field->get_resources());
+
 	lua_pushstring
-		(L, get_egbase(L).world().get_resource
-			 (fcoords(L).field->get_resources())->name().c_str());
+		(L, rDesc ? rDesc->name().c_str() : "none");
 
 	return 1;
 }
@@ -4466,7 +4469,8 @@
 	Field * field = fcoords(L).field;
 	int32_t res = field->get_resources();
 	int32_t amount = luaL_checkint32(L, -1);
-	int32_t max_amount = get_egbase(L).world().get_resource(res)->max_amount();
+	const ResourceDescription * resDesc = get_egbase(L).world().get_resource(res);
+	int32_t max_amount = resDesc ? resDesc->max_amount() : 0;
 
 	if (amount < 0 || amount > max_amount)
 		report_error(L, "Illegal amount: %i, must be >= 0 and <= %i", amount, max_amount);

=== modified file 'src/ui_fsmenu/options.cc'
--- src/ui_fsmenu/options.cc	2016-01-01 18:57:17 +0000
+++ src/ui_fsmenu/options.cc	2016-01-04 21:01:25 +0000
@@ -532,7 +532,8 @@
  * Handles communication between window class and options
  */
 OptionsCtrl::OptionsCtrl(Section & s)
-: opt_section_(s), opt_dialog_(std::unique_ptr<FullscreenMenuOptions>(new FullscreenMenuOptions(options_struct(0))))
+: opt_section_(s),
+  opt_dialog_(std::unique_ptr<FullscreenMenuOptions>(new FullscreenMenuOptions(options_struct(0))))
 {
 	handle_menu();
 }

=== modified file 'src/wui/overlay_manager.cc'
--- src/wui/overlay_manager.cc	2014-09-14 11:31:58 +0000
+++ src/wui/overlay_manager.cc	2016-01-04 21:01:25 +0000
@@ -182,6 +182,8 @@
 
 /**
  * remove one (or many) overlays from a node or triangle
+ *
+ * @param pic    The overlay to remove. If null, all overlays are removed.
  */
 void OverlayManager::remove_overlay
 	(Widelands::TCoords<> const c, const Image* pic)
@@ -193,7 +195,7 @@
 	if (overlay_map.count(c)) {
 		RegisteredOverlaysMap::iterator it = overlay_map.lower_bound(c);
 		do {
-			if (pic && it->second.pic == pic) {
+			if (!pic || it->second.pic == pic) {
 				overlay_map.erase(it);
 				it = overlay_map.lower_bound(c);
 			} else {

=== modified file 'src/wui/overlay_manager.h'
--- src/wui/overlay_manager.h	2014-09-14 11:31:58 +0000
+++ src/wui/overlay_manager.h	2016-01-04 21:01:25 +0000
@@ -66,7 +66,7 @@
 	};
 
 	using CallbackFn =
-		boost::function<int32_t(const Widelands::TCoords<Widelands::FCoords>& coordinates)>;
+		boost::function<bool(const Widelands::TCoords<Widelands::FCoords>& coordinates)>;
 
 	OverlayManager();
 

=== modified file 'test/maps/lua_testsuite.wmf/scripting/efield.lua'
--- test/maps/lua_testsuite.wmf/scripting/efield.lua	2015-10-31 11:59:04 +0000
+++ test/maps/lua_testsuite.wmf/scripting/efield.lua	2016-01-04 21:01:25 +0000
@@ -5,15 +5,15 @@
 function field_resources_tests:test_default_resource_in_editor()
    -- The editor doesn't bother to set the default resources on the map.
    -- The user might want to overwrite them anyways. It therefore sets
-   -- the resource of all fields to the first in the world and the amount
-   -- to zero.
-   assert_equal("coal", self.f.resource)
+   -- the resource of all fields to 'none' and the amount to zero.
+   assert_equal("none", self.f.resource)
    assert_equal(0, self.f.resource_amount)
 end
 
 function field_resources_tests:test_initial_resource_in_editor()
-   -- making sure that (set_) resource_amount sets also starting resource in the editor
-   assert_equal("coal", self.f.resource)
+   -- making sure that (set_) resource_amount sets also initial resource in the editor
+   -- the resource has to be set to something different than 'none', as none has no amount
+   self.f.resource = "coal"
    self.f.resource_amount=10
    assert_equal(self.f.initial_resource_amount, self.f.resource_amount)
    assert_equal(10, self.f.initial_resource_amount)