Merge lp:~widelands-dev/widelands/kill_overlay_manager into lp:widelands

[SirVer]

 Delete the overlay_manager.
  - Draw build help in the draw routines directly.
  - Give Editor tools the ability to modify which field caps should be used for overlays. This is used to restrict resources, player starting positions and port positions.

[SirVer (sirver)]

This is the last refactoring branch in the pipeline for now. This is a refactoring that decreases coupling and makes the clearer in many places.

It also makes overlay bugs less likely since overlays no longer need to be registered, they are just drawn as the current state of the playing field is.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2665. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/274941928.
Appveyor build 2486. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_kill_overlay_manager-2486.

[kaputtnik (franku)]

When compiling this branch:

.../kill_overlay_manager/src/editor/tools/set_port_space_tool.cc:42: Trailing whitespace at end of line
.../kill_overlay_manager/src/editor/tools/set_starting_pos_tool.cc:58: Trailing whitespace at end of line

All is working imho. In Editor i tested overlays, playing starting positions, resources and ports.

In an older save game tested the buildhelp.

review: Approve (testing)

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2666. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/275173267.
Appveyor build 2487. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_kill_overlay_manager-2487.

[GunChleoc (gunchleoc)]

Goodbye, you won't be missed :)

@bunnybot merge

review: Approve

=== modified file 'src/editor/CMakeLists.txt'
--- src/editor/CMakeLists.txt	2017-08-17 13:37:32 +0000
+++ src/editor/CMakeLists.txt	2017-09-13 18:51:31 +0000
@@ -108,6 +108,5 @@
     ui_basic
     wui
     wui_common
-    wui_field_overlay_manager
     wui_mapview_pixelfunctions
 )
 
=== modified file 'src/editor/editorinteractive.cc'
--- src/editor/editorinteractive.cc	2017-09-10 18:17:55 +0000
+++ src/editor/editorinteractive.cc	2017-09-13 18:51:31 +0000
@@ -51,7 +51,6 @@
 #include "scripting/lua_table.h"
 #include "ui_basic/messagebox.h"
 #include "ui_basic/progresswindow.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/game_tips.h"
 #include "wui/interactive_base.h"
 
@@ -190,9 +189,6 @@
 	// TODO(unknown): get rid of cleanup_for_load, it tends to be very messy
 	// Instead, delete and re-create the egbase.
 	egbase().cleanup_for_load();
-
-	// Select a tool that doesn't care about map changes
-	mutable_field_overlay_manager()->register_overlay_callback_function(nullptr);
 }
 
 /// Called just before the editor starts, after postload, init and gfxload.
@@ -331,9 +327,14 @@
 			}
 		}
 
-		// TODO(sirver): Do not use the field_overlay_manager, instead draw the
-		// overlays we are interested in here directly.
-		field_overlay_manager().foreach_overlay(field.fcoords, blit_overlay);
+		// Draw build help.
+		if (buildhelp()) {
+			const auto* overlay =
+			   get_buildhelp_overlay(tools_->current().nodecaps_for_buildhelp(field.fcoords, ebase));
+			if (overlay != nullptr) {
+				blit_overlay(overlay->pic, overlay->hotspot);
+			}
+		}
 
 		// Draw the player starting position overlays.
 		const auto it = starting_positions.find(field.fcoords);
@@ -589,9 +590,6 @@
 				toolsize_menu.update(toolsize_menu.value());
 			}
 		}
-		//  A new tool has been selected. Remove all registered overlay callback
-		//  functions.
-		mutable_field_overlay_manager()->register_overlay_callback_function(nullptr);
 		egbase().mutable_map()->recalc_whole_map(egbase().world());
 	}
 	tools_->current_pointer = &primary;
@@ -680,8 +678,6 @@
 	case MapWas::kGloballyMutated:
 		break;
 	}
-
-	mutable_field_overlay_manager()->remove_all_overlays();
 }
 
 EditorInteractive::Tools* EditorInteractive::tools() {
 
=== modified file 'src/editor/tools/decrease_resources_tool.h'
--- src/editor/tools/decrease_resources_tool.h	2017-01-25 18:55:59 +0000
+++ src/editor/tools/decrease_resources_tool.h	2017-09-13 18:51:31 +0000
@@ -20,6 +20,7 @@
 #ifndef WL_EDITOR_TOOLS_DECREASE_RESOURCES_TOOL_H
 #define WL_EDITOR_TOOLS_DECREASE_RESOURCES_TOOL_H
 
+#include "editor/tools/set_resources_tool.h"
 #include "editor/tools/tool.h"
 
 ///  Decreases the resources of a node by a value.
@@ -45,6 +46,11 @@
 		return g_gr->images().get("images/wui/editor/fsel_editor_decrease_resources.png");
 	}
 
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase& egbase) override {
+		return resource_tools_nodecaps(fcoords, egbase, cur_res_);
+	}
+
 	int32_t get_change_by() const {
 		return change_by_;
 	}
 
=== modified file 'src/editor/tools/increase_resources_tool.h'
--- src/editor/tools/increase_resources_tool.h	2017-01-25 18:55:59 +0000
+++ src/editor/tools/increase_resources_tool.h	2017-09-13 18:51:31 +0000
@@ -57,6 +57,11 @@
 		return g_gr->images().get("images/wui/editor/fsel_editor_increase_resources.png");
 	}
 
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase& egbase) override {
+		return resource_tools_nodecaps(fcoords, egbase, cur_res_);
+	}
+
 	int32_t get_change_by() const {
 		return change_by_;
 	}
 
=== modified file 'src/editor/tools/set_port_space_tool.cc'
--- src/editor/tools/set_port_space_tool.cc	2017-08-13 18:02:53 +0000
+++ src/editor/tools/set_port_space_tool.cc	2017-09-13 18:51:31 +0000
@@ -28,16 +28,19 @@
 
 using namespace Widelands;
 
-/// static callback function for overlay calculation
-int32_t editor_tool_set_port_space_callback(const Widelands::FCoords& c, const Map& map) {
+namespace  {
+
+Widelands::NodeCaps port_tool_nodecaps(const Widelands::FCoords& c, const Map& map) {
 	NodeCaps const caps = c.field->nodecaps();
 	if ((caps & BUILDCAPS_SIZEMASK) == BUILDCAPS_BIG) {
 		if (!map.find_portdock(c).empty())
 			return caps;
 	}
-	return 0;
+	return NodeCaps::CAPS_NONE;
 }
 
+}  // namespace
+
 EditorSetPortSpaceTool::EditorSetPortSpaceTool(EditorUnsetPortSpaceTool& the_unset_tool)
    : EditorTool(the_unset_tool, the_unset_tool) {
 }
@@ -61,7 +64,7 @@
 	   *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)) {
+		if (port_tool_nodecaps(mr.location(), *map) != NodeCaps::CAPS_NONE) {
 			map->set_port_space(mr.location(), true);
 			Area<FCoords> a(mr.location(), 0);
 			map->recalc_for_field_area(world, a);
@@ -72,6 +75,12 @@
 	return nr;
 }
 
+Widelands::NodeCaps
+EditorSetPortSpaceTool::nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+                                               const Widelands::EditorGameBase& egbase) {
+	return port_tool_nodecaps(fcoords, egbase.map());
+}
+
 int32_t EditorSetPortSpaceTool::handle_undo_impl(const Widelands::World& world,
                                                  const NodeAndTriangle<Coords>& center,
                                                  EditorInteractive& parent,
@@ -96,7 +105,7 @@
 	   *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)) {
+		if (port_tool_nodecaps(mr.location(), *map)) {
 			map->set_port_space(mr.location(), false);
 			Area<FCoords> a(mr.location(), 0);
 			map->recalc_for_field_area(world, a);
@@ -114,3 +123,9 @@
                                                    Map* map) {
 	return parent.tools()->set_port_space.handle_click_impl(world, center, parent, args, map);
 }
+
+Widelands::NodeCaps
+EditorUnsetPortSpaceTool::nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+                                                  const Widelands::EditorGameBase& egbase) {
+	return port_tool_nodecaps(fcoords, egbase.map());
+}
 
=== modified file 'src/editor/tools/set_port_space_tool.h'
--- src/editor/tools/set_port_space_tool.h	2017-08-13 18:02:53 +0000
+++ src/editor/tools/set_port_space_tool.h	2017-09-13 18:51:31 +0000
@@ -46,6 +46,8 @@
 	const Image* get_sel_impl() const override {
 		return g_gr->images().get(FSEL_EUPS_FILENAME);
 	}
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase& egbase) override;
 };
 
 /// Sets a buildspace for ports.
@@ -68,8 +70,8 @@
 	const Image* get_sel_impl() const override {
 		return g_gr->images().get(FSEL_ESPS_FILENAME);
 	}
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase& egbase) override;
 };
 
-int32_t editor_tool_set_port_space_callback(const Widelands::FCoords& c, const Widelands::Map& map);
-
 #endif  // end of include guard: WL_EDITOR_TOOLS_SET_PORT_SPACE_TOOL_H
 
=== modified file 'src/editor/tools/set_resources_tool.cc'
--- src/editor/tools/set_resources_tool.cc	2017-01-25 18:55:59 +0000
+++ src/editor/tools/set_resources_tool.cc	2017-09-13 18:51:31 +0000
@@ -85,3 +85,13 @@
 	a.set_to = set_to_;
 	return a;
 }
+
+Widelands::NodeCaps resource_tools_nodecaps(const Widelands::FCoords& fcoords,
+                                            const Widelands::EditorGameBase& egbase,
+                                            Widelands::DescriptionIndex resource) {
+	if (egbase.map().is_resource_valid(egbase.world(), fcoords, resource)) {
+		return fcoords.field->nodecaps();
+	}
+	return Widelands::NodeCaps::CAPS_NONE;
+}
+
 
=== modified file 'src/editor/tools/set_resources_tool.h'
--- src/editor/tools/set_resources_tool.h	2017-01-25 18:55:59 +0000
+++ src/editor/tools/set_resources_tool.h	2017-09-13 18:51:31 +0000
@@ -24,6 +24,10 @@
 #include "logic/mapregion.h"
 #include "logic/widelands.h"
 
+Widelands::NodeCaps resource_tools_nodecaps(const Widelands::FCoords& fcoords,
+                                            const Widelands::EditorGameBase& egbase,
+                                            Widelands::DescriptionIndex resource);
+
 ///  Decreases the resources of a node by a value.
 struct EditorSetResourcesTool : public EditorTool {
 	EditorSetResourcesTool() : EditorTool(*this, *this), cur_res_(0), set_to_(0) {
@@ -50,6 +54,11 @@
 		return g_gr->images().get("images/wui/editor/fsel_editor_set_resources.png");
 	}
 
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase& egbase) override {
+		return resource_tools_nodecaps(fcoords, egbase, cur_res_);
+	}
+
 	Widelands::ResourceAmount get_set_to() const {
 		return set_to_;
 	}
 
=== modified file 'src/editor/tools/set_starting_pos_tool.cc'
--- src/editor/tools/set_starting_pos_tool.cc	2017-08-28 12:58:24 +0000
+++ src/editor/tools/set_starting_pos_tool.cc	2017-09-13 18:51:31 +0000
@@ -28,17 +28,17 @@
 // global variable to pass data from callback to class
 static int32_t current_player_;
 
-/*
- * static callback function for overlay calculation
- */
-int32_t editor_tool_set_starting_pos_callback(const Widelands::FCoords& c, Widelands::Map& map) {
+namespace  {
+
+Widelands::NodeCaps set_starting_pos_tool_nodecaps(const Widelands::FCoords& c,
+                                                   const Widelands::Map& map) {
 	// Area around already placed players
 	Widelands::PlayerNumber const nr_players = map.get_nrplayers();
 	for (Widelands::PlayerNumber p = 1, last = current_player_ - 1;; ++p) {
 		for (; p <= last; ++p) {
 			if (Widelands::Coords const sp = map.get_starting_pos(p)) {
 				if (map.calc_distance(sp, c) < MIN_PLACE_AROUND_PLAYERS) {
-					return 0;
+					return Widelands::NodeCaps::CAPS_NONE;
 				}
 			}
 		}
@@ -52,9 +52,11 @@
 	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_BIG)
 		return caps;
 
-	return 0;
+	return Widelands::NodeCaps::CAPS_NONE;
 }
 
+}  // namespace
+
 EditorSetStartingPosTool::EditorSetStartingPosTool() : EditorTool(*this, *this, false) {
 	current_player_ = 1;
 }
@@ -78,13 +80,20 @@
 		}
 
 		//  check if field is valid
-		if (editor_tool_set_starting_pos_callback(map->get_fcoords(center.node), *map)) {
+		if (set_starting_pos_tool_nodecaps(map->get_fcoords(center.node), *map) !=
+		    Widelands::NodeCaps::CAPS_NONE) {
 			map->set_starting_pos(current_player_, center.node);
 		}
 	}
 	return 1;
 }
 
+Widelands::NodeCaps
+EditorSetStartingPosTool::nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+                                                 const Widelands::EditorGameBase& egbase) {
+	return set_starting_pos_tool_nodecaps(fcoords, egbase.map());
+}
+
 Widelands::PlayerNumber EditorSetStartingPosTool::get_current_player() const {
 	return current_player_;
 }
 
=== modified file 'src/editor/tools/set_starting_pos_tool.h'
--- src/editor/tools/set_starting_pos_tool.h	2017-08-28 12:41:15 +0000
+++ src/editor/tools/set_starting_pos_tool.h	2017-09-13 18:51:31 +0000
@@ -25,7 +25,6 @@
 #include "editor/tools/tool.h"
 #include "graphic/playercolor.h"
 #include "logic/widelands.h"
-#include "wui/field_overlay_manager.h"
 
 // How much place should be left around a player position
 // where no other player can start
@@ -49,8 +48,8 @@
 	bool has_size_one() const override {
 		return true;
 	}
+	Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                           const Widelands::EditorGameBase&) override;
 };
 
-int32_t editor_tool_set_starting_pos_callback(const Widelands::FCoords& c, Widelands::Map& map);
-
 #endif  // end of include guard: WL_EDITOR_TOOLS_SET_STARTING_POS_TOOL_H
 
=== modified file 'src/editor/tools/tool.h'
--- src/editor/tools/tool.h	2017-01-25 18:55:59 +0000
+++ src/editor/tools/tool.h	2017-09-13 18:51:31 +0000
@@ -26,6 +26,7 @@
 #include "editor/tools/action_args.h"
 #include "graphic/graphic.h"
 #include "graphic/image.h"
+#include "logic/editor_game_base.h"
 #include "logic/widelands_geometry.h"
 
 class EditorInteractive;
@@ -99,6 +100,14 @@
 		return 0;
 	}  // non unduable tools don't need to implement this.
 	virtual const Image* get_sel_impl() const = 0;
+
+	// Gives the tool the chance to modify the nodecaps to change what will be
+	// displayed as build help.
+	virtual Widelands::NodeCaps nodecaps_for_buildhelp(const Widelands::FCoords& fcoords,
+	                                                   const Widelands::EditorGameBase&) {
+		return fcoords.field->nodecaps();
+	}
+
 	virtual bool operates_on_triangles() const {
 		return false;
 	}
 
=== modified file 'src/editor/ui_menus/player_menu.cc'
--- src/editor/ui_menus/player_menu.cc	2017-09-01 00:16:04 +0000
+++ src/editor/ui_menus/player_menu.cc	2017-09-13 18:51:31 +0000
@@ -33,7 +33,6 @@
 #include "ui_basic/editbox.h"
 #include "ui_basic/messagebox.h"
 #include "ui_basic/textarea.h"
-#include "wui/field_overlay_manager.h"
 
 #define UNDEFINED_TRIBE_NAME "<undefined>"
 
@@ -220,13 +219,6 @@
 	Widelands::PlayerNumber const nr_players = old_nr_players - 1;
 	assert(1 <= nr_players);
 
-	if (const Widelands::Coords sp = map->get_starting_pos(old_nr_players)) {
-		//  Remove starting position marker.
-		const Image* player_image =
-		   playercolor_image(old_nr_players - 1, "images/players/player_position.png");
-		assert(player_image);
-		menu.mutable_field_overlay_manager()->remove_overlay(sp, player_image);
-	}
 	// if removed player was selected switch to the next highest player
 	if (old_nr_players == menu.tools()->set_starting_pos.get_current_player()) {
 		set_starting_pos_clicked(nr_players);
@@ -275,12 +267,6 @@
 
 	//  reselect tool, so everything is in a defined state
 	menu.select_tool(menu.tools()->current(), EditorTool::First);
-
-	//  Register callback function to make sure that only valid locations are
-	//  selected.
-	menu.mutable_field_overlay_manager()->register_overlay_callback_function(
-	   boost::bind(&editor_tool_set_starting_pos_callback, _1, boost::ref(*map)));
-	map->recalc_whole_map(menu.egbase().world());
 	update();
 }
 
 
=== modified file 'src/editor/ui_menus/tool_change_resources_options_menu.cc'
--- src/editor/ui_menus/tool_change_resources_options_menu.cc	2017-08-19 22:22:20 +0000
+++ src/editor/ui_menus/tool_change_resources_options_menu.cc	2017-09-13 18:51:31 +0000
@@ -35,7 +35,6 @@
 #include "logic/map_objects/world/world.h"
 #include "logic/widelands.h"
 #include "logic/widelands_geometry.h"
-#include "wui/field_overlay_manager.h"
 
 constexpr int kMaxValue = 63;
 
@@ -153,17 +152,6 @@
 	increase_tool_.set_cur_res(resource_index);
 	increase_tool_.decrease_tool().set_cur_res(resource_index);
 
-	Widelands::EditorGameBase& egbase = eia().egbase();
-	Widelands::Map* map = egbase.mutable_map();
-	eia().mutable_field_overlay_manager()->register_overlay_callback_function(
-	   [resource_index, map, &egbase](const Widelands::FCoords& fc) -> uint32_t {
-		   if (map->is_resource_valid(egbase.world(), fc, resource_index)) {
-			   return fc.field->nodecaps();
-		   }
-		   return 0;
-		});
-
-	map->recalc_whole_map(egbase.world());
 	select_correct_tool();
 	update();
 }
 
=== modified file 'src/editor/ui_menus/tool_menu.cc'
--- src/editor/ui_menus/tool_menu.cc	2017-08-19 22:22:20 +0000
+++ src/editor/ui_menus/tool_menu.cc	2017-09-13 18:51:31 +0000
@@ -140,13 +140,6 @@
 	}
 
 	parent.select_tool(*current_tool_pointer, EditorTool::First);
-	if (current_tool_pointer == &parent.tools()->set_port_space) {
-		// Set correct overlay
-		Widelands::Map* map = parent.egbase().mutable_map();
-		parent.mutable_field_overlay_manager()->register_overlay_callback_function(
-		   boost::bind(&editor_tool_set_port_space_callback, _1, boost::ref(*map)));
-		map->recalc_whole_map(parent.egbase().world());
-	}
 
 	if (current_registry_pointer) {
 		if (UI::Window* const window = current_registry_pointer->window) {
 
=== modified file 'src/graphic/CMakeLists.txt'
--- src/graphic/CMakeLists.txt	2017-08-28 08:33:02 +0000
+++ src/graphic/CMakeLists.txt	2017-09-13 18:51:31 +0000
@@ -184,7 +184,6 @@
     graphic_surface
     logic
     wui
-    wui_field_overlay_manager
     wui_mapview_pixelfunctions
 )
 
 
=== modified file 'src/graphic/game_renderer.cc'
--- src/graphic/game_renderer.cc	2017-08-29 10:48:24 +0000
+++ src/graphic/game_renderer.cc	2017-09-13 18:51:31 +0000
@@ -29,7 +29,6 @@
 #include "logic/editor_game_base.h"
 #include "logic/map_objects/world/world.h"
 #include "logic/player.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/interactive_base.h"
 #include "wui/mapviewpixelconstants.h"
 #include "wui/mapviewpixelfunctions.h"
 
=== modified file 'src/logic/map.cc'
--- src/logic/map.cc	2017-09-03 09:36:11 +0000
+++ src/logic/map.cc	2017-09-13 18:51:31 +0000
@@ -1770,7 +1770,7 @@
 
 bool Map::is_resource_valid(const Widelands::World& world,
                             const Widelands::FCoords& c,
-                            DescriptionIndex curres) {
+                            DescriptionIndex curres) const {
 	if (curres == Widelands::kNoResource)
 		return true;
 
 
=== modified file 'src/logic/map.h'
--- src/logic/map.h	2017-08-31 10:55:45 +0000
+++ src/logic/map.h	2017-09-13 18:51:31 +0000
@@ -428,7 +428,7 @@
 	 */
 	bool is_resource_valid(const Widelands::World& world,
 	                       const Widelands::FCoords& c,
-	                       DescriptionIndex curres);
+	                       DescriptionIndex curres) const;
 
 	// The objectives that are defined in this map if it is a scenario.
 	const Objectives& objectives() const {
 
=== modified file 'src/wui/CMakeLists.txt'
--- src/wui/CMakeLists.txt	2017-09-04 05:08:56 +0000
+++ src/wui/CMakeLists.txt	2017-09-13 18:51:31 +0000
@@ -24,17 +24,6 @@
     wui
 )
 
-wl_library(wui_field_overlay_manager
-  SRCS
-    field_overlay_manager.cc
-    field_overlay_manager.h
-  DEPENDS
-    base_geometry
-    graphic
-    logic
-    logic_widelands_geometry
-)
-
 wl_library(wui_economy_options
   SRCS
     economy_options_window.cc
@@ -265,7 +254,6 @@
     ui_basic
     wui_chat_ui
     wui_economy_options
-    wui_field_overlay_manager
     wui_mapview
     wui_mapview_pixelfunctions
     wui_quicknavigation
 
=== modified file 'src/wui/buildingwindow.h'
--- src/wui/buildingwindow.h	2017-09-01 09:18:10 +0000
+++ src/wui/buildingwindow.h	2017-09-13 18:51:31 +0000
@@ -28,7 +28,6 @@
 #include "notifications/notifications.h"
 #include "ui_basic/button.h"
 #include "ui_basic/unique_window.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/interactive_gamebase.h"
 #include "wui/waresdisplay.h"
 
 
=== removed file 'src/wui/field_overlay_manager.cc'
--- src/wui/field_overlay_manager.cc	2017-08-16 05:10:15 +0000
+++ src/wui/field_overlay_manager.cc	1970-01-01 00:00:00 +0000
@@ -1,181 +0,0 @@
-/*
- * Copyright (C) 2002-2017 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- */
-
-#include "wui/field_overlay_manager.h"
-
-#include <algorithm>
-
-#include <stdint.h>
-
-#include "graphic/graphic.h"
-#include "logic/field.h"
-
-FieldOverlayManager::FieldOverlayManager() : buildhelp_(false), current_overlay_id_(0) {
-	OverlayInfo* buildhelp_info = buildhelp_infos_;
-	const char* filenames[] = {"images/wui/overlays/set_flag.png", "images/wui/overlays/small.png",
-	                           "images/wui/overlays/medium.png",   "images/wui/overlays/big.png",
-	                           "images/wui/overlays/mine.png",     "images/wui/overlays/port.png"};
-	const char* const* filename = filenames;
-
-	//  Special case for flag, which has a different formula for hotspot_y.
-	buildhelp_info->pic = g_gr->images().get(*filename);
-	buildhelp_info->hotspot =
-	   Vector2i(buildhelp_info->pic->width() / 2, buildhelp_info->pic->height() - 1);
-
-	const OverlayInfo* const buildhelp_infos_end = buildhelp_info + Widelands::Field::Buildhelp_None;
-	for (;;) {  // The other buildhelp overlays.
-		++buildhelp_info;
-		++filename;
-		if (buildhelp_info == buildhelp_infos_end)
-			break;
-		buildhelp_info->pic = g_gr->images().get(*filename);
-		buildhelp_info->hotspot =
-		   Vector2i(buildhelp_info->pic->width() / 2, buildhelp_info->pic->height() / 2);
-	}
-}
-
-bool FieldOverlayManager::buildhelp() const {
-	return buildhelp_;
-}
-
-void FieldOverlayManager::show_buildhelp(const bool value) {
-	buildhelp_ = value;
-}
-
-int FieldOverlayManager::get_buildhelp_overlay(const Widelands::FCoords& fc) const {
-	Widelands::NodeCaps const caps =
-	   callback_ ? static_cast<Widelands::NodeCaps>(callback_(fc)) : fc.field->nodecaps();
-
-	if (caps & Widelands::BUILDCAPS_MINE) {
-		return Widelands::Field::Buildhelp_Mine;
-	}
-	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_BIG) {
-		if (caps & Widelands::BUILDCAPS_PORT) {
-			return Widelands::Field::Buildhelp_Port;
-		}
-		return Widelands::Field::Buildhelp_Big;
-	}
-	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_MEDIUM) {
-		return Widelands::Field::Buildhelp_Medium;
-	}
-	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_SMALL) {
-		return Widelands::Field::Buildhelp_Small;
-	}
-	if (caps & Widelands::BUILDCAPS_FLAG) {
-		return Widelands::Field::Buildhelp_Flag;
-	}
-	return Widelands::Field::Buildhelp_None;
-}
-
-void FieldOverlayManager::register_overlay(const Widelands::Coords& c,
-                                           const Image* pic,
-                                           const OverlayLevel& level,
-                                           Vector2i hotspot,
-                                           OverlayId const overlay_id) {
-	if (hotspot == Vector2i::invalid()) {
-		hotspot = Vector2i(pic->width() / 2, pic->height() / 2);
-	}
-
-	for (auto it = overlays_.find(c); it != overlays_.end() && it->first == c; ++it)
-		if (it->second.pic == pic && it->second.hotspot == hotspot && it->second.level == level) {
-			it->second.overlay_ids.insert(overlay_id);
-			return;
-		}
-
-	overlays_.insert(std::pair<Widelands::Coords const, RegisteredOverlays>(
-	   c, RegisteredOverlays(overlay_id, pic, hotspot, level)));
-
-	//  Now manually sort, so that they are ordered
-	//    * first by c (done by std::multimap)
-	//    * second by levels (done manually here)
-
-	// there is at least one registered
-	auto it = overlays_.lower_bound(c);
-	do {
-		auto jt = it;
-		++jt;
-		if (jt == overlays_.end())
-			break;
-		if (jt->first == it->first) {
-			// There are several overlays registered for this location.
-			if (jt->second.level < it->second.level) {
-				std::swap(it->second, jt->second);
-				it = overlays_.lower_bound(c);
-			} else
-				++it;
-		} else
-			break;  // it is the last element, break this loop.
-	} while (it->first == c);
-}
-
-/**
- * remove one (or many) overlays from a node or triangle
- *
- * @param pic    The overlay to remove. If null, all overlays are removed.
- */
-void FieldOverlayManager::remove_overlay(const Widelands::Coords& c, const Image* pic) {
-	if (overlays_.count(c) == 0) {
-		return;
-	}
-	auto it = overlays_.lower_bound(c);
-	do {
-		if (!pic || it->second.pic == pic) {
-			overlays_.erase(it);
-			it = overlays_.lower_bound(c);
-		} else {
-			++it;
-		}
-	} while (it != overlays_.end() && it->first == c);
-}
-
-void FieldOverlayManager::remove_overlay(const OverlayId overlay_id) {
-	for (auto it = overlays_.begin(); it != overlays_.end();) {
-		it->second.overlay_ids.erase(overlay_id);
-		if (it->second.overlay_ids.empty()) {
-			overlays_.erase(it++);  //  This is necessary!
-		} else {
-			++it;
-		}
-	}
-}
-
-void FieldOverlayManager::remove_all_overlays() {
-	overlays_.clear();
-}
-
-void FieldOverlayManager::register_overlay_callback_function(CallbackFn function) {
-	callback_ = function;
-}
-
-FieldOverlayManager::OverlayId FieldOverlayManager::next_overlay_id() {
-	++current_overlay_id_;
-	return current_overlay_id_;
-}
-
-bool FieldOverlayManager::is_enabled(const OverlayLevel& level) const {
-	return disabled_layers_.count(level) == 0;
-}
-
-void FieldOverlayManager::set_enabled(const OverlayLevel& level, const bool enabled) {
-	if (enabled) {
-		disabled_layers_.erase(level);
-	} else {
-		disabled_layers_.insert(level);
-	}
-}
 
=== removed file 'src/wui/field_overlay_manager.h'
--- src/wui/field_overlay_manager.h	2017-09-01 13:26:55 +0000
+++ src/wui/field_overlay_manager.h	1970-01-01 00:00:00 +0000
@@ -1,172 +0,0 @@
-/*
- * Copyright (C) 2002-2017 by the Widelands Development Team
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- *
- */
-
-#ifndef WL_WUI_FIELD_OVERLAY_MANAGER_H
-#define WL_WUI_FIELD_OVERLAY_MANAGER_H
-
-#include <functional>
-#include <map>
-#include <set>
-#include <vector>
-
-#include "base/vector.h"
-#include "logic/field.h"
-#include "logic/widelands_geometry.h"
-
-class Image;
-
-/*
- * The Overlay Manager is responsible for the map overlays. He
- * manages overlays in the following way:
- *   - When someone registered one (or more) special overlays
- *     for a field he draws them accordingly
- *
- *    about the level variable:
- *     the level describe when the overlay should be drawn, lower means drawn
- *     earlier.
- *
- *    about overlay_id:
- *     the overlay_id can be given to the register function, whenever
- *     the job is finished or canceled, a simple remove_overlay
- *     with the overlay_id can be called and all overlays created in the
- *     job are removed.
- */
-
-// Levels for the overlay registers. This defines in which order they will be
-// drawn. Buildhelp is special and has the value 5, i.e. every smaller will be
-// drawn below the buildhelp, everything higher above.
-// TODO(sirver): no longer used. remove.
-enum class OverlayLevel {};
-
-struct FieldOverlayManager {
-	/// A unique id identifying a registered overlay.
-	using OverlayId = uint32_t;
-
-	/// A function returning Field::nodecaps() for the build overlay. This can be
-	/// registered to hide or change some of the nodecaps during rendering.
-	using CallbackFn = std::function<int32_t(const Widelands::FCoords& coordinates)>;
-
-	FieldOverlayManager();
-
-	/// Returns true if the buildhelp is currently shown.
-	bool buildhelp() const;
-
-	/// Defines if the buildhelp should be shown.
-	void show_buildhelp(bool t);
-
-	/// Register callback function.
-	void register_overlay_callback_function(CallbackFn function);
-
-	/// Like 'buildhelp', but for an individual layer.
-	bool is_enabled(const OverlayLevel& level) const;
-	void set_enabled(const OverlayLevel& level, bool value);
-
-	/// Get a unique, unused id that can be passed to register_overlay.
-	OverlayId next_overlay_id();
-
-	/// Register an overlay at a location (node or triangle). hotspot is the point
-	/// of the picture that will be exactly over the location. If hotspot is
-	/// Vector2i::invalid(), the center of the picture will be used as hotspot.
-	void register_overlay(const Widelands::Coords& coords,
-	                      const Image* pic,
-	                      const OverlayLevel& overlay_level,
-	                      Vector2i hotspot = Vector2i::invalid(),
-	                      OverlayId overlay_id = 0);
-
-	/// removes all overlays when pic is nullptr.
-	void remove_overlay(const Widelands::Coords& coords, const Image* pic);
-
-	/// remove all overlays with this overlay_id
-	void remove_overlay(OverlayId overlay_id);
-
-	/// Removes all overlays.
-	// TODO(sirver): It would be preferable to just delete and recreate the object.
-	void remove_all_overlays();
-
-	/// Calls 'func' for each of the the currently registered and enabled
-	/// overlays and the buildhelp.
-	template <typename T> void foreach_overlay(const Widelands::FCoords& c, T func) const {
-		auto it = overlays_.lower_bound(c);
-		while (it != overlays_.end() && it->first == c &&
-		       static_cast<int>(it->second.level) <= kLevelForBuildHelp) {
-			if (is_enabled(it->second.level)) {
-				func(it->second.pic, it->second.hotspot);
-			}
-			++it;
-		}
-
-		if (buildhelp_) {
-			int buildhelp_overlay_index = get_buildhelp_overlay(c);
-			if (buildhelp_overlay_index < Widelands::Field::Buildhelp_None) {
-				auto& overlay_info = buildhelp_infos_[buildhelp_overlay_index];
-				func(overlay_info.pic, overlay_info.hotspot);
-			}
-		}
-
-		while (it != overlays_.end() && it->first == c) {
-			if (is_enabled(it->second.level)) {
-				func(it->second.pic, it->second.hotspot);
-			}
-			++it;
-		}
-	}
-
-private:
-	static constexpr int kLevelForBuildHelp = 5;
-
-	/// A overlay as drawn onto the screen.
-	struct OverlayInfo {
-		const Image* pic = nullptr;
-		Vector2i hotspot = Vector2i::zero();
-	};
-
-	struct RegisteredOverlays {
-		RegisteredOverlays(const OverlayId init_overlay_id,
-		                   const Image* init_pic,
-		                   const Vector2i init_hotspot,
-		                   const OverlayLevel& init_level)
-		   : pic(init_pic), hotspot(init_hotspot), level(init_level) {
-			overlay_ids.insert(init_overlay_id);
-		}
-		std::set<OverlayId> overlay_ids;
-		const Image* pic;
-		Vector2i hotspot = Vector2i::zero();
-		OverlayLevel level;
-	};
-
-	// Returns the index into buildhelp_infos_ for the correct fieldcaps for
-	// 'fc' according to the current 'callback_'.
-	int get_buildhelp_overlay(const Widelands::FCoords& fc) const;
-
-	std::multimap<const Widelands::Coords, RegisteredOverlays> overlays_;
-
-	OverlayInfo buildhelp_infos_[Widelands::Field::Buildhelp_None];
-	bool buildhelp_;
-	// We are inverting the logic here, since new layers are by default enabled
-	// and we only support to toggle some of them off. Otherwise whenever a new
-	// layer is added in 'OverlayLevel' we would also need to add it to the
-	// 'enabled_layers_' set on construction.
-	std::set<OverlayLevel> disabled_layers_;
-
-	// this callback is used to define where overlays are drawn.
-	CallbackFn callback_;
-	OverlayId current_overlay_id_;
-};
-
-#endif  // end of include guard: WL_WUI_FIELD_OVERLAY_MANAGER_H
 
=== modified file 'src/wui/fieldaction.cc'
--- src/wui/fieldaction.cc	2017-09-03 13:03:56 +0000
+++ src/wui/fieldaction.cc	2017-09-13 18:51:31 +0000
@@ -41,7 +41,6 @@
 #include "wui/actionconfirm.h"
 #include "wui/attack_box.h"
 #include "wui/economy_options_window.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/game_debug_ui.h"
 #include "wui/interactive_player.h"
 #include "wui/waresdisplay.h"
 
=== modified file 'src/wui/interactive_base.cc'
--- src/wui/interactive_base.cc	2017-09-11 19:18:35 +0000
+++ src/wui/interactive_base.cc	2017-09-13 18:51:31 +0000
@@ -46,7 +46,6 @@
 #include "logic/widelands_geometry.h"
 #include "profile/profile.h"
 #include "scripting/lua_interface.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/game_chat_menu.h"
 #include "wui/game_debug_ui.h"
 #include "wui/interactive_player.h"
@@ -56,6 +55,8 @@
 #include "wui/minimap.h"
 #include "wui/unique_window_handler.h"
 
+namespace  {
+
 using Widelands::Area;
 using Widelands::CoordPath;
 using Widelands::Coords;
@@ -65,15 +66,39 @@
 using Widelands::MapObject;
 using Widelands::TCoords;
 
+int caps_to_buildhelp(const Widelands::NodeCaps caps) {
+	if (caps & Widelands::BUILDCAPS_MINE) {
+		return Widelands::Field::Buildhelp_Mine;
+	}
+	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_BIG) {
+		if (caps & Widelands::BUILDCAPS_PORT) {
+			return Widelands::Field::Buildhelp_Port;
+		}
+		return Widelands::Field::Buildhelp_Big;
+	}
+	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_MEDIUM) {
+		return Widelands::Field::Buildhelp_Medium;
+	}
+	if ((caps & Widelands::BUILDCAPS_SIZEMASK) == Widelands::BUILDCAPS_SMALL) {
+		return Widelands::Field::Buildhelp_Small;
+	}
+	if (caps & Widelands::BUILDCAPS_FLAG) {
+		return Widelands::Field::Buildhelp_Flag;
+	}
+	return Widelands::Field::Buildhelp_None;
+}
+
+}  // namespace
+
 InteractiveBase::InteractiveBase(EditorGameBase& the_egbase, Section& global_s)
    : UI::Panel(nullptr, 0, 0, g_gr->get_xres(), g_gr->get_yres()),
      show_workarea_preview_(global_s.get_bool("workareapreview", true)),
+	  buildhelp_(false),
      map_view_(this, the_egbase.map(), 0, 0, g_gr->get_xres(), g_gr->get_yres()),
      // Initialize chatoveraly before the toolbar so it is below
      chat_overlay_(new ChatOverlay(this, 10, 25, get_w() / 2, get_h() - 25)),
      toolbar_(this, 0, 0, UI::Box::Horizontal),
      quick_navigation_(&map_view_),
-     field_overlay_manager_(new FieldOverlayManager()),
      egbase_(the_egbase),
 #ifndef NDEBUG  //  not in releases
      display_flags_(dfDebug),
@@ -94,6 +119,33 @@
                     g_gr->images().get("images/wui/overlays/workarea2.png"),
                     g_gr->images().get("images/wui/overlays/workarea1.png")} {
 
+	// Load the buildhelp icons.
+	{
+		BuildhelpOverlay* buildhelp_overlay = buildhelp_overlays_;
+		const char* filenames[] = {
+		   "images/wui/overlays/set_flag.png", "images/wui/overlays/small.png",
+		   "images/wui/overlays/medium.png",   "images/wui/overlays/big.png",
+		   "images/wui/overlays/mine.png",     "images/wui/overlays/port.png"};
+		const char* const* filename = filenames;
+
+		//  Special case for flag, which has a different formula for hotspot_y.
+		buildhelp_overlay->pic = g_gr->images().get(*filename);
+		buildhelp_overlay->hotspot =
+		   Vector2i(buildhelp_overlay->pic->width() / 2, buildhelp_overlay->pic->height() - 1);
+
+		const BuildhelpOverlay* const buildhelp_overlays_end =
+		   buildhelp_overlay + Widelands::Field::Buildhelp_None;
+		for (;;) {  // The other buildhelp overlays.
+			++buildhelp_overlay;
+			++filename;
+			if (buildhelp_overlay == buildhelp_overlays_end)
+				break;
+			buildhelp_overlay->pic = g_gr->images().get(*filename);
+			buildhelp_overlay->hotspot =
+			   Vector2i(buildhelp_overlay->pic->width() / 2, buildhelp_overlay->pic->height() / 2);
+		}
+	}
+
 	resize_chat_overlay();
 
 	graphic_resolution_changed_subscriber_ = Notifications::subscribe<GraphicResolutionChanged>(
@@ -144,6 +196,15 @@
 	}
 }
 
+const InteractiveBase::BuildhelpOverlay*
+InteractiveBase::get_buildhelp_overlay(const Widelands::NodeCaps caps) const {
+	const int buildhelp_overlay_index = caps_to_buildhelp(caps);
+	if (buildhelp_overlay_index < Widelands::Field::Buildhelp_None) {
+		return &buildhelp_overlays_[buildhelp_overlay_index];
+	}
+	return nullptr;
+}
+
 UniqueWindowHandler& InteractiveBase::unique_windows() {
 	return *unique_window_handler_;
 }
@@ -202,16 +263,16 @@
 }
 
 bool InteractiveBase::buildhelp() const {
-	return field_overlay_manager_->buildhelp();
+	return buildhelp_;
 }
 
 void InteractiveBase::show_buildhelp(bool t) {
-	field_overlay_manager_->show_buildhelp(t);
+	buildhelp_ = t;
 	on_buildhelp_changed(t);
 }
 
 void InteractiveBase::toggle_buildhelp() {
-	show_buildhelp(!field_overlay_manager_->buildhelp());
+	show_buildhelp(!buildhelp());
 }
 
 UI::Button* InteractiveBase::add_toolbar_button(const std::string& image_basename,
 
=== modified file 'src/wui/interactive_base.h'
--- src/wui/interactive_base.h	2017-09-11 14:11:56 +0000
+++ src/wui/interactive_base.h	2017-09-13 18:51:31 +0000
@@ -37,7 +37,6 @@
 #include "ui_basic/unique_window.h"
 #include "wui/chatoverlay.h"
 #include "wui/debugconsole.h"
-#include "wui/field_overlay_manager.h"
 #include "wui/mapview.h"
 #include "wui/minimap.h"
 #include "wui/quicknavigation.h"
@@ -72,6 +71,12 @@
 		std::map<Widelands::Coords, const Image*> steepness_indicators;
 	};
 
+	/// A build help overlay, i.e. small, big, mine, port ...
+	struct BuildhelpOverlay {
+		const Image* pic = nullptr;
+		Vector2i hotspot = Vector2i::zero();
+	};
+
 	// Manages all UniqueWindows.
 	UniqueWindowHandler& unique_windows();
 
@@ -155,13 +160,6 @@
 		log_message(std::string(message));
 	}
 
-	const FieldOverlayManager& field_overlay_manager() const {
-		return *field_overlay_manager_;
-	}
-	FieldOverlayManager* mutable_field_overlay_manager() {
-		return field_overlay_manager_.get();
-	}
-
 	void toggle_minimap();
 	void toggle_buildhelp();
 
@@ -171,10 +169,6 @@
 	// Sets the landmark for the keyboard 'key' to 'point'
 	void set_landmark(size_t key, const MapView::View& view);
 
-	const RoadBuildingOverlays& road_building_overlays() const {
-		return road_building_overlays_;
-	}
-
 	MapView* map_view() {
 		return &map_view_;
 	}
@@ -228,6 +222,14 @@
 	std::map<Widelands::Coords, const Image*>
 	get_work_area_overlays(const Widelands::Map& map) const;
 
+	// Returns the 'BuildhelpOverlay' for 'caps' or nullptr if there is no help
+	// to be displayed on this field.
+	const BuildhelpOverlay* get_buildhelp_overlay(Widelands::NodeCaps caps) const;
+
+	const RoadBuildingOverlays& road_building_overlays() const {
+		return road_building_overlays_;
+	}
+
 private:
 	int32_t stereo_position(Widelands::Coords position_map);
 	void resize_chat_overlay();
@@ -244,18 +246,17 @@
 		              Widelands::Coords(0, 0),
 		              Widelands::TCoords<>(Widelands::Coords(0, 0), Widelands::TriangleIndex::D)},
 		        const uint32_t Radius = 0,
-		        const Image* Pic = nullptr,
-		        const FieldOverlayManager::OverlayId Jobid = 0)
-		   : freeze(Freeze), triangles(Triangles), pos(Pos), radius(Radius), pic(Pic), jobid(Jobid) {
+		        const Image* Pic = nullptr)
+		   : freeze(Freeze), triangles(Triangles), pos(Pos), radius(Radius), pic(Pic) {
 		}
 		bool freeze;     // don't change sel, even if mouse moves
 		bool triangles;  //  otherwise nodes
 		Widelands::NodeAndTriangle<> pos;
 		uint32_t radius;
 		const Image* pic;
-		FieldOverlayManager::OverlayId jobid;
 	} sel_;
 
+	bool buildhelp_;
 	MapView map_view_;
 	ChatOverlay* chat_overlay_;
 
@@ -270,8 +271,6 @@
 	MiniMap::Registry minimap_registry_;
 	QuickNavigation quick_navigation_;
 
-	std::unique_ptr<FieldOverlayManager> field_overlay_manager_;
-
 	// The currently enabled work area previews. They are keyed by the
 	// coordinate that the building that shows the work area is positioned.
 	std::map<Widelands::Coords, const WorkareaInfo*> work_area_previews_;
@@ -293,6 +292,7 @@
 	UI::UniqueWindow::Registry debugconsole_;
 	std::unique_ptr<UniqueWindowHandler> unique_window_handler_;
 	std::vector<const Image*> workarea_pics_;
+	BuildhelpOverlay buildhelp_overlays_[Widelands::Field::Buildhelp_None];
 };
 
 #endif  // end of include guard: WL_WUI_INTERACTIVE_BASE_H
 
=== modified file 'src/wui/interactive_gamebase.cc'
--- src/wui/interactive_gamebase.cc	2017-08-20 17:45:42 +0000
+++ src/wui/interactive_gamebase.cc	2017-09-13 18:51:31 +0000
@@ -137,13 +137,9 @@
  * during single/multiplayer/scenario).
  */
 void InteractiveGameBase::postload() {
-	auto* overlay_manager = mutable_field_overlay_manager();
 	show_buildhelp(false);
 	on_buildhelp_changed(buildhelp());
 
-	overlay_manager->register_overlay_callback_function(
-	   boost::bind(&InteractiveGameBase::calculate_buildcaps, this, _1));
-
 	// Recalc whole map for changed owner stuff
 	egbase().mutable_map()->recalc_whole_map(egbase().world());
 
 
=== modified file 'src/wui/interactive_gamebase.h'
--- src/wui/interactive_gamebase.h	2017-08-28 07:39:59 +0000
+++ src/wui/interactive_gamebase.h	2017-09-13 18:51:31 +0000
@@ -97,7 +97,6 @@
 
 protected:
 	void draw_overlay(RenderTarget&) override;
-	virtual int32_t calculate_buildcaps(const Widelands::FCoords& c) = 0;
 
 	GameMainMenuWindows main_windows_;
 	ChatProvider* chat_provider_;
 
=== modified file 'src/wui/interactive_player.cc'
--- src/wui/interactive_player.cc	2017-09-11 08:22:25 +0000
+++ src/wui/interactive_player.cc	2017-09-13 18:51:31 +0000
@@ -389,9 +389,13 @@
 			}
 		}
 
-		// TODO(sirver): Do not use the field_overlay_manager, instead draw the
-		// overlays we are interested in here directly.
-		field_overlay_manager().foreach_overlay(f->fcoords, blit_overlay);
+		// Draw build help.
+		if (buildhelp()) {
+			const auto* overlay = get_buildhelp_overlay(plr.get_buildcaps(f->fcoords));
+			if (overlay != nullptr) {
+				blit_overlay(overlay->pic, overlay->hotspot);
+			}
+		}
 
 		// Blit the selection marker.
 		if (f->fcoords == get_sel_pos().node) {
@@ -425,11 +429,6 @@
 	return player_number_;
 }
 
-int32_t InteractivePlayer::calculate_buildcaps(const Widelands::FCoords& c) {
-	assert(get_player());
-	return get_player()->get_buildcaps(c);
-}
-
 /// Player has clicked on the given node; bring up the context menu.
 void InteractivePlayer::node_action(const Widelands::NodeAndTriangle<>& node_and_triangle) {
 	const Map& map = egbase().map();
 
=== modified file 'src/wui/interactive_player.h'
--- src/wui/interactive_player.h	2017-08-28 07:39:59 +0000
+++ src/wui/interactive_player.h	2017-09-13 18:51:31 +0000
@@ -78,7 +78,6 @@
 	}
 
 	void popup_message(Widelands::MessageId, const Widelands::Message&);
-	int32_t calculate_buildcaps(const Widelands::FCoords& c) override;
 
 private:
 	void cmdSwitchPlayer(const std::vector<std::string>& args);
 
=== modified file 'src/wui/interactive_spectator.cc'
--- src/wui/interactive_spectator.cc	2017-09-01 13:26:55 +0000
+++ src/wui/interactive_spectator.cc	2017-09-13 18:51:31 +0000
@@ -117,27 +117,27 @@
 	assert(get_sel_radius() == 0);
 	assert(!get_sel_triangles());
 
-	const auto& gbase = egbase();
-	auto* fields_to_draw = given_map_view->draw_terrain(gbase, dst);
+	const Widelands::Game& the_game = game();
+	const Widelands::Map& map = the_game.map();
+	auto* fields_to_draw = given_map_view->draw_terrain(the_game, dst);
 	const float scale = 1.f / given_map_view->view().zoom;
-	const uint32_t gametime = gbase.get_gametime();
+	const uint32_t gametime = the_game.get_gametime();
 
 	const auto text_to_draw = get_text_to_draw();
-	const std::map<Widelands::Coords, const Image*> work_area_overlays =
-	   get_work_area_overlays(gbase.map());
+	const std::map<Widelands::Coords, const Image*> work_area_overlays = get_work_area_overlays(map);
 	for (size_t idx = 0; idx < fields_to_draw->size(); ++idx) {
 		const FieldsToDraw::Field& field = fields_to_draw->at(idx);
 
 		draw_border_markers(field, scale, *fields_to_draw, dst);
 
 		Widelands::BaseImmovable* const imm = field.fcoords.field->get_immovable();
-		if (imm != nullptr && imm->get_positions(gbase).front() == field.fcoords) {
+		if (imm != nullptr && imm->get_positions(the_game).front() == field.fcoords) {
 			imm->draw(gametime, text_to_draw, field.rendertarget_pixel, scale, dst);
 		}
 
 		for (Widelands::Bob* bob = field.fcoords.field->get_first_bob(); bob;
 		     bob = bob->get_next_bob()) {
-			bob->draw(gbase, text_to_draw, field.rendertarget_pixel, scale, dst);
+			bob->draw(the_game, text_to_draw, field.rendertarget_pixel, scale, dst);
 		}
 
 		const auto blit_overlay = [dst, &field, scale](const Image* pic, const Vector2i& hotspot) {
@@ -147,15 +147,29 @@
 			                    BlendMode::UseAlpha);
 		};
 
+		// Draw work area previews.
 		const auto it = work_area_overlays.find(field.fcoords);
 		if (it != work_area_overlays.end()) {
 			const Image* pic = it->second;
 			blit_overlay(pic, Vector2i(pic->width() / 2, pic->height() / 2));
 		}
 
-		// TODO(sirver): Do not use the field_overlay_manager, instead draw the
-		// overlays we are interested in here directly.
-		field_overlay_manager().foreach_overlay(field.fcoords, blit_overlay);
+		// Draw build help.
+		if (buildhelp()) {
+			auto caps = Widelands::NodeCaps::CAPS_NONE;
+			const Widelands::PlayerNumber nr_players = map.get_nrplayers();
+			iterate_players_existing(p, nr_players, the_game, player) {
+				const Widelands::NodeCaps nc = player->get_buildcaps(field.fcoords);
+				if (nc > Widelands::NodeCaps::CAPS_NONE) {
+					caps = nc;
+					break;
+				}
+			}
+			const auto* overlay = get_buildhelp_overlay(caps);
+			if (overlay != nullptr) {
+				blit_overlay(overlay->pic, overlay->hotspot);
+			}
+		}
 
 		// Blit the selection marker.
 		if (field.fcoords == get_sel_pos().node) {
@@ -175,17 +189,6 @@
 	return nullptr;
 }
 
-int32_t InteractiveSpectator::calculate_buildcaps(const Widelands::FCoords& c) {
-	const Widelands::PlayerNumber nr_players = game().map().get_nrplayers();
-	iterate_players_existing(p, nr_players, game(), player) {
-		const Widelands::NodeCaps nc = player->get_buildcaps(c);
-		if (nc > Widelands::NodeCaps::CAPS_NONE) {
-			return nc;
-		}
-	}
-	return Widelands::NodeCaps::CAPS_NONE;
-}
-
 // Toolbar button callback functions.
 void InteractiveSpectator::exit_btn() {
 	if (is_multiplayer()) {
 
=== modified file 'src/wui/interactive_spectator.h'
--- src/wui/interactive_spectator.h	2017-08-28 07:39:59 +0000
+++ src/wui/interactive_spectator.h	2017-09-13 18:51:31 +0000
@@ -48,7 +48,6 @@
 
 private:
 	void exit_btn();
-	int32_t calculate_buildcaps(const Widelands::FCoords& c) override;
 	bool can_see(Widelands::PlayerNumber) const override;
 	bool can_act(Widelands::PlayerNumber) const override;
 	Widelands::PlayerNumber player_number() const override;