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

[Benedikt Straub]

Allow players to define settings for and to enhance buildings under construction

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 4971. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/532431388.
Appveyor build 4752. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4752.

[Toni Förster (stonerl)]

I get these compiler warnings a couple of times.

/Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/building_settings.h:42:8: warning: 'Widelands::BuildingSettings' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
struct BuildingSettings {
       ^
/Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/building_settings.h:57:8: warning: 'Widelands::ProductionsiteSettings' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
struct ProductionsiteSettings : public BuildingSettings {
       ^
/Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/building_settings.h:74:8: warning: 'Widelands::MilitarysiteSettings' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
struct MilitarysiteSettings : public BuildingSettings {
       ^
/Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/building_settings.h:86:8: warning: 'Widelands::TrainingsiteSettings' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
struct TrainingsiteSettings : public ProductionsiteSettings {
       ^
/Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/building_settings.h:97:8: warning: 'Widelands::WarehouseSettings' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]
struct WarehouseSettings : public BuildingSettings {
       ^
5 warnings generated.

[Toni Förster (stonerl)]

Some comments regarding the UI.

I think we should keep the UI consistent. Instead of checkboxes please use the icons/buttons that are used in the building's window. The same applies for the priority settings. We use traffic lights instead of buttons.

[Benedikt Straub (nordfriese)]

Fixed the compiler warnings and made the UI design consistent. I did not convert the Stop and Launch Expedition to toggle-buttons though because it is never clear with such buttons whether the icon shows the current state or the action taken by clicking it IMHO.

By the way, when clicking the Enhance button, the window will annoyingly switch to the first tab – this is unrelated to this branch, see bug 1818857.

[Toni Förster (stonerl)]

hmm. I would prefer icons but you are completely right. I opened a topic in the forum:

https://wl.widelands.org/forum/topic/4518/?page=1#post-27957

[Toni Förster (stonerl)]

Four warnings left:

src/logic/playercommand.cc:2288:6: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]
                                        default:

src/logic/playercommand.cc:2384:6: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]
                                        default:

src/wui/constructionsitewindow.cc:197:3: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]
                default:

src/logic/map_objects/tribes/building_settings.cc:176:5: warning: default label in switch which covers all enumeration values [-Wcovered-switch-default]
                                default:

[Toni Förster (stonerl)]

Your buttons are a little too big. The buttons for in-/decreasing the wares are 24x24 while yours are 25x30.

Also, some wares are covered by the button; see the fish in the tavern (I guess that is because of your buttons being to big)

[Toni Förster (stonerl)]

With this branch I get crashes after a while. Not sure if the culprit is this branch or something in trunk, though.

/Users/toni/Launchpad/widelands-repo/working_tree/src/graphic/animation.cc:451] Requested unknown animation with id: -432781024
==54196==ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x000000000000 bp 0x7ffee6344650 sp 0x7ffee63445a8 T0)

[Benedikt Straub (nordfriese)]

Took care of the warnings and fixed the input queue layout.

> src/graphic/animation.cc:451] Requested unknown animation with id: -432781024

A backtrace would be helpful…
Did you get this while an (enhanced?) constructionsite was being built, or when a constructionsite was being completed? I got similar crashes before, but I thought I had caught all corner cases now…

[Toni Förster (stonerl)]

Assertion failed: (military_site_->capacity_ != capacity), function set_soldier_capacity, file /Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/militarysite.cc, line 85.

[Benedikt Straub (nordfriese)]

Assert fail fixed :)

[kaputtnik (franku)]

Looks like this branch breaks savegame compatibility. When trying to load a game which runs fine in trunk i get:

Writing Buildingdata Data ... widelands: /home/kaputtnik/Quellcode/widelands-repo/constructionsite_options/src/map_io/map_buildingdata_packet.cc:974: void Widelands::MapBuildingdataPacket::write_constructionsite(const Widelands::ConstructionSite&, FileWrite&, Widelands::Game&, Widelands::MapObjectSaver&): Assertion `constructionsite.settings_' failed.
Abgebrochen (Speicherabzug geschrieben)

[Benedikt Straub (nordfriese)]

Oops… should be fixed now

[Toni Förster (stonerl)]

And another assertion.

Assertion failed: (animation_index < animations.size()), function draw, file /Users/toni/Launchpad/widelands-repo/working_tree/src/logic/map_objects/tribes/constructionsite.cc, line 85.

[Benedikt Straub (nordfriese)]

This seems to be the same issue as the crash with animation ID -432781024, but with a more usable file&line number. Will push a fix soonish

[Benedikt Straub (nordfriese)]

Since the bug is not reproducible, I can´t be certain, but it should most likely be gone now

[Toni Förster (stonerl)]

Seems to be fixed.

[kaputtnik (franku)]

Trying to load a savgame from trunk prints now in a window (and console):

Game data error
buildingdata: building 524547: not found

Loading in trunk works fine. Save game: https://bugs.launchpad.net/widelands/+bug/1597310/+attachment/5264357/+files/construction_site_settings.wgf

[GunChleoc (gunchleoc)]

I am getting a similar error when loading our homepage reference screenshot savegame Build, so we already have a change to saveloading in trunk where we overlooked having to increase the packet number.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 5003. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/533470509.
Appveyor build 4784. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4784.

[Toni Förster (stonerl)]

Would it be possible to move the tabs for Warehouses' and Ports' to the top, instead of having to tab rows?

[Benedikt Straub (nordfriese)]

OK, will change it like this

[GunChleoc (gunchleoc)]

It would be nice if the tab was remembered after using the "enhance" button.

The target of the help button does not get updated when enhancing, e.g. construction site for deeper coal mine will show the coal mine instead.

"Launch expedition" should be "Start an expedition" like on the button for the finished port.

It would be nice if the extra options like "Start an expedition" or "Stop" would have the same UI buttons as the finished sites. I can live with the checkboxes though.

[GunChleoc (gunchleoc)]

Also, this:

=================================================================
==6265==ERROR: LeakSanitizer: detected memory leaks

Direct leak of 2744 byte(s) in 49 object(s) allocated from:
    #0 0x7ff86f576458 in operator new(unsigned long) (/usr/lib/x86_64-linux-gnu/libasan.so.4+0xe0458)
    #1 0x55643637edfd in Widelands::MilitarySite::create_building_settings() const ../src/logic/map_objects/tribes/militarysite.cc:978
    #2 0x556435cb4c9b in Widelands::Player::enhance_or_dismantle(Widelands::Building*, unsigned char) ../src/logic/player.cc:763
    #3 0x556435cb47a3 in Widelands::Player::dismantle_building(Widelands::Building*) ../src/logic/player.cc:743
    #4 0x5564366afc07 in Widelands::CmdDismantleBuilding::execute(Widelands::Game&) ../src/logic/playercommand.cc:701
    #5 0x5564366a690e in Widelands::CmdQueue::run_queue(int, unsigned int&) ../src/logic/cmd_queue.cc:122
    #6 0x556435c8be44 in Widelands::Game::think() ../src/logic/game.cc:599
    #7 0x55643605fe76 in InteractiveBase::think() ../src/wui/interactive_base.cc:475
    #8 0x5564360b3bde in InteractivePlayer::think() ../src/wui/interactive_player.cc:228
    #9 0x556435eec265 in UI::Panel::do_think() ../src/ui_basic/panel.cc:483
    #10 0x556435ee95ca in UI::Panel::do_run() ../src/ui_basic/panel.cc:184
    #11 0x556435983b5d in UI::Panel::Returncodes UI::Panel::run<UI::Panel::Returncodes>() ../src/ui_basic/panel.h:104
    #12 0x556435c8b669 in Widelands::Game::run(UI::ProgressWindow*, Widelands::Game::StartGameType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&) ../src/logic/game.cc:569
    #13 0x55643596f976 in WLApplication::new_game() ../src/wlapplication.cc:1354
    #14 0x55643596da4a in WLApplication::mainmenu_singleplayer() ../src/wlapplication.cc:1208
    #15 0x55643596cb95 in WLApplication::mainmenu() ../src/wlapplication.cc:1114
    #16 0x556435963b7b in WLApplication::run() ../src/wlapplication.cc:470
    #17 0x55643595f8ce in main ../src/main.cc:44
    #18 0x7ff86c9a9b96 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21b96)

[Benedikt Straub (nordfriese)]

> "Launch expedition" should be "Start an expedition" like on the button for the finished port.
> The target of the help button does not get updated when enhancing, e.g. construction site for deeper coal mine will show the coal mine instead.
> ASan

Should all be fixed now

> It would be nice if the tab was remembered after using the "enhance" button.

This is exactly the same as bug 1818857 so it should be fixed independent from this branch. There will likely be one catch-all fix for both flavours of the bug.

> It would be nice if the extra options like "Start an expedition" or "Stop" would have the same UI buttons as the finished sites. I can live with the checkboxes though.

What I could do is to render the appropriate icon next to the checkbox if you like. But unless we change the other UI elements in such a way that they show clearly what the current state is, there is no alternative to the checkboxes IMHO, since the current icons are only acceptable because one can see the active state elsewhere (stats string / expedition tab), which can not happen here.

[GunChleoc (gunchleoc)]

OK, let's leave the design as it is :)

This doesn't compile:

ow.cc.o -c ../src/wui/dismantlesitewindow.cc
In file included from ../src/wui/dismantlesitewindow.h:25:0,
                 from ../src/wui/dismantlesitewindow.cc:20:
../src/wui/buildingwindow.h: In member function ‘void BuildingWindow::set_building_descr_for_help(const Widelands::BuildingDescr&)’:
../src/wui/buildingwindow.h:99:30: error: ‘void Widelands::BuildingDescr::operator=(const Widelands::BuildingDescr&)’ is private within this context
   building_descr_for_help_ = d;
                              ^

Once that has been fixed, we still need to look at the code.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 5074. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/538200870.
Appveyor build 4854. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4854.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 5076. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/538299033.
Appveyor build 4856. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4856.

[GunChleoc (gunchleoc)]

I finally got around to doing the code review. This branch still has a lot of room for streamlining the code and the performance.

review: Needs Fixing

[Benedikt Straub (nordfriese)]

Implemented your comments

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 5185. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/544759817.
Appveyor build 4965. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4965.

[GunChleoc (gunchleoc)]

The changes look good - there are still some open comments, though. Sorry it took me a while to get back to this.

[Benedikt Straub (nordfriese)]

No problem. I have very little time for Widelands at the moment anyway :)

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 5203. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/547642295.
Appveyor build 4982. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_constructionsite_options-4982.

[GunChleoc (gunchleoc)]

LGTM now :)

I'd like to retest this due to the code changes made during review.

review: Approve

[GunChleoc (gunchleoc)]

Tested and still working - thanks for this great feature!

@bunnybot merge

[bunnybot (widelandsofficial)]

Refusing to merge, since Travis is not green. Use @bunnybot merge force for merging anyways.

Travis build 5203. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/547642295.

[GunChleoc (gunchleoc)]

inputqueues again

@bunnybot merge force

[bunnybot (widelandsofficial)]

Error merging this proposal:

Output:
stdout:

stderr:
Unable to obtain lock held by <email address hidden> on taotie (process #21580), acquired 19 hours, 2 minutes ago.
See "bzr help break-lock" for more.
bzr: ERROR: Could not acquire lock "(remote lock)": bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/trunk/

[GunChleoc (gunchleoc)]

@bunnybot merge force

=== modified file 'src/ai/defaultai_seafaring.cc'
--- src/ai/defaultai_seafaring.cc	2019-02-23 11:00:49 +0000
+++ src/ai/defaultai_seafaring.cc	2019-06-19 09:23:26 +0000
@@ -346,7 +346,7 @@
 				if (site->bo->is(BuildingAttribute::kShipyard)) {
 					for (uint32_t k = 0; k < site->bo->inputs.size(); ++k) {
 						game().send_player_set_ware_priority(
-						   *site->site, wwWARE, site->bo->inputs.at(k), HIGH_PRIORITY);
+						   *site->site, wwWARE, site->bo->inputs.at(k), kPriorityHigh);
 					}
 				}
 			}

=== modified file 'src/economy/economy.cc'
--- src/economy/economy.cc	2019-04-09 16:43:49 +0000
+++ src/economy/economy.cc	2019-06-19 09:23:26 +0000
@@ -971,7 +971,7 @@
 static bool accept_warehouse_if_policy(Warehouse& wh,
                                        WareWorker type,
                                        DescriptionIndex ware,
-                                       Warehouse::StockPolicy policy) {
+                                       StockPolicy policy) {
 	return wh.get_stock_policy(type, ware) == policy;
 }
 
@@ -1005,8 +1005,8 @@
 
 		for (uint32_t nwh = 0; nwh < warehouses_.size(); ++nwh) {
 			Warehouse* wh = warehouses_[nwh];
-			Warehouse::StockPolicy policy = wh->get_stock_policy(type, ware);
-			if (policy == Warehouse::StockPolicy::kPrefer) {
+			StockPolicy policy = wh->get_stock_policy(type, ware);
+			if (policy == StockPolicy::kPrefer) {
 				haveprefer = true;
 
 				// Getting count of worker/ware
@@ -1022,7 +1022,7 @@
 					preferred_wh_stock = current_stock;
 				}
 			}
-			if (policy == Warehouse::StockPolicy::kNormal)
+			if (policy == StockPolicy::kNormal)
 				havenormal = true;
 		}
 		if (!havenormal && !haveprefer && type == wwWARE)
@@ -1037,7 +1037,7 @@
 			                            (!havenormal) ?
 			                               WarehouseAcceptFn() :
 			                               boost::bind(&accept_warehouse_if_policy, _1, type, ware,
-			                                           Warehouse::StockPolicy::kNormal));
+			                                           StockPolicy::kNormal));
 		}
 		if (!wh) {
 			log("Warning: Economy::handle_active_supplies "

=== modified file 'src/economy/request.cc'
--- src/economy/request.cc	2019-06-13 17:32:28 +0000
+++ src/economy/request.cc	2019-06-19 09:23:26 +0000
@@ -266,7 +266,7 @@
 int32_t Request::get_priority(int32_t cost) const {
 	int MAX_IDLE_PRIORITY = 100;
 	bool is_construction_site = false;
-	int32_t modifier = DEFAULT_PRIORITY;
+	int32_t modifier = kPriorityNormal;
 
 	if (target_building_) {
 		modifier = target_building_->get_priority(get_type(), get_index());

=== modified file 'src/logic/editor_game_base.cc'
--- src/logic/editor_game_base.cc	2019-04-26 05:52:49 +0000
+++ src/logic/editor_game_base.cc	2019-06-19 09:23:26 +0000
@@ -38,6 +38,7 @@
 #include "logic/map_objects/map_object.h"
 #include "logic/map_objects/tribes/battle.h"
 #include "logic/map_objects/tribes/building.h"
+#include "logic/map_objects/tribes/constructionsite.h"
 #include "logic/map_objects/tribes/dismantlesite.h"
 #include "logic/map_objects/tribes/tribe_descr.h"
 #include "logic/map_objects/tribes/tribes.h"
@@ -349,10 +350,15 @@
                                                 PlayerNumber const owner,
                                                 DescriptionIndex idx,
                                                 bool loading,
-                                                Building::FormerBuildings former_buildings) {
+                                                Building::FormerBuildings former_buildings,
+                                                const BuildingSettings* settings) {
 	Player* plr = get_player(owner);
 	const TribeDescr& tribe = plr->tribe();
-	return tribe.get_building_descr(idx)->create(*this, plr, c, true, loading, former_buildings);
+	Building& b = tribe.get_building_descr(idx)->create(*this, plr, c, true, loading, former_buildings);
+	if (settings) {
+		dynamic_cast<ConstructionSite&>(b).apply_settings(*settings);
+	}
+	return b;
 }
 
 /**

=== modified file 'src/logic/editor_game_base.h'
--- src/logic/editor_game_base.h	2019-02-27 19:00:36 +0000
+++ src/logic/editor_game_base.h	2019-06-19 09:23:26 +0000
@@ -56,6 +56,7 @@
 class TribeDescr;
 struct Flag;
 struct AttackController;
+struct BuildingSettings;
 
 struct NoteFieldPossession {
 	CAN_BE_SENT_AS_NOTE(NoteId::FieldPossession)
@@ -130,7 +131,8 @@
 	                      PlayerNumber,
 	                      DescriptionIndex,
 	                      bool loading = false,
-	                      Building::FormerBuildings former_buildings = Building::FormerBuildings());
+	                      Building::FormerBuildings former_buildings = Building::FormerBuildings(),
+	                      const BuildingSettings* settings = nullptr);
 	Building&
 	warp_dismantlesite(const Coords&,
 	                   PlayerNumber,

=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2019-05-25 07:36:44 +0000
+++ src/logic/game.cc	2019-06-19 09:23:26 +0000
@@ -56,6 +56,7 @@
 #include "logic/map_objects/tribes/soldier.h"
 #include "logic/map_objects/tribes/trainingsite.h"
 #include "logic/map_objects/tribes/tribe_descr.h"
+#include "logic/map_objects/tribes/warehouse.h"
 #include "logic/player.h"
 #include "logic/playercommand.h"
 #include "logic/replay.h"
@@ -775,8 +776,7 @@
 }
 
 void Game::send_player_enhance_building(Building& building, DescriptionIndex const id) {
-	assert(building.owner().tribe().has_building(id));
-
+	assert(building.descr().type() == MapObjectType::CONSTRUCTIONSITE || building.owner().tribe().has_building(id));
 	send_player_command(
 	   new CmdEnhanceBuilding(get_gametime(), building.owner().player_number(), building, id));
 }
@@ -858,6 +858,11 @@
 	   new CmdProposeTrade(get_gametime(), object->get_owner()->player_number(), trade));
 }
 
+void Game::send_player_set_stock_policy(Building& imm, WareWorker ww, DescriptionIndex di, StockPolicy sp) {
+	send_player_command(new CmdSetStockPolicy(get_gametime(), imm.get_owner()->player_number(),
+			imm, ww == wwWORKER, di, sp));
+}
+
 int Game::propose_trade(const Trade& trade) {
 	// TODO(sirver,trading): Check if a trade is possible (i.e. if there is a
 	// path between the two markets);

=== modified file 'src/logic/game.h'
--- src/logic/game.h	2019-05-25 07:36:44 +0000
+++ src/logic/game.h	2019-06-19 09:23:26 +0000
@@ -46,6 +46,7 @@
 // See forester_cache_
 constexpr int16_t kInvalidForesterEntry = -1;
 
+class ConstructionSite;
 struct Flag;
 struct Path;
 struct PlayerImmovable;
@@ -56,6 +57,7 @@
 struct PlayerEndStatus;
 class TrainingSite;
 class MilitarySite;
+enum class StockPolicy;
 
 enum {
 	gs_notrunning = 0,  // game is being prepared
@@ -262,6 +264,7 @@
 
 	void send_player_enhance_building(Building&, DescriptionIndex);
 	void send_player_evict_worker(Worker&);
+	void send_player_set_stock_policy(Building&, WareWorker, DescriptionIndex, StockPolicy);
 	void send_player_set_ware_priority(PlayerImmovable&,
 	                                   int32_t type,
 	                                   DescriptionIndex index,

=== modified file 'src/logic/map_objects/CMakeLists.txt'
--- src/logic/map_objects/CMakeLists.txt	2019-05-12 07:45:59 +0000
+++ src/logic/map_objects/CMakeLists.txt	2019-06-19 09:23:26 +0000
@@ -49,6 +49,8 @@
     tribes/bill_of_materials.h
     tribes/building.cc
     tribes/building.h
+    tribes/building_settings.cc
+    tribes/building_settings.h
     tribes/carrier.cc
     tribes/carrier.h
     tribes/constructionsite.cc

=== modified file 'src/logic/map_objects/tribes/bill_of_materials.h'
--- src/logic/map_objects/tribes/bill_of_materials.h	2019-02-23 11:00:49 +0000
+++ src/logic/map_objects/tribes/bill_of_materials.h	2019-06-19 09:23:26 +0000
@@ -28,29 +28,6 @@
 using WareAmount = std::pair<DescriptionIndex, Widelands::Quantity>;
 using BillOfMaterials = std::vector<WareAmount>;
 
-// range structure for iterating ware range with index
-struct WareRange {
-	explicit WareRange(const BillOfMaterials& range)
-	   : i(0), current(range.begin()), end(range.end()) {
-	}
-	WareRange& operator++() {
-		++i;
-		++current;
-		return *this;
-	}
-	bool empty() const {
-		return current == end;
-	}
-	operator bool() const {
-		return !empty();
-	}
-
-	uint8_t i;
-	BillOfMaterials::const_iterator current;
-
-private:
-	BillOfMaterials::const_iterator const end;
-};
 }  // namespace Widelands
 
 #endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_TRIBES_BILL_OF_MATERIALS_H

=== modified file 'src/logic/map_objects/tribes/building.cc'
--- src/logic/map_objects/tribes/building.cc	2019-05-26 17:21:15 +0000
+++ src/logic/map_objects/tribes/building.cc	2019-06-19 09:23:26 +0000
@@ -638,13 +638,13 @@
 
 int32_t
 Building::get_priority(WareWorker type, DescriptionIndex const ware_index, bool adjust) const {
-	int32_t priority = DEFAULT_PRIORITY;
+	int32_t priority = kPriorityNormal;
 	if (type == wwWARE) {
 		// if priority is defined for specific ware,
 		// combine base priority and ware priority
 		std::map<DescriptionIndex, int32_t>::const_iterator it = ware_priorities_.find(ware_index);
 		if (it != ware_priorities_.end())
-			priority = adjust ? (priority * it->second / DEFAULT_PRIORITY) : it->second;
+			priority = adjust ? (priority * it->second / kPriorityNormal) : it->second;
 	}
 
 	return priority;
@@ -660,7 +660,7 @@
 	std::map<DescriptionIndex, int32_t>& ware_priorities = p[wwWARE];
 	std::map<DescriptionIndex, int32_t>::const_iterator it;
 	for (it = ware_priorities_.begin(); it != ware_priorities_.end(); ++it) {
-		if (it->second == DEFAULT_PRIORITY)
+		if (it->second == kPriorityNormal)
 			continue;
 		ware_priorities[it->first] = it->second;
 	}

=== modified file 'src/logic/map_objects/tribes/building.h'
--- src/logic/map_objects/tribes/building.h	2019-05-11 12:37:45 +0000
+++ src/logic/map_objects/tribes/building.h	2019-06-19 09:23:26 +0000
@@ -31,6 +31,7 @@
 #include "logic/map_objects/buildcost.h"
 #include "logic/map_objects/immovable.h"
 #include "logic/map_objects/tribes/attack_target.h"
+#include "logic/map_objects/tribes/building_settings.h"
 #include "logic/map_objects/tribes/bill_of_materials.h"
 #include "logic/map_objects/tribes/soldiercontrol.h"
 #include "logic/map_objects/tribes/wareworker.h"
@@ -51,9 +52,9 @@
 
 class Building;
 
-#define LOW_PRIORITY 2
-#define DEFAULT_PRIORITY 4
-#define HIGH_PRIORITY 8
+constexpr int32_t kPriorityLow = 2;
+constexpr int32_t kPriorityNormal = 4;
+constexpr int32_t kPriorityHigh = 8;
 
 /*
  * Common to all buildings!
@@ -266,8 +267,8 @@
 
 	// Get/Set the priority for this waretype for this building. 'type' defines
 	// if this is for a worker or a ware, 'index' is the type of worker or ware.
-	// If 'adjust' is false, the three possible states HIGH_PRIORITY,
-	// DEFAULT_PRIORITY and LOW_PRIORITY are returned, otherwise numerical
+	// If 'adjust' is false, the three possible states kPriorityHigh,
+	// kPriorityNormal and kPriorityLow are returned, otherwise numerical
 	// values adjusted to the preciousness of the ware in general are returned.
 	virtual int32_t get_priority(WareWorker type, DescriptionIndex, bool adjust = true) const;
 	void set_priority(int32_t type, DescriptionIndex ware_index, int32_t new_priority);
@@ -301,6 +302,10 @@
 	void add_worker(Worker&) override;
 	void remove_worker(Worker&) override;
 
+	virtual const BuildingSettings* create_building_settings() const {
+		return nullptr;
+	}
+
 	// AttackTarget object associated with this building. If the building can
 	// never be attacked (for example productionsites) this will be nullptr.
 	const AttackTarget* attack_target() const {

=== added file 'src/logic/map_objects/tribes/building_settings.cc'
--- src/logic/map_objects/tribes/building_settings.cc	1970-01-01 00:00:00 +0000
+++ src/logic/map_objects/tribes/building_settings.cc	2019-06-19 09:23:26 +0000
@@ -0,0 +1,346 @@
+/*
+ * Copyright (C) 2002-2019 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 "logic/map_objects/tribes/building_settings.h"
+
+#include "io/fileread.h"
+#include "io/filewrite.h"
+#include "logic/game.h"
+#include "logic/game_data_error.h"
+#include "logic/map_objects/tribes/militarysite.h"
+#include "logic/map_objects/tribes/productionsite.h"
+#include "logic/map_objects/tribes/trainingsite.h"
+#include "logic/map_objects/tribes/tribe_descr.h"
+#include "logic/map_objects/tribes/warehouse.h"
+
+namespace Widelands {
+
+ProductionsiteSettings::ProductionsiteSettings(const ProductionSiteDescr& descr)
+		: BuildingSettings(descr.name()), stopped(false) {
+	for (const auto& pair : descr.input_wares()) {
+		ware_queues.push_back(std::make_pair(pair.first,
+				InputQueueSetting{pair.second, pair.second, kPriorityNormal}));
+	}
+	for (const auto& pair : descr.input_workers()) {
+		worker_queues.push_back(std::make_pair(pair.first,
+				InputQueueSetting{pair.second, pair.second, kPriorityNormal}));
+	}
+}
+
+MilitarysiteSettings::MilitarysiteSettings(const MilitarySiteDescr& descr)
+		: BuildingSettings(descr.name()),
+	  max_capacity(descr.get_max_number_of_soldiers()),
+	  desired_capacity(descr.get_max_number_of_soldiers()),
+	  prefer_heroes(descr.prefers_heroes_at_start_) {
+}
+
+TrainingsiteSettings::TrainingsiteSettings(const TrainingSiteDescr& descr)
+	: ProductionsiteSettings(descr),
+	  max_capacity(descr.get_max_number_of_soldiers()),
+	  desired_capacity(descr.get_max_number_of_soldiers()) {
+}
+
+WarehouseSettings::WarehouseSettings(const WarehouseDescr& wh, const TribeDescr& tribe)
+		: BuildingSettings(wh.name()), launch_expedition_allowed(wh.get_isport()), launch_expedition(false) {
+	for (const DescriptionIndex di : tribe.wares()) {
+		ware_preferences.emplace(di, StockPolicy::kNormal);
+	}
+	for (const DescriptionIndex di : tribe.workers()) {
+		worker_preferences.emplace(di, StockPolicy::kNormal);
+	}
+	for (const DescriptionIndex di : tribe.worker_types_without_cost()) {
+		worker_preferences.erase(di);
+	}
+}
+
+void ProductionsiteSettings::apply(const BuildingSettings& bs) {
+	BuildingSettings::apply(bs);
+	if (upcast(const ProductionsiteSettings, s, &bs)) {
+		stopped = s->stopped;
+		for (auto& pair : ware_queues) {
+			for (const auto& other : s->ware_queues) {
+				if (pair.first == other.first) {
+					pair.second.priority = other.second.priority;
+					pair.second.desired_fill = std::min(pair.second.max_fill, other.second.desired_fill);
+					break;
+				}
+			}
+		}
+		for (auto& pair : worker_queues) {
+			for (const auto& other : s->worker_queues) {
+				if (pair.first == other.first) {
+					pair.second.priority = other.second.priority;
+					pair.second.desired_fill = std::min(pair.second.max_fill, other.second.desired_fill);
+					break;
+				}
+			}
+		}
+	}
+}
+
+void TrainingsiteSettings::apply(const BuildingSettings& bs) {
+	ProductionsiteSettings::apply(bs);
+	if (upcast(const TrainingsiteSettings, s, &bs)) {
+		desired_capacity = std::min(max_capacity, s->desired_capacity);
+	}
+}
+
+void MilitarysiteSettings::apply(const BuildingSettings& bs) {
+	BuildingSettings::apply(bs);
+	if (upcast(const MilitarysiteSettings, s, &bs)) {
+		desired_capacity = std::min(max_capacity, s->desired_capacity);
+		prefer_heroes = s->prefer_heroes;
+	}
+}
+
+void WarehouseSettings::apply(const BuildingSettings& bs) {
+	BuildingSettings::apply(bs);
+	if (upcast(const WarehouseSettings, s, &bs)) {
+		for (auto& pair : ware_preferences) {
+			const auto it = s->ware_preferences.find(pair.first);
+			if (it != s->ware_preferences.end()) {
+				pair.second = it->second;
+			}
+		}
+		for (auto& pair : worker_preferences) {
+			const auto it = s->worker_preferences.find(pair.first);
+			if (it != s->worker_preferences.end()) {
+				pair.second = it->second;
+			}
+		}
+		launch_expedition = launch_expedition_allowed && s->launch_expedition;
+	}
+}
+
+// Saveloading
+
+constexpr uint8_t kCurrentPacketVersion = 1;
+constexpr uint8_t kCurrentPacketVersionMilitarysite = 1;
+constexpr uint8_t kCurrentPacketVersionProductionsite = 1;
+constexpr uint8_t kCurrentPacketVersionTrainingsite = 1;
+constexpr uint8_t kCurrentPacketVersionWarehouse = 1;
+
+enum class BuildingType : uint8_t {
+	kWarehouse = 1,
+	kProductionsite = 2,
+	kTrainingsite = 3,
+	kMilitarysite = 4,
+};
+
+// static
+BuildingSettings* BuildingSettings::load(const Game& game, const TribeDescr& tribe, FileRead& fr) {
+	try {
+		const uint8_t packet_version = fr.unsigned_8();
+		if (packet_version == kCurrentPacketVersion) {
+			const std::string name(fr.c_string());
+			const DescriptionIndex index = game.tribes().building_index(name);
+			const BuildingType type = static_cast<BuildingType>(fr.unsigned_8());
+			BuildingSettings* result = nullptr;
+			switch (type) {
+				case BuildingType::kTrainingsite: {
+					result = new TrainingsiteSettings(*dynamic_cast<const TrainingSiteDescr*>(
+							game.tribes().get_building_descr(index)));
+					break;
+				}
+				case BuildingType::kProductionsite: {
+					result = new ProductionsiteSettings(*dynamic_cast<const ProductionSiteDescr*>(
+							game.tribes().get_building_descr(index)));
+					break;
+				}
+				case BuildingType::kMilitarysite: {
+					result = new MilitarysiteSettings(*dynamic_cast<const MilitarySiteDescr*>(
+							game.tribes().get_building_descr(index)));
+					break;
+				}
+				case BuildingType::kWarehouse: {
+					result = new WarehouseSettings(*dynamic_cast<const WarehouseDescr*>(
+							game.tribes().get_building_descr(index)), tribe);
+					break;
+				}
+			}
+			if (!result) {
+				throw wexception("Unknown building category %u (%s)", static_cast<uint8_t>(type), name.c_str());
+			}
+			result->read(game, fr);
+			return result;
+		} else {
+			throw UnhandledVersionError(
+			   "BuildingSettings_load", packet_version, kCurrentPacketVersion);
+		}
+	} catch (const WException& e) {
+		throw GameDataError("BuildingSettings_load: %s", e.what());
+	}
+	NEVER_HERE();
+}
+
+void BuildingSettings::read(const Game&, FileRead&) {
+	// Header was peeled away by load()
+}
+
+void BuildingSettings::save(const Game&, FileWrite& fw) const {
+	fw.unsigned_8(kCurrentPacketVersion);
+	fw.c_string(descr_.c_str());
+}
+
+void MilitarysiteSettings::read(const Game& game, FileRead& fr) {
+	BuildingSettings::read(game, fr);
+	try {
+		const uint8_t packet_version = fr.unsigned_8();
+		if (packet_version == kCurrentPacketVersionMilitarysite) {
+			desired_capacity = fr.unsigned_32();
+			prefer_heroes = fr.unsigned_8();
+		} else {
+			throw UnhandledVersionError(
+			   "MilitarysiteSettings", packet_version, kCurrentPacketVersionMilitarysite);
+		}
+	} catch (const WException& e) {
+		throw GameDataError("MilitarysiteSettings: %s", e.what());
+	}
+}
+
+void MilitarysiteSettings::save(const Game& game, FileWrite& fw) const {
+	BuildingSettings::save(game, fw);
+	fw.unsigned_8(static_cast<uint8_t>(BuildingType::kMilitarysite));
+	fw.unsigned_8(kCurrentPacketVersionMilitarysite);
+
+	fw.unsigned_32(desired_capacity);
+	fw.unsigned_8(prefer_heroes ? 1 : 0);
+}
+
+void ProductionsiteSettings::read(const Game& game, FileRead& fr) {
+	BuildingSettings::read(game, fr);
+	try {
+		const uint8_t packet_version = fr.unsigned_8();
+		if (packet_version == kCurrentPacketVersionProductionsite) {
+			stopped = fr.unsigned_8();
+			const uint32_t nr_wares = fr.unsigned_32();
+			const uint32_t nr_workers = fr.unsigned_32();
+			for (uint32_t i = 0; i < nr_wares; ++i) {
+				const DescriptionIndex di = fr.unsigned_32();
+				const uint32_t fill = fr.unsigned_32();
+				const int32_t priority = fr.signed_32();
+				ware_queues.at(i).first = di;
+				ware_queues.at(i).second.desired_fill = fill;
+				ware_queues.at(i).second.priority = priority;
+			}
+			for (uint32_t i = 0; i < nr_workers; ++i) {
+				const DescriptionIndex di = fr.unsigned_32();
+				const uint32_t fill = fr.unsigned_32();
+				const int32_t priority = fr.signed_32();
+				worker_queues.at(i).first = di;
+				worker_queues.at(i).second.desired_fill = fill;
+				worker_queues.at(i).second.priority = priority;
+			}
+		} else {
+			throw UnhandledVersionError(
+			   "ProductionsiteSettings", packet_version, kCurrentPacketVersionProductionsite);
+		}
+	} catch (const WException& e) {
+		throw GameDataError("ProductionsiteSettings: %s", e.what());
+	}
+}
+
+void ProductionsiteSettings::save(const Game& game, FileWrite& fw) const {
+	BuildingSettings::save(game, fw);
+	fw.unsigned_8(static_cast<uint8_t>(BuildingType::kProductionsite));
+	fw.unsigned_8(kCurrentPacketVersionProductionsite);
+
+	fw.unsigned_8(stopped ? 1 : 0);
+	fw.unsigned_32(ware_queues.size());
+	fw.unsigned_32(worker_queues.size());
+	for (const auto& pair : ware_queues) {
+		fw.unsigned_32(pair.first);
+		fw.unsigned_32(pair.second.desired_fill);
+		fw.signed_32(pair.second.priority);
+	}
+	for (const auto& pair : worker_queues) {
+		fw.unsigned_32(pair.first);
+		fw.unsigned_32(pair.second.desired_fill);
+		fw.signed_32(pair.second.priority);
+	}
+}
+
+void TrainingsiteSettings::read(const Game& game, FileRead& fr) {
+	ProductionsiteSettings::read(game, fr);
+	try {
+		const uint8_t packet_version = fr.unsigned_8();
+		if (packet_version == kCurrentPacketVersionTrainingsite) {
+			desired_capacity = fr.unsigned_32();
+		} else {
+			throw UnhandledVersionError(
+			   "TrainingsiteSettings", packet_version, kCurrentPacketVersionTrainingsite);
+		}
+	} catch (const WException& e) {
+		throw GameDataError("TrainingsiteSettings: %s", e.what());
+	}
+}
+
+void TrainingsiteSettings::save(const Game& game, FileWrite& fw) const {
+	ProductionsiteSettings::save(game, fw);
+	fw.unsigned_8(static_cast<uint8_t>(BuildingType::kTrainingsite));
+	fw.unsigned_8(kCurrentPacketVersionTrainingsite);
+	fw.unsigned_32(desired_capacity);
+}
+
+void WarehouseSettings::read(const Game& game, FileRead& fr) {
+	BuildingSettings::read(game, fr);
+	try {
+		const uint8_t packet_version = fr.unsigned_8();
+		if (packet_version == kCurrentPacketVersionWarehouse) {
+			launch_expedition = fr.unsigned_8();
+			const uint32_t nr_wares = fr.unsigned_32();
+			const uint32_t nr_workers = fr.unsigned_32();
+			for (uint32_t i = 0; i < nr_wares; ++i) {
+				const DescriptionIndex di = fr.unsigned_32();
+				const uint8_t pref = fr.unsigned_8();
+				ware_preferences[di] = static_cast<StockPolicy>(pref);
+			}
+			for (uint32_t i = 0; i < nr_workers; ++i) {
+				const DescriptionIndex di = fr.unsigned_32();
+				const uint8_t pref = fr.unsigned_8();
+				worker_preferences[di] = static_cast<StockPolicy>(pref);
+			}
+		} else {
+			throw UnhandledVersionError(
+			   "WarehouseSettings", packet_version, kCurrentPacketVersionWarehouse);
+		}
+	} catch (const WException& e) {
+		throw GameDataError("WarehouseSettings: %s", e.what());
+	}
+}
+
+void WarehouseSettings::save(const Game& game, FileWrite& fw) const {
+	BuildingSettings::save(game, fw);
+	fw.unsigned_8(static_cast<uint8_t>(BuildingType::kWarehouse));
+	fw.unsigned_8(kCurrentPacketVersionWarehouse);
+
+	fw.unsigned_8(launch_expedition ? 1 : 0);
+	fw.unsigned_32(ware_preferences.size());
+	fw.unsigned_32(worker_preferences.size());
+	for (const auto& pair : ware_preferences) {
+		fw.unsigned_32(pair.first);
+		fw.unsigned_8(static_cast<uint8_t>(pair.second));
+	}
+	for (const auto& pair : worker_preferences) {
+		fw.unsigned_32(pair.first);
+		fw.unsigned_8(static_cast<uint8_t>(pair.second));
+	}
+}
+
+} // namespace Widelands

=== added file 'src/logic/map_objects/tribes/building_settings.h'
--- src/logic/map_objects/tribes/building_settings.h	1970-01-01 00:00:00 +0000
+++ src/logic/map_objects/tribes/building_settings.h	2019-06-19 09:23:26 +0000
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2002-2019 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_LOGIC_MAP_OBJECTS_TRIBES_BUILDING_SETTINGS_H
+#define WL_LOGIC_MAP_OBJECTS_TRIBES_BUILDING_SETTINGS_H
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "logic/widelands.h"
+
+class FileRead;
+class FileWrite;
+
+namespace Widelands {
+
+class Game;
+class MilitarySiteDescr;
+class ProductionSiteDescr;
+enum class StockPolicy;
+class TrainingSiteDescr;
+class TribeDescr;
+class WarehouseDescr;
+
+struct BuildingSettings {
+	BuildingSettings(const std::string& name) : descr_(name) {
+	}
+	virtual ~BuildingSettings() {
+	}
+
+	static BuildingSettings* load(const Game&, const TribeDescr&, FileRead&);
+
+	virtual void save(const Game&, FileWrite&) const;
+	virtual void read(const Game&, FileRead&);
+
+	virtual void apply(const BuildingSettings&) {
+	}
+
+private:
+	const std::string descr_;
+};
+
+struct ProductionsiteSettings : public BuildingSettings {
+	ProductionsiteSettings(const ProductionSiteDescr& descr);
+	~ProductionsiteSettings() override {
+	}
+	void apply(const BuildingSettings&) override;
+
+	void save(const Game&, FileWrite&) const override;
+	void read(const Game&, FileRead&) override;
+
+	struct InputQueueSetting {
+		const uint32_t max_fill;
+		uint32_t desired_fill;
+		int32_t priority;
+	};
+	std::vector<std::pair<DescriptionIndex, InputQueueSetting>> ware_queues;
+	std::vector<std::pair<DescriptionIndex, InputQueueSetting>> worker_queues;
+	bool stopped;
+};
+
+struct MilitarysiteSettings : public BuildingSettings {
+	MilitarysiteSettings(const MilitarySiteDescr&);
+	~MilitarysiteSettings() override {
+	}
+	void apply(const BuildingSettings&) override;
+
+	void save(const Game&, FileWrite&) const override;
+	void read(const Game&, FileRead&) override;
+
+	const uint32_t max_capacity;
+	uint32_t desired_capacity;
+	bool prefer_heroes;
+};
+
+struct TrainingsiteSettings : public ProductionsiteSettings {
+	TrainingsiteSettings(const TrainingSiteDescr&);
+	~TrainingsiteSettings() override {
+	}
+	void apply(const BuildingSettings&) override;
+
+	void save(const Game&, FileWrite&) const override;
+	void read(const Game&, FileRead&) override;
+
+	const uint32_t max_capacity;
+	uint32_t desired_capacity;
+};
+
+struct WarehouseSettings : public BuildingSettings {
+	WarehouseSettings(const WarehouseDescr&, const TribeDescr&);
+	~WarehouseSettings() override {
+	}
+	void apply(const BuildingSettings&) override;
+
+	void save(const Game&, FileWrite&) const override;
+	void read(const Game&, FileRead&) override;
+
+	std::map<DescriptionIndex, StockPolicy> ware_preferences;
+	std::map<DescriptionIndex, StockPolicy> worker_preferences;
+	const bool launch_expedition_allowed;
+	bool launch_expedition;
+};
+
+}  // namespace Widelands
+
+#endif  // end of include guard: WL_LOGIC_MAP_OBJECTS_TRIBES_BUILDING_SETTINGS_H

=== modified file 'src/logic/map_objects/tribes/constructionsite.cc'
--- src/logic/map_objects/tribes/constructionsite.cc	2019-05-26 17:21:15 +0000
+++ src/logic/map_objects/tribes/constructionsite.cc	2019-06-19 09:23:26 +0000
@@ -32,6 +32,11 @@
 #include "graphic/rendertarget.h"
 #include "logic/editor_game_base.h"
 #include "logic/game.h"
+#include "logic/game_data_error.h"
+#include "logic/map_objects/tribes/militarysite.h"
+#include "logic/map_objects/tribes/partially_finished_building.h"
+#include "logic/map_objects/tribes/productionsite.h"
+#include "logic/map_objects/tribes/trainingsite.h"
 #include "logic/map_objects/tribes/tribe_descr.h"
 #include "logic/map_objects/tribes/worker.h"
 #include "sound/note_sound.h"
@@ -46,32 +51,61 @@
                                        const RGBColor& player_color,
                                        RenderTarget* dst) const {
 	// Draw the construction site marker
-	const uint32_t anim_idx = becomes->is_animation_known("build") ?
-	                             becomes->get_animation("build", nullptr) :
-	                             becomes->get_unoccupied_animation();
-
-	const Animation& anim = g_gr->animations().get_animation(anim_idx);
-	const size_t nr_frames = anim.nr_frames();
-	const uint32_t cur_frame = totaltime ? completedtime * nr_frames / totaltime : 0;
-	uint32_t anim_time = cur_frame * FRAME_LENGTH;
-
-	if (cur_frame) {  //  not the first pic
-		// Draw the complete prev pic , so we won't run into trouble if images have different sizes
-		dst->blit_animation(point_on_dst, Widelands::Coords::null(), scale, anim_idx,
-		                    anim_time - FRAME_LENGTH, &player_color);
+	std::vector<std::pair<uint32_t, uint32_t>> animations;
+	uint32_t total_frames = 0;
+	auto push_animation = [](const BuildingDescr* d, std::vector<std::pair<uint32_t, uint32_t>>* anims, uint32_t* tf) {
+		const bool known = d->is_animation_known("build");
+		const uint32_t anim_idx = known ?
+				d->get_animation("build", nullptr) :
+				d->get_unoccupied_animation();
+		// If there is no build animation, we use only the first frame or we
+		// would get many build steps with almost the same image...
+		const uint32_t nrframes = known ? g_gr->animations().get_animation(anim_idx).nr_frames() : 1;
+		assert(nrframes);
+		*tf += nrframes;
+		anims->push_back(std::make_pair(anim_idx, nrframes));
+	};
+	for (const BuildingDescr* d : intermediates) {
+		push_animation(d, &animations, &total_frames);
+	}
+	push_animation(becomes, &animations, &total_frames);
+
+	uint32_t frame_index = totaltime ? std::min(completedtime * total_frames / totaltime, total_frames - 1) : 0;
+	uint32_t animation_index = 0;
+	while (frame_index >= animations[animation_index].second) {
+		frame_index -= animations[animation_index].second;
+		++animation_index;
+		assert(animation_index < animations.size());
+	}
+	const uint32_t anim_time = frame_index * FRAME_LENGTH;
+
+	if (frame_index > 0) {
+		// Not the first pic within this animation – draw the previous one
+		dst->blit_animation(point_on_dst, Widelands::Coords::null(), scale,
+				animations[animation_index].first, anim_time - FRAME_LENGTH, &player_color);
+	} else if (animation_index > 0) {
+		// The first pic, but not the first series of animations – draw the last pic of the previous series
+		dst->blit_animation(point_on_dst, Widelands::Coords::null(), scale,
+				animations[animation_index - 1].first,
+				FRAME_LENGTH * (animations[animation_index - 1].second - 1), &player_color);
 	} else if (was) {
-		//  Is the first picture but there was another building here before,
-		//  get its most fitting picture and draw it instead.
-		dst->blit_animation(point_on_dst, Widelands::Coords::null(), scale,
-		                    was->get_unoccupied_animation(), anim_time - FRAME_LENGTH, &player_color);
+		//  First pic in first series, but there was another building here before –
+		//  get its most fitting picture and draw it instead
+		const uint32_t unocc = was->get_unoccupied_animation();
+		dst->blit_animation(point_on_dst, Widelands::Coords::null(), scale, unocc,
+				FRAME_LENGTH * (g_gr->animations().get_animation(unocc).nr_frames() - 1),
+				&player_color);
 	}
 	// Now blit a segment of the current construction phase from the bottom.
-	int percent = 100 * completedtime * nr_frames;
+	int percent = 100 * completedtime * total_frames;
 	if (totaltime) {
 		percent /= totaltime;
 	}
-	percent -= 100 * cur_frame;
-	dst->blit_animation(point_on_dst, coords, scale, anim_idx, anim_time, &player_color, percent);
+	percent -= 100 * frame_index;
+	for (uint32_t i = 0; i < animation_index; ++i) {
+		percent -= 100 * animations[i].second;
+	}
+	dst->blit_animation(point_on_dst, coords, scale, animations[animation_index].first, anim_time, &player_color, percent);
 }
 
 /**
@@ -104,7 +138,7 @@
 */
 
 ConstructionSite::ConstructionSite(const ConstructionSiteDescr& cs_descr)
-   : PartiallyFinishedBuilding(cs_descr), fetchfromflag_(0), builder_idle_(false) {
+   : PartiallyFinishedBuilding(cs_descr), fetchfromflag_(0), builder_idle_(false), settings_(nullptr) {
 }
 
 void ConstructionSite::update_statistics_string(std::string* s) {
@@ -181,9 +215,30 @@
 
 		work_steps_ += it->second;
 	}
+
+	init_settings();
+
 	return true;
 }
 
+void ConstructionSite::init_settings() {
+	assert(building_);
+	assert(!settings_);
+	if (upcast(const WarehouseDescr, wd, building_)) {
+		settings_.reset(new WarehouseSettings(*wd, owner().tribe()));
+	} else if (upcast(const TrainingSiteDescr, td, building_)) {
+		settings_.reset(new TrainingsiteSettings(*td));
+	} else if (upcast(const ProductionSiteDescr, pd, building_)) {
+		settings_.reset(new ProductionsiteSettings(*pd));
+	} else if (upcast(const MilitarySiteDescr, md, building_)) {
+		settings_.reset(new MilitarysiteSettings(*md));
+	} else {
+		// TODO(Nordfriese): Add support for markets when trading is implemented
+		log("WARNING: Created constructionsite for a %s, which is not of any known building type\n",
+				building_->name().c_str());
+	}
+}
+
 /*
 ===============
 Release worker and material (if any is left).
@@ -207,6 +262,52 @@
 			builder->reset_tasks(dynamic_cast<Game&>(egbase));
 			builder->set_location(&b);
 		}
+
+		// Apply settings
+		if (settings_) {
+			if (upcast(ProductionsiteSettings, ps, settings_.get())) {
+				for (const auto& pair : ps->ware_queues) {
+					b.inputqueue(pair.first, wwWARE).set_max_fill(pair.second.desired_fill);
+					b.set_priority(wwWARE, pair.first, pair.second.priority);
+				}
+				for (const auto& pair : ps->worker_queues) {
+					b.inputqueue(pair.first, wwWORKER).set_max_fill(pair.second.desired_fill);
+					b.set_priority(wwWORKER, pair.first, pair.second.priority);
+				}
+				if (upcast(TrainingsiteSettings, ts, ps)) {
+					assert(b.soldier_control());
+					assert(ts->desired_capacity >= b.soldier_control()->min_soldier_capacity());
+					assert(ts->desired_capacity <= b.soldier_control()->max_soldier_capacity());
+					if (ts->desired_capacity != b.soldier_control()->soldier_capacity()) {
+						b.mutable_soldier_control()->set_soldier_capacity(ts->desired_capacity);
+					}
+				}
+				dynamic_cast<ProductionSite&>(b).set_stopped(ps->stopped);
+			} else if (upcast(MilitarysiteSettings, ms, settings_.get())) {
+				assert(b.soldier_control());
+				assert(ms->desired_capacity >= b.soldier_control()->min_soldier_capacity());
+				assert(ms->desired_capacity <= b.soldier_control()->max_soldier_capacity());
+				if (ms->desired_capacity != b.soldier_control()->soldier_capacity()) {
+					b.mutable_soldier_control()->set_soldier_capacity(ms->desired_capacity);
+				}
+				dynamic_cast<MilitarySite&>(b).set_soldier_preference(ms->prefer_heroes ?
+						SoldierPreference::kHeroes : SoldierPreference::kRookies);
+			} else if (upcast(WarehouseSettings, ws, settings_.get())) {
+				Warehouse& site = dynamic_cast<Warehouse&>(b);
+				for (const auto& pair : ws->ware_preferences) {
+					site.set_ware_policy(pair.first, pair.second);
+				}
+				for (const auto& pair : ws->worker_preferences) {
+					site.set_worker_policy(pair.first, pair.second);
+				}
+				if (ws->launch_expedition) {
+					get_owner()->start_or_cancel_expedition(site);
+				}
+			} else {
+				NEVER_HERE();
+			}
+		}
+
 		// Open the new building window if needed
 		Notifications::publish(NoteBuilding(b.serial(), NoteBuilding::Action::kFinishWarp));
 	}
@@ -214,6 +315,138 @@
 
 /*
 ===============
+Start building the next enhancement even before the base building is completed.
+===============
+*/
+void ConstructionSite::enhance(Game&) {
+	assert(building_->enhancement() != INVALID_INDEX);
+	Notifications::publish(NoteImmovable(this, NoteImmovable::Ownership::LOST));
+
+	info_.intermediates.push_back(building_);
+	old_buildings_.push_back(owner().tribe().building_index(building_->name()));
+	building_ = owner().tribe().get_building_descr(building_->enhancement());
+	assert(building_);
+	info_.becomes = building_;
+
+	const std::map<DescriptionIndex, uint8_t>& buildcost = building_->enhancement_cost();
+	std::set<DescriptionIndex> new_ware_types;
+	for (const auto& pair : buildcost) {
+		bool found = false;
+		for (const auto& queue : wares_) {
+			if (queue->get_index() == pair.first) {
+				found = true;
+				break;
+			}
+		}
+		if (!found) {
+			new_ware_types.insert(pair.first);
+		}
+	}
+
+	const size_t old_size = wares_.size();
+	wares_.resize(old_size + new_ware_types.size());
+
+	size_t new_index = 0;
+	for (const auto& pair : buildcost) {
+		if (new_ware_types.count(pair.first)) {
+			WaresQueue& wq = *(wares_[old_size + new_index] = new WaresQueue(*this, pair.first, pair.second));
+			wq.set_callback(ConstructionSite::wares_queue_callback, this);
+			wq.set_consume_interval(CONSTRUCTIONSITE_STEP_TIME);
+			++new_index;
+		} else {
+			for (size_t i = 0; i < old_size; ++i) {
+				WaresQueue& wq = *wares_[i];
+				if (wq.get_index() == pair.first) {
+					wq.set_max_size(wq.get_max_size() + pair.second);
+					wq.set_max_fill(wq.get_max_fill() + pair.second);
+					break;
+				}
+			}
+		}
+		work_steps_ += pair.second;
+	}
+
+	BuildingSettings* old_settings = settings_.release();
+	if (upcast(const WarehouseDescr, wd, building_)) {
+		upcast(WarehouseSettings, ws, old_settings);
+		assert(ws);
+		WarehouseSettings* new_settings = new WarehouseSettings(*wd, owner().tribe());
+		settings_.reset(new_settings);
+		for (const auto& pair : ws->ware_preferences) {
+			new_settings->ware_preferences[pair.first] = pair.second;
+		}
+		for (const auto& pair : ws->worker_preferences) {
+			new_settings->worker_preferences[pair.first] = pair.second;
+		}
+		new_settings->launch_expedition = ws->launch_expedition && building_->get_isport();
+	} else if (upcast(const TrainingSiteDescr, td, building_)) {
+		upcast(TrainingsiteSettings, ts, old_settings);
+		assert(ts);
+		TrainingsiteSettings* new_settings = new TrainingsiteSettings(*td);
+		settings_.reset(new_settings);
+		new_settings->stopped = ts->stopped;
+		for (const auto& pair_old : ts->ware_queues) {
+			for (auto& pair_new : new_settings->ware_queues) {
+				if (pair_new.first == pair_old.first) {
+					pair_new.second.priority = pair_old.second.priority;
+					pair_new.second.desired_fill = std::min(pair_old.second.desired_fill, pair_new.second.max_fill);
+					break;
+				}
+			}
+		}
+		for (const auto& pair_old : ts->worker_queues) {
+			for (auto& pair_new : new_settings->worker_queues) {
+				if (pair_new.first == pair_old.first) {
+					pair_new.second.priority = pair_old.second.priority;
+					pair_new.second.desired_fill = std::min(pair_old.second.desired_fill, pair_new.second.max_fill);
+					break;
+				}
+			}
+		}
+		new_settings->desired_capacity = std::min(new_settings->max_capacity, ts->desired_capacity);
+	} else if (upcast(const ProductionSiteDescr, pd, building_)) {
+		upcast(ProductionsiteSettings, ps, old_settings);
+		assert(ps);
+		ProductionsiteSettings* new_settings = new ProductionsiteSettings(*pd);
+		settings_.reset(new_settings);
+		new_settings->stopped = ps->stopped;
+		for (const auto& pair_old : ps->ware_queues) {
+			for (auto& pair_new : new_settings->ware_queues) {
+				if (pair_new.first == pair_old.first) {
+					pair_new.second.priority = pair_old.second.priority;
+					pair_new.second.desired_fill = std::min(pair_old.second.desired_fill, pair_new.second.max_fill);
+					break;
+				}
+			}
+		}
+		for (const auto& pair_old : ps->worker_queues) {
+			for (auto& pair_new : new_settings->worker_queues) {
+				if (pair_new.first == pair_old.first) {
+					pair_new.second.priority = pair_old.second.priority;
+					pair_new.second.desired_fill = std::min(pair_old.second.desired_fill, pair_new.second.max_fill);
+					break;
+				}
+			}
+		}
+	} else if (upcast(const MilitarySiteDescr, md, building_)) {
+		upcast(MilitarysiteSettings, ms, old_settings);
+		assert(ms);
+		MilitarysiteSettings* new_settings = new MilitarysiteSettings(*md);
+		settings_.reset(new_settings);
+		new_settings->desired_capacity = std::max<uint32_t>(1, std::min<uint32_t>(
+				new_settings->max_capacity, ms->desired_capacity));
+		new_settings->prefer_heroes = ms->prefer_heroes;
+	} else {
+		// TODO(Nordfriese): Add support for markets when trading is implemented
+		log("WARNING: Enhanced constructionsite to a %s, which is not of any known building type\n",
+				building_->name().c_str());
+	}
+	Notifications::publish(NoteImmovable(this, NoteImmovable::Ownership::GAINED));
+	Notifications::publish(NoteBuilding(serial(), NoteBuilding::Action::kChanged));
+}
+
+/*
+===============
 Construction sites only burn if some of the work has been completed.
 ===============
 */
@@ -343,6 +576,17 @@
 
 /*
 ===============
+Overwrite as many values of the current settings with those of the given settings as possible.
+===============
+*/
+void ConstructionSite::apply_settings(const BuildingSettings& cs) {
+	assert(settings_);
+	settings_->apply(cs);
+	delete &cs;
+}
+
+/*
+===============
 Draw the construction site.
 ===============
 */

=== modified file 'src/logic/map_objects/tribes/constructionsite.h'
--- src/logic/map_objects/tribes/constructionsite.h	2019-05-05 14:05:07 +0000
+++ src/logic/map_objects/tribes/constructionsite.h	2019-06-19 09:23:26 +0000
@@ -20,16 +20,26 @@
 #ifndef WL_LOGIC_MAP_OBJECTS_TRIBES_CONSTRUCTIONSITE_H
 #define WL_LOGIC_MAP_OBJECTS_TRIBES_CONSTRUCTIONSITE_H
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
+#include "logic/map_objects/tribes/building_settings.h"
 #include "logic/map_objects/tribes/partially_finished_building.h"
 #include "scripting/lua_table.h"
 
+class FileRead;
+class FileWrite;
+
 namespace Widelands {
 
 class Building;
+class MilitarySiteDescr;
+class ProductionSiteDescr;
 class Request;
+enum class StockPolicy;
+class TrainingSiteDescr;
+class WarehouseDescr;
 class WaresQueue;
 
 /// Per-player and per-field constructionsite information
@@ -47,6 +57,7 @@
 	const BuildingDescr*
 	   becomes;  // Also works as a marker telling whether there is a construction site.
 	const BuildingDescr* was;  // only valid if "becomes" is an enhanced building.
+	std::vector<const BuildingDescr*> intermediates; // If we enhance a building while it's still under construction
 	uint32_t totaltime;
 	uint32_t completedtime;
 };
@@ -114,6 +125,13 @@
 	bool fetch_from_flag(Game&) override;
 	bool get_building_work(Game&, Worker&, bool success) override;
 
+	BuildingSettings* get_settings() const {
+		return settings_.get();
+	}
+	void apply_settings(const BuildingSettings&);
+
+	void enhance(Game&);
+
 protected:
 	void update_statistics_string(std::string* statistics_string) override;
 
@@ -135,6 +153,9 @@
 
 	bool builder_idle_;                 // used to determine whether the builder is idle
 	ConstructionsiteInformation info_;  // asked for by player point of view for the gameview
+
+	std::unique_ptr<BuildingSettings> settings_;
+	void init_settings();
 };
 }  // namespace Widelands
 

=== modified file 'src/logic/map_objects/tribes/militarysite.cc'
--- src/logic/map_objects/tribes/militarysite.cc	2019-05-26 17:21:15 +0000
+++ src/logic/map_objects/tribes/militarysite.cc	2019-06-19 09:23:26 +0000
@@ -982,6 +982,13 @@
 	return false;
 }
 
+const BuildingSettings* MilitarySite::create_building_settings() const {
+	MilitarysiteSettings* settings = new MilitarysiteSettings(descr());
+	settings->desired_capacity = std::min(settings->max_capacity, soldier_control_.soldier_capacity());
+	settings->prefer_heroes = soldier_preference_ == SoldierPreference::kHeroes;
+	return settings;
+}
+
 // setters
 
 void MilitarySite::set_soldier_preference(SoldierPreference p) {

=== modified file 'src/logic/map_objects/tribes/militarysite.h'
--- src/logic/map_objects/tribes/militarysite.h	2019-05-05 14:05:07 +0000
+++ src/logic/map_objects/tribes/militarysite.h	2019-06-19 09:23:26 +0000
@@ -108,6 +108,8 @@
 		return soldier_preference_;
 	}
 
+	const BuildingSettings* create_building_settings() const override;
+
 protected:
 	void conquer_area(EditorGameBase&);
 

=== modified file 'src/logic/map_objects/tribes/productionsite.cc'
--- src/logic/map_objects/tribes/productionsite.cc	2019-05-29 07:14:00 +0000
+++ src/logic/map_objects/tribes/productionsite.cc	2019-06-19 09:23:26 +0000
@@ -445,13 +445,12 @@
 	const BillOfMaterials& input_workers = descr().input_workers();
 	input_queues_.resize(input_wares.size() + input_workers.size());
 
-	for (WareRange i(input_wares); i; ++i) {
-		input_queues_[i.i] = new WaresQueue(*this, i.current->first, i.current->second);
+	size_t i = 0;
+	for (const WareAmount& pair : input_wares) {
+		input_queues_[i++] = new WaresQueue(*this, pair.first, pair.second);
 	}
-
-	for (WareRange i(input_workers); i; ++i) {
-		input_queues_[input_wares.size() + i.i] =
-		   new WorkersQueue(*this, i.current->first, i.current->second);
+	for (const WareAmount& pair : input_workers) {
+		input_queues_[i++] = new WorkersQueue(*this, pair.first, pair.second);
 	}
 
 	//  Request missing workers.
@@ -1020,6 +1019,30 @@
 	set_production_result("");
 }
 
+const BuildingSettings* ProductionSite::create_building_settings() const {
+	ProductionsiteSettings* settings = new ProductionsiteSettings(descr());
+	settings->stopped = is_stopped_;
+	for (auto& pair : settings->ware_queues) {
+		pair.second.priority = get_priority(wwWARE, pair.first, false);
+		for (const auto& queue : input_queues_) {
+			if (queue->get_type() == wwWARE && queue->get_index() == pair.first) {
+				pair.second.desired_fill = std::min(pair.second.max_fill, queue->get_max_fill());
+				break;
+			}
+		}
+	}
+	for (auto& pair : settings->worker_queues) {
+		pair.second.priority = get_priority(wwWORKER, pair.first, false);
+		for (const auto& queue : input_queues_) {
+			if (queue->get_type() == wwWORKER && queue->get_index() == pair.first) {
+				pair.second.desired_fill = std::min(pair.second.max_fill, queue->get_max_fill());
+				break;
+			}
+		}
+	}
+	return settings;
+}
+
 /// Changes the default anim string to \li anim
 void ProductionSite::set_default_anim(std::string anim) {
 	if (default_anim_ == anim)

=== modified file 'src/logic/map_objects/tribes/productionsite.h'
--- src/logic/map_objects/tribes/productionsite.h	2019-05-28 21:04:36 +0000
+++ src/logic/map_objects/tribes/productionsite.h	2019-06-19 09:23:26 +0000
@@ -241,6 +241,8 @@
 
 	void set_default_anim(std::string);
 
+	const BuildingSettings* create_building_settings() const override;
+
 protected:
 	void update_statistics_string(std::string* statistics) override;
 

=== modified file 'src/logic/map_objects/tribes/trainingsite.cc'
--- src/logic/map_objects/tribes/trainingsite.cc	2019-05-05 14:05:07 +0000
+++ src/logic/map_objects/tribes/trainingsite.cc	2019-06-19 09:23:26 +0000
@@ -525,6 +525,13 @@
 	}
 }
 
+const BuildingSettings* TrainingSite::create_building_settings() const {
+	TrainingsiteSettings* settings = new TrainingsiteSettings(descr());
+	settings->apply(*ProductionSite::create_building_settings());
+	settings->desired_capacity = std::min(settings->max_capacity, soldier_control_.soldier_capacity());
+	return settings;
+}
+
 /**
  * In addition to advancing the program, update soldier status.
  */

=== modified file 'src/logic/map_objects/tribes/trainingsite.h'
--- src/logic/map_objects/tribes/trainingsite.h	2019-05-05 14:05:07 +0000
+++ src/logic/map_objects/tribes/trainingsite.h	2019-06-19 09:23:26 +0000
@@ -199,6 +199,8 @@
 	void training_successful(TrainingAttribute type, uint32_t level);
 	void training_done();
 
+	const BuildingSettings* create_building_settings() const override;
+
 protected:
 	void program_end(Game&, ProgramResult) override;
 

=== modified file 'src/logic/map_objects/tribes/warehouse.cc'
--- src/logic/map_objects/tribes/warehouse.cc	2019-03-01 04:19:53 +0000
+++ src/logic/map_objects/tribes/warehouse.cc	2019-06-19 09:23:26 +0000
@@ -1275,17 +1275,17 @@
 	}
 }
 
-Warehouse::StockPolicy Warehouse::get_ware_policy(DescriptionIndex ware) const {
+StockPolicy Warehouse::get_ware_policy(DescriptionIndex ware) const {
 	assert(ware < static_cast<DescriptionIndex>(ware_policy_.size()));
 	return ware_policy_[ware];
 }
 
-Warehouse::StockPolicy Warehouse::get_worker_policy(DescriptionIndex ware) const {
+StockPolicy Warehouse::get_worker_policy(DescriptionIndex ware) const {
 	assert(ware < static_cast<DescriptionIndex>(worker_policy_.size()));
 	return worker_policy_[ware];
 }
 
-Warehouse::StockPolicy Warehouse::get_stock_policy(WareWorker waretype,
+StockPolicy Warehouse::get_stock_policy(WareWorker waretype,
                                                    DescriptionIndex wareindex) const {
 	if (waretype == wwWORKER)
 		return get_worker_policy(wareindex);
@@ -1293,25 +1293,25 @@
 		return get_ware_policy(wareindex);
 }
 
-void Warehouse::set_ware_policy(DescriptionIndex ware, Warehouse::StockPolicy policy) {
+void Warehouse::set_ware_policy(DescriptionIndex ware, StockPolicy policy) {
 	assert(ware < static_cast<DescriptionIndex>(ware_policy_.size()));
 	ware_policy_[ware] = policy;
 }
 
-void Warehouse::set_worker_policy(DescriptionIndex ware, Warehouse::StockPolicy policy) {
+void Warehouse::set_worker_policy(DescriptionIndex ware, StockPolicy policy) {
 	assert(ware < static_cast<DescriptionIndex>(worker_policy_.size()));
 	worker_policy_[ware] = policy;
 }
 
 /**
- * Check if there are remaining wares with \ref Warehouse::StockPolicy::kRemove,
+ * Check if there are remaining wares with \ref StockPolicy::kRemove,
  * and remove one of them if appropriate.
  */
 void Warehouse::check_remove_stock(Game& game) {
 	if (base_flag().current_wares() < base_flag().total_capacity() / 2) {
 		for (DescriptionIndex ware = 0; ware < static_cast<DescriptionIndex>(ware_policy_.size());
 		     ++ware) {
-			if (get_ware_policy(ware) != Warehouse::StockPolicy::kRemove || !get_wares().stock(ware))
+			if (get_ware_policy(ware) != StockPolicy::kRemove || !get_wares().stock(ware))
 				continue;
 
 			launch_ware(game, ware);
@@ -1321,7 +1321,7 @@
 
 	for (DescriptionIndex widx = 0; widx < static_cast<DescriptionIndex>(worker_policy_.size());
 	     ++widx) {
-		if (get_worker_policy(widx) != Warehouse::StockPolicy::kRemove || !get_workers().stock(widx))
+		if (get_worker_policy(widx) != StockPolicy::kRemove || !get_workers().stock(widx))
 			continue;
 
 		Worker& worker = launch_worker(game, widx, Requirements());
@@ -1337,6 +1337,18 @@
 	return portdock_->expedition_bootstrap()->inputqueue(index, type);
 }
 
+const BuildingSettings* Warehouse::create_building_settings() const {
+	WarehouseSettings* settings = new WarehouseSettings(descr(), owner().tribe());
+	for (auto& pair : settings->ware_preferences) {
+		pair.second = get_ware_policy(pair.first);
+	}
+	for (auto& pair : settings->worker_preferences) {
+		pair.second = get_worker_policy(pair.first);
+	}
+	settings->launch_expedition = portdock_ && portdock_->expedition_started();
+	return settings;
+}
+
 void Warehouse::log_general_info(const EditorGameBase& egbase) const {
 	Building::log_general_info(egbase);
 

=== modified file 'src/logic/map_objects/tribes/warehouse.h'
--- src/logic/map_objects/tribes/warehouse.h	2019-05-05 14:05:07 +0000
+++ src/logic/map_objects/tribes/warehouse.h	2019-06-19 09:23:26 +0000
@@ -68,6 +68,40 @@
 	DISALLOW_COPY_AND_ASSIGN(WarehouseDescr);
 };
 
+/**
+ * Each ware and worker type has an associated per-warehouse
+ * stock policy that defines whether it will be stocked by this
+ * warehouse.
+ *
+ * \note The values of this enum are written directly into savegames,
+ * so be careful when changing them.
+ */
+enum class StockPolicy {
+	/**
+	 * The default policy allows stocking wares without any special priority.
+	 */
+	kNormal = 0,
+
+	/**
+	 * As long as there are warehouses with this policy for a ware, all
+	 * available unstocked supplies will be transferred to warehouses
+	 * with this policy.
+	 */
+	kPrefer = 1,
+
+	/**
+	 * If a ware has this stock policy, no more of this ware will enter
+	 * the warehouse.
+	 */
+	kDontStock = 2,
+
+	/**
+	 * Like \ref kDontStock, but in addition, existing stock of this ware
+	 * will be transported out of the warehouse over time.
+	 */
+	kRemove = 3,
+};
+
 class Warehouse : public Building {
 	friend class PortDock;
 	friend class MapBuildingdataPacket;
@@ -75,39 +109,6 @@
 	MO_DESCR(WarehouseDescr)
 
 public:
-	/**
-	 * Each ware and worker type has an associated per-warehouse
-	 * stock policy that defines whether it will be stocked by this
-	 * warehouse.
-	 *
-	 * \note The values of this enum are written directly into savegames,
-	 * so be careful when changing them.
-	 */
-	enum class StockPolicy {
-		/**
-		 * The default policy allows stocking wares without any special priority.
-		 */
-		kNormal = 0,
-
-		/**
-		 * As long as there are warehouses with this policy for a ware, all
-		 * available unstocked supplies will be transferred to warehouses
-		 * with this policy.
-		 */
-		kPrefer = 1,
-
-		/**
-		 * If a ware has this stock policy, no more of this ware will enter
-		 * the warehouse.
-		 */
-		kDontStock = 2,
-
-		/**
-		 * Like \ref kDontStock, but in addition, existing stock of this ware
-		 * will be transported out of the warehouse over time.
-		 */
-		kRemove = 3,
-	};
 
 	/**
 	 * Whether worker indices in count_workers() have to match exactly.
@@ -208,6 +209,8 @@
 		return portdock_;
 	}
 
+	const BuildingSettings* create_building_settings() const override;
+
 	// Returns the waresqueue of the expedition if this is a port.
 	// Will throw an exception otherwise.
 	InputQueue& inputqueue(DescriptionIndex, WareWorker) override;

=== modified file 'src/logic/player.cc'
--- src/logic/player.cc	2019-05-26 05:58:14 +0000
+++ src/logic/player.cc	2019-06-19 09:23:26 +0000
@@ -760,6 +760,7 @@
 		} else {
 			workers = building->get_workers();
 		}
+		const BuildingSettings* settings = building->create_building_settings();
 
 		if (index_of_new_building != INVALID_INDEX) {
 			// For enhancing, register whether the window was open
@@ -770,7 +771,7 @@
 		//  pointer.
 		if (index_of_new_building != INVALID_INDEX)
 			building = &egbase().warp_constructionsite(
-			   position, player_number_, index_of_new_building, false, former_buildings);
+			   position, player_number_, index_of_new_building, false, former_buildings, settings);
 		else
 			building = &egbase().warp_dismantlesite(position, player_number_, false, former_buildings);
 

=== modified file 'src/logic/playercommand.cc'
--- src/logic/playercommand.cc	2019-05-25 10:54:30 +0000
+++ src/logic/playercommand.cc	2019-06-19 09:23:26 +0000
@@ -486,8 +486,14 @@
 }
 
 void CmdStartStopBuilding::execute(Game& game) {
-	if (upcast(Building, building, game.objects().get_object(serial)))
+	MapObject* mo = game.objects().get_object(serial);
+	if (upcast(ConstructionSite, cs, mo)) {
+		if (upcast(ProductionsiteSettings, s, cs->get_settings())) {
+			s->stopped = !s->stopped;
+		}
+	} else if (upcast(Building, building, mo)) {
 		game.get_player(sender())->start_stop_building(*building);
+	}
 }
 
 void CmdStartStopBuilding::serialize(StreamWrite& ser) {
@@ -536,8 +542,14 @@
 }
 
 void CmdMilitarySiteSetSoldierPreference::execute(Game& game) {
-	if (upcast(MilitarySite, building, game.objects().get_object(serial)))
+	MapObject* mo = game.objects().get_object(serial);
+	if (upcast(ConstructionSite, cs, mo)) {
+		if (upcast(MilitarysiteSettings, s, cs->get_settings())) {
+			s->prefer_heroes = preference == SoldierPreference::kHeroes;
+		}
+	} else if (upcast(MilitarySite, building, mo)) {
 		game.get_player(sender())->military_site_set_soldier_preference(*building, preference);
+	}
 }
 
 constexpr uint16_t kCurrentPacketVersionSoldierPreference = 1;
@@ -582,8 +594,14 @@
 }
 
 void CmdStartOrCancelExpedition::execute(Game& game) {
-	if (upcast(Warehouse, warehouse, game.objects().get_object(serial)))
+	MapObject* mo = game.objects().get_object(serial);
+	if (upcast(ConstructionSite, cs, mo)) {
+		if (upcast(WarehouseSettings, s, cs->get_settings())) {
+			s->launch_expedition = !s->launch_expedition;
+		}
+	} else if (upcast(Warehouse, warehouse, game.objects().get_object(serial))) {
 		game.get_player(sender())->start_or_cancel_expedition(*warehouse);
+	}
 }
 
 void CmdStartOrCancelExpedition::serialize(StreamWrite& ser) {
@@ -626,8 +644,12 @@
 }
 
 void CmdEnhanceBuilding::execute(Game& game) {
-	if (upcast(Building, building, game.objects().get_object(serial)))
+	MapObject* mo = game.objects().get_object(serial);
+	if (upcast(ConstructionSite, cs, mo)) {
+		cs->enhance(game);
+	} else if (upcast(Building, building, mo)) {
 		game.get_player(sender())->enhance_building(building, bi);
+	}
 }
 
 void CmdEnhanceBuilding::serialize(StreamWrite& ser) {
@@ -1036,14 +1058,22 @@
 }
 
 void CmdSetWarePriority::execute(Game& game) {
-	upcast(Building, psite, game.objects().get_object(serial_));
-
-	if (!psite)
-		return;
-	if (psite->owner().player_number() != sender())
-		return;
-
-	psite->set_priority(type_, index_, priority_);
+	MapObject* mo = game.objects().get_object(serial_);
+	if (upcast(ConstructionSite, cs, mo)) {
+		if (upcast(ProductionsiteSettings, s, cs->get_settings())) {
+			for (auto& pair : s->ware_queues) {
+				if (pair.first == index_) {
+					pair.second.priority = priority_;
+					return;
+				}
+			}
+			NEVER_HERE();
+		}
+	} else if (upcast(Building, psite, mo)) {
+		if (psite->owner().player_number() == sender()) {
+			psite->set_priority(type_, index_, priority_);
+		}
+	}
 }
 
 constexpr uint16_t kCurrentPacketVersionCmdSetWarePriority = 1;
@@ -1110,14 +1140,36 @@
 }
 
 void CmdSetInputMaxFill::execute(Game& game) {
-	upcast(Building, b, game.objects().get_object(serial_));
-
-	if (!b)
-		return;
-	if (b->owner().player_number() != sender())
-		return;
-
-	b->inputqueue(index_, type_).set_max_fill(max_fill_);
+	MapObject* mo = game.objects().get_object(serial_);
+	if (upcast(ConstructionSite, cs, mo)) {
+		if (upcast(ProductionsiteSettings, s, cs->get_settings())) {
+			switch (type_) {
+				case wwWARE:
+					for (auto& pair : s->ware_queues) {
+						if (pair.first == index_) {
+							assert(pair.second.max_fill >= max_fill_);
+							pair.second.desired_fill = max_fill_;
+							return;
+						}
+					}
+					NEVER_HERE();
+				case wwWORKER:
+					for (auto& pair : s->worker_queues) {
+						if (pair.first == index_) {
+							assert(pair.second.max_fill >= max_fill_);
+							pair.second.desired_fill = max_fill_;
+							return;
+						}
+					}
+					NEVER_HERE();
+			}
+			NEVER_HERE();
+		}
+	} else if (upcast(Building, b, mo)) {
+		if (b->owner().player_number() == sender()) {
+			b->inputqueue(index_, type_).set_max_fill(max_fill_);
+		}
+	}
 }
 
 constexpr uint16_t kCurrentPacketVersionCmdSetInputMaxFill = 2;
@@ -1528,7 +1580,18 @@
 }
 
 void CmdChangeSoldierCapacity::execute(Game& game) {
-	if (upcast(Building, building, game.objects().get_object(serial))) {
+	MapObject* mo = game.objects().get_object(serial);
+	if (upcast(ConstructionSite, cs, mo)) {
+		assert(val >= 0);
+		uint32_t capacity = static_cast<uint32_t>(val);
+		if (upcast(MilitarysiteSettings, ms, cs->get_settings())) {
+			assert(ms->max_capacity >= capacity);
+			ms->desired_capacity = capacity;
+		} else if (upcast(TrainingsiteSettings, ts, cs->get_settings())) {
+			assert(ts->max_capacity >= capacity);
+			ts->desired_capacity = capacity;
+		}
+	} else if (upcast(Building, building, mo)) {
 		if (building->get_owner() == game.get_player(sender()) &&
 		    building->soldier_control() != nullptr) {
 			SoldierControl* soldier_control = building->mutable_soldier_control();
@@ -1750,10 +1813,10 @@
 /*** struct Cmd_SetStockPolicy ***/
 CmdSetStockPolicy::CmdSetStockPolicy(uint32_t time,
                                      PlayerNumber p,
-                                     Warehouse& wh,
+                                     Building& wh,
                                      bool isworker,
                                      DescriptionIndex ware,
-                                     Warehouse::StockPolicy policy)
+                                     StockPolicy policy)
    : PlayerCommand(time, p) {
 	warehouse_ = wh.serial();
 	isworker_ = isworker;
@@ -1768,7 +1831,16 @@
 void CmdSetStockPolicy::execute(Game& game) {
 	// Sanitize data that could have come from the network
 	if (Player* plr = game.get_player(sender())) {
-		if (upcast(Warehouse, warehouse, game.objects().get_object(warehouse_))) {
+		MapObject* mo = game.objects().get_object(warehouse_);
+		if (upcast(ConstructionSite, cs, mo)) {
+			if (upcast(WarehouseSettings, s, cs->get_settings())) {
+				if (isworker_) {
+					s->worker_preferences[ware_] = policy_;
+				} else {
+					s->ware_preferences[ware_] = policy_;
+				}
+			}
+		} else if (upcast(Warehouse, warehouse, mo)) {
 			if (warehouse->get_owner() != plr) {
 				log("Cmd_SetStockPolicy: sender %u, but warehouse owner %u\n", sender(),
 				    warehouse->owner().player_number());
@@ -1796,7 +1868,7 @@
 	warehouse_ = des.unsigned_32();
 	isworker_ = des.unsigned_8();
 	ware_ = DescriptionIndex(des.unsigned_8());
-	policy_ = static_cast<Warehouse::StockPolicy>(des.unsigned_8());
+	policy_ = static_cast<StockPolicy>(des.unsigned_8());
 }
 
 void CmdSetStockPolicy::serialize(StreamWrite& ser) {
@@ -1818,7 +1890,7 @@
 			warehouse_ = fr.unsigned_32();
 			isworker_ = fr.unsigned_8();
 			ware_ = DescriptionIndex(fr.unsigned_8());
-			policy_ = static_cast<Warehouse::StockPolicy>(fr.unsigned_8());
+			policy_ = static_cast<StockPolicy>(fr.unsigned_8());
 		} else {
 			throw UnhandledVersionError(
 			   "CmdSetStockPolicy", packet_version, kCurrentPacketVersionCmdSetStockPolicy);
@@ -1906,4 +1978,5 @@
 	// TODO(sirver,trading): Implement this.
 	NEVER_HERE();
 }
+
 }  // namespace Widelands

=== modified file 'src/logic/playercommand.h'
--- src/logic/playercommand.h	2019-05-29 16:59:16 +0000
+++ src/logic/playercommand.h	2019-06-19 09:23:26 +0000
@@ -24,6 +24,7 @@
 
 #include "economy/flag.h"
 #include "logic/cmd_queue.h"
+#include "logic/map_objects/tribes/constructionsite.h"
 #include "logic/map_objects/tribes/militarysite.h"
 #include "logic/map_objects/tribes/ship.h"
 #include "logic/map_objects/tribes/trainingsite.h"
@@ -824,10 +825,10 @@
 struct CmdSetStockPolicy : PlayerCommand {
 	CmdSetStockPolicy(uint32_t time,
 	                  PlayerNumber p,
-	                  Warehouse& wh,
+	                  Building& wh,
 	                  bool isworker,
 	                  DescriptionIndex ware,
-	                  Warehouse::StockPolicy policy);
+	                  StockPolicy policy);
 
 	QueueCommandTypes id() const override {
 		return QueueCommandTypes::kSetStockPolicy;
@@ -848,7 +849,7 @@
 	Serial warehouse_;
 	bool isworker_;
 	DescriptionIndex ware_;
-	Warehouse::StockPolicy policy_;
+	StockPolicy policy_;
 };
 
 struct CmdProposeTrade : PlayerCommand {
@@ -872,6 +873,7 @@
 private:
 	Trade trade_;
 };
+
 }  // namespace Widelands
 
 #endif  // end of include guard: WL_LOGIC_PLAYERCOMMAND_H

=== modified file 'src/map_io/map_buildingdata_packet.cc'
--- src/map_io/map_buildingdata_packet.cc	2019-06-13 17:32:28 +0000
+++ src/map_io/map_buildingdata_packet.cc	2019-06-19 09:23:26 +0000
@@ -60,7 +60,7 @@
 
 // Building type package versions
 constexpr uint16_t kCurrentPacketVersionDismantlesite = 1;
-constexpr uint16_t kCurrentPacketVersionConstructionsite = 3;
+constexpr uint16_t kCurrentPacketVersionConstructionsite = 4;
 constexpr uint16_t kCurrentPacketPFBuilding = 1;
 // Responsible for warehouses and expedition bootstraps
 constexpr uint16_t kCurrentPacketVersionWarehouse = 7;
@@ -274,7 +274,7 @@
    const TribesLegacyLookupTable& tribes_lookup_table) {
 	try {
 		uint16_t const packet_version = fr.unsigned_16();
-		if (packet_version >= kCurrentPacketVersionConstructionsite) {
+		if (packet_version >= 3) {
 			read_partially_finished_building(constructionsite, fr, game, mol, tribes_lookup_table);
 
 			for (ConstructionSite::Wares::iterator wares_iter = constructionsite.wares_.begin();
@@ -284,6 +284,18 @@
 			}
 
 			constructionsite.fetchfromflag_ = fr.signed_32();
+
+			if (packet_version >= 4) {
+				const uint32_t intermediates = fr.unsigned_32();
+				for (uint32_t i = 0; i < intermediates; ++i) {
+					constructionsite.info_.intermediates.push_back(game.tribes().get_building_descr(
+							game.tribes().building_index(fr.c_string())));
+				}
+				constructionsite.settings_.reset(BuildingSettings::load(game,
+						constructionsite.owner().tribe(), fr));
+			} else {
+				constructionsite.init_settings();
+			}
 		} else {
 			throw UnhandledVersionError("MapBuildingdataPacket - Constructionsite", packet_version,
 			                            kCurrentPacketVersionConstructionsite);
@@ -329,7 +341,7 @@
 				const DescriptionIndex& id =
 				   tribe.ware_index(tribes_lookup_table.lookup_ware(fr.c_string()));
 				Quantity amount = fr.unsigned_32();
-				Warehouse::StockPolicy policy = static_cast<Warehouse::StockPolicy>(fr.unsigned_8());
+				StockPolicy policy = static_cast<StockPolicy>(fr.unsigned_8());
 
 				if (game.tribes().ware_exists(id)) {
 					warehouse.insert_wares(id, amount);
@@ -340,7 +352,7 @@
 				const DescriptionIndex& id =
 				   tribe.worker_index(tribes_lookup_table.lookup_worker(fr.c_string()));
 				uint32_t amount = fr.unsigned_32();
-				Warehouse::StockPolicy policy = static_cast<Warehouse::StockPolicy>(fr.unsigned_8());
+				StockPolicy policy = static_cast<StockPolicy>(fr.unsigned_8());
 
 				if (game.tribes().worker_exists(id)) {
 					warehouse.insert_workers(id, amount);
@@ -978,6 +990,14 @@
 	write_partially_finished_building(constructionsite, fw, game, mos);
 
 	fw.signed_32(constructionsite.fetchfromflag_);
+
+	fw.unsigned_32(constructionsite.info_.intermediates.size());
+	for (const BuildingDescr* d : constructionsite.info_.intermediates) {
+		fw.c_string(d->name().c_str());
+	}
+
+	assert(constructionsite.settings_);
+	constructionsite.settings_->save(game, fw);
 }
 
 void MapBuildingdataPacket::write_dismantlesite(const DismantleSite& dms,

=== modified file 'src/notifications/note_ids.h'
--- src/notifications/note_ids.h	2019-05-10 17:43:19 +0000
+++ src/notifications/note_ids.h	2019-06-19 09:23:26 +0000
@@ -29,6 +29,7 @@
 	ChatMessage,
 	LogMessage,
 	Immovable,
+	ConstructionsiteEnhanced,
 	FieldPossession,
 	FieldTerrainChanged,
 	ProductionSiteOutOfResources,

=== modified file 'src/scripting/lua_map.cc'
--- src/scripting/lua_map.cc	2019-05-04 10:47:44 +0000
+++ src/scripting/lua_map.cc	2019-06-19 09:23:26 +0000
@@ -4871,39 +4871,39 @@
 }
 
 // Transforms the given warehouse policy to a string which is used by the lua code
-inline void wh_policy_to_string(lua_State* L, Warehouse::StockPolicy p) {
+inline void wh_policy_to_string(lua_State* L, StockPolicy p) {
 	switch (p) {
-	case Warehouse::StockPolicy::kNormal:
+	case StockPolicy::kNormal:
 		lua_pushstring(L, "normal");
 		break;
-	case Warehouse::StockPolicy::kPrefer:
+	case StockPolicy::kPrefer:
 		lua_pushstring(L, "prefer");
 		break;
-	case Warehouse::StockPolicy::kDontStock:
+	case StockPolicy::kDontStock:
 		lua_pushstring(L, "dontstock");
 		break;
-	case Warehouse::StockPolicy::kRemove:
+	case StockPolicy::kRemove:
 		lua_pushstring(L, "remove");
 		break;
 	}
 }
 // Transforms the given string from the lua code to a warehouse policy
-inline Warehouse::StockPolicy string_to_wh_policy(lua_State* L, uint32_t index) {
+inline StockPolicy string_to_wh_policy(lua_State* L, uint32_t index) {
 	std::string str = luaL_checkstring(L, index);
 	if (str == "normal")
-		return Warehouse::StockPolicy::kNormal;
+		return StockPolicy::kNormal;
 	else if (str == "prefer")
-		return Warehouse::StockPolicy::kPrefer;
+		return StockPolicy::kPrefer;
 	else if (str == "dontstock")
-		return Warehouse::StockPolicy::kDontStock;
+		return StockPolicy::kDontStock;
 	else if (str == "remove")
-		return Warehouse::StockPolicy::kRemove;
+		return StockPolicy::kRemove;
 	else
 		report_error(L, "<%s> is no valid warehouse policy!", str.c_str());
 }
 
 inline bool
-do_set_ware_policy(Warehouse* wh, const DescriptionIndex idx, const Warehouse::StockPolicy p) {
+do_set_ware_policy(Warehouse* wh, const DescriptionIndex idx, const StockPolicy p) {
 	wh->set_ware_policy(idx, p);
 	return true;
 }
@@ -4913,7 +4913,7 @@
  * If the no ware with the given name exists for the tribe of the warehouse, return false.
  */
 inline bool
-do_set_ware_policy(Warehouse* wh, const std::string& name, const Warehouse::StockPolicy p) {
+do_set_ware_policy(Warehouse* wh, const std::string& name, const StockPolicy p) {
 	const TribeDescr& tribe = wh->owner().tribe();
 	DescriptionIndex idx = tribe.ware_index(name);
 	if (!tribe.has_ware(idx)) {
@@ -4923,7 +4923,7 @@
 }
 
 inline bool
-do_set_worker_policy(Warehouse* wh, const DescriptionIndex idx, const Warehouse::StockPolicy p) {
+do_set_worker_policy(Warehouse* wh, const DescriptionIndex idx, const StockPolicy p) {
 	const TribeDescr& tribe = wh->owner().tribe();
 	// If the worker does not cost anything, ignore it
 	// Otherwise, an unlimited stream of carriers might leave the warehouse
@@ -4942,7 +4942,7 @@
  * If no worker with the given name exists for the tribe of the warehouse, return false.
  */
 inline bool
-do_set_worker_policy(Warehouse* wh, const std::string& name, const Warehouse::StockPolicy p) {
+do_set_worker_policy(Warehouse* wh, const std::string& name, const StockPolicy p) {
 	const TribeDescr& tribe = wh->owner().tribe();
 	DescriptionIndex idx = tribe.worker_index(name);
 	if (!tribe.has_worker(idx)) {
@@ -4972,7 +4972,7 @@
 		report_error(L, "Wrong number of arguments to set_warehouse_policies!");
 
 	Warehouse* wh = get(L, get_egbase(L));
-	Warehouse::StockPolicy p = string_to_wh_policy(L, -1);
+	StockPolicy p = string_to_wh_policy(L, -1);
 	lua_pop(L, 1);
 	const TribeDescr& tribe = wh->owner().tribe();
 

=== modified file 'src/wui/actionconfirm.cc'
--- src/wui/actionconfirm.cc	2019-04-28 16:53:20 +0000
+++ src/wui/actionconfirm.cc	2019-06-19 09:23:26 +0000
@@ -92,7 +92,8 @@
 struct EnhanceConfirm : public ActionConfirm {
 	EnhanceConfirm(InteractivePlayer& parent,
 	               Widelands::Building& building,
-	               const Widelands::DescriptionIndex& id);
+	               const Widelands::DescriptionIndex& id,
+                   bool still_under_construction);
 
 	void think() override;
 	void ok() override;
@@ -100,6 +101,7 @@
 private:
 	// Do not make this a reference - it is a stack variable in the caller
 	const Widelands::DescriptionIndex id_;
+	bool still_under_construction_;
 };
 
 /**
@@ -259,7 +261,8 @@
 */
 EnhanceConfirm::EnhanceConfirm(InteractivePlayer& parent,
                                Widelands::Building& building,
-                               const Widelands::DescriptionIndex& id)
+                               const Widelands::DescriptionIndex& id,
+                          bool still_under_construction)
    : ActionConfirm(
         parent,
         _("Enhance building?"),
@@ -270,7 +273,8 @@
               .str() :
            _("Do you really want to enhance this building?"),
         building),
-     id_(id) {
+     id_(id),
+     still_under_construction_(still_under_construction) {
 	// Nothing special to do
 }
 
@@ -284,7 +288,7 @@
 	upcast(Widelands::Building, building, object_.get(egbase));
 
 	if (!building || !iaplayer().can_act(building->owner().player_number()) ||
-	    !(building->get_playercaps() & Widelands::Building::PCap_Enhancable))
+	    !(still_under_construction_ || (building->get_playercaps() & Widelands::Building::PCap_Enhancable)))
 		die();
 }
 
@@ -293,11 +297,18 @@
  */
 void EnhanceConfirm::ok() {
 	Widelands::Game& game = iaplayer().game();
-	upcast(Widelands::Building, building, object_.get(game));
 
-	if (building && iaplayer().can_act(building->owner().player_number()) &&
-	    (building->get_playercaps() & Widelands::Building::PCap_Enhancable)) {
-		game.send_player_enhance_building(*building, id_);
+	if (still_under_construction_) {
+		upcast(Widelands::ConstructionSite, cs, object_.get(game));
+		if (cs && iaplayer().can_act(cs->owner().player_number())) {
+			game.send_player_enhance_building(*cs, Widelands::INVALID_INDEX);
+		}
+	} else {
+		upcast(Widelands::Building, building, object_.get(game));
+		if (building && iaplayer().can_act(building->owner().player_number()) &&
+			(building->get_playercaps() & Widelands::Building::PCap_Enhancable)) {
+			game.send_player_enhance_building(*building, id_);
+		}
 	}
 
 	die();
@@ -419,8 +430,9 @@
  */
 void show_enhance_confirm(InteractivePlayer& player,
                           Widelands::Building& building,
-                          const Widelands::DescriptionIndex& id) {
-	new EnhanceConfirm(player, building, id);
+                          const Widelands::DescriptionIndex& id,
+                          bool constructionsite) {
+	new EnhanceConfirm(player, building, id, constructionsite);
 }
 
 /**

=== modified file 'src/wui/actionconfirm.h'
--- src/wui/actionconfirm.h	2019-02-23 11:00:49 +0000
+++ src/wui/actionconfirm.h	2019-06-19 09:23:26 +0000
@@ -39,7 +39,8 @@
 
 void show_enhance_confirm(InteractivePlayer& player,
                           Widelands::Building& building,
-                          const Widelands::DescriptionIndex& id);
+                          const Widelands::DescriptionIndex& id,
+                          bool still_under_construction = false);
 
 // Ship confirm windows
 void show_ship_sink_confirm(InteractivePlayer& player, Widelands::Ship& ship);

=== modified file 'src/wui/buildingwindow.cc'
--- src/wui/buildingwindow.cc	2019-05-26 17:21:15 +0000
+++ src/wui/buildingwindow.cc	2019-06-19 09:23:26 +0000
@@ -54,7 +54,7 @@
      is_dying_(false),
      parent_(&parent),
      building_(&b),
-     building_descr_for_help_(descr),
+     building_descr_for_help_(&descr),
      building_position_(b.get_position()),
      showing_workarea_(false),
      avoid_fastclick_(avoid_fastclick),
@@ -363,14 +363,14 @@
 		                  g_gr->images().get("images/ui_basic/menu_help.png"), _("Help"));
 
 		UI::UniqueWindow::Registry& registry =
-		   igbase()->unique_windows().get_registry(building_descr_for_help_.name() + "_help");
+		   igbase()->unique_windows().get_registry(building_descr_for_help_->name() + "_help");
 		registry.open_window = [this, &registry] {
 			if (parent_ != nullptr) {
 				Widelands::Building* building_in_lambda = building_.get(parent_->egbase());
 				if (building_in_lambda == nullptr) {
 					return;
 				}
-				new UI::BuildingHelpWindow(igbase(), registry, building_descr_for_help_,
+				new UI::BuildingHelpWindow(igbase(), registry, *building_descr_for_help_,
 				                           building_in_lambda->owner().tribe(),
 				                           &parent_->egbase().lua());
 			}

=== modified file 'src/wui/buildingwindow.h'
--- src/wui/buildingwindow.h	2019-02-23 11:00:49 +0000
+++ src/wui/buildingwindow.h	2019-06-19 09:23:26 +0000
@@ -95,6 +95,10 @@
 
 	bool is_dying_;
 
+	void set_building_descr_for_help(const Widelands::BuildingDescr* d) {
+		building_descr_for_help_ = d;
+	}
+
 private:
 	void create_capsbuttons(UI::Box* buttons, Widelands::Building* building);
 
@@ -110,7 +114,7 @@
 	Widelands::OPtr<Widelands::Building> building_;
 
 	// The building description that will be used for the help button
-	const Widelands::BuildingDescr& building_descr_for_help_;
+	const Widelands::BuildingDescr* building_descr_for_help_;
 
 	// We require this to unregister overlays when we are closed. Since the
 	// building might have been destroyed by then we have to keep a copy of its

=== modified file 'src/wui/constructionsitewindow.cc'
--- src/wui/constructionsitewindow.cc	2019-02-23 11:00:49 +0000
+++ src/wui/constructionsitewindow.cc	2019-06-19 09:23:26 +0000
@@ -22,9 +22,67 @@
 #include <boost/format.hpp>
 
 #include "graphic/graphic.h"
+#include "wui/actionconfirm.h"
 #include "wui/inputqueuedisplay.h"
+#include "wui/interactive_player.h"
 
 static const char pic_tab_wares[] = "images/wui/buildings/menu_tab_wares.png";
+static const char pic_tab_settings[] = "images/wui/menus/menu_stock.png";
+static const char pic_tab_settings_wares[] = "images/wui/stats/menu_tab_wares_warehouse.png";
+static const char pic_tab_settings_workers[] = "images/wui/stats/menu_tab_workers_warehouse.png";
+static const char pic_max_fill_indicator[] = "images/wui/buildings/max_fill_indicator.png";
+static const char pic_priority_low[] = "images/wui/buildings/low_priority_button.png";
+static const char pic_priority_normal[] = "images/wui/buildings/normal_priority_button.png";
+static const char pic_priority_high[] = "images/wui/buildings/high_priority_button.png";
+static const char pic_stock_policy_prefer[] = "images/wui/buildings/stock_policy_prefer.png";
+static const char pic_stock_policy_dontstock[] = "images/wui/buildings/stock_policy_dontstock.png";
+static const char pic_stock_policy_remove[] = "images/wui/buildings/stock_policy_remove.png";
+static const char pic_stock_policy_button_normal[] = "images/wui/buildings/stock_policy_button_normal.png";
+static const char pic_stock_policy_button_prefer[] = "images/wui/buildings/stock_policy_button_prefer.png";
+static const char pic_stock_policy_button_dontstock[] = "images/wui/buildings/stock_policy_button_dontstock.png";
+static const char pic_stock_policy_button_remove[] = "images/wui/buildings/stock_policy_button_remove.png";
+static const char pic_decrease_capacity[] = "images/wui/buildings/menu_down_train.png";
+static const char pic_increase_capacity[] = "images/wui/buildings/menu_up_train.png";
+
+ConstructionSiteWindow::FakeWaresDisplay::FakeWaresDisplay(UI::Panel* parent,
+														  bool can_act,
+														  Widelands::ConstructionSite& cs,
+														  Widelands::WareWorker type)
+	: WaresDisplay(parent, 0, 0, cs.owner().tribe(), type, can_act),
+	  settings_(*dynamic_cast<Widelands::WarehouseSettings*>(cs.get_settings())),
+	  tribe_(cs.owner().tribe()) {
+}
+
+void ConstructionSiteWindow::FakeWaresDisplay::draw_ware(RenderTarget& dst, Widelands::DescriptionIndex ware) {
+	if (get_type() == Widelands::wwWORKER && std::find(tribe_.worker_types_without_cost().begin(),
+			tribe_.worker_types_without_cost().end(), ware) != tribe_.worker_types_without_cost().end()) {
+		return;
+	}
+	WaresDisplay::draw_ware(dst, ware);
+
+	const auto& map = get_type() == Widelands::wwWARE ? settings_.ware_preferences : settings_.worker_preferences;
+	const auto it = map.find(ware);
+	if (it == map.end()) {
+		return;
+	}
+	const Image* pic = nullptr;
+	switch (it->second) {
+	case Widelands::StockPolicy::kPrefer:
+		pic = g_gr->images().get(pic_stock_policy_prefer);
+		break;
+	case Widelands::StockPolicy::kDontStock:
+		pic = g_gr->images().get(pic_stock_policy_dontstock);
+		break;
+	case Widelands::StockPolicy::kRemove:
+		pic = g_gr->images().get(pic_stock_policy_remove);
+		break;
+	case Widelands::StockPolicy::kNormal:
+		// No icon for the normal policy
+		return;
+	}
+	assert(pic);
+	dst.blit(ware_position(ware), pic);
+}
 
 ConstructionSiteWindow::ConstructionSiteWindow(InteractiveGameBase& parent,
                                                UI::UniqueWindow::Registry& reg,
@@ -33,13 +91,23 @@
                                                bool workarea_preview_wanted)
    : BuildingWindow(parent, reg, cs, cs.building(), avoid_fastclick),
      construction_site_(&cs),
-     progress_(nullptr) {
+     progress_(nullptr),
+		cs_enhance_(nullptr),
+		cs_launch_expedition_(nullptr),
+		cs_prefer_heroes_rookies_(nullptr),
+		cs_soldier_capacity_decrease_(nullptr),
+		cs_soldier_capacity_increase_(nullptr),
+		cs_soldier_capacity_display_(nullptr),
+		cs_stopped_(nullptr),
+		cs_warehouse_wares_(nullptr),
+		cs_warehouse_workers_(nullptr) {
 	init(avoid_fastclick, workarea_preview_wanted);
 }
 
 void ConstructionSiteWindow::init(bool avoid_fastclick, bool workarea_preview_wanted) {
 	Widelands::ConstructionSite* construction_site = construction_site_.get(igbase()->egbase());
 	assert(construction_site != nullptr);
+	set_building_descr_for_help(&construction_site->building());
 
 	BuildingWindow::init(avoid_fastclick, workarea_preview_wanted);
 	UI::Box& box = *new UI::Box(get_tabs(), 0, 0, UI::Box::Vertical);
@@ -59,10 +127,245 @@
 
 	get_tabs()->add("wares", g_gr->images().get(pic_tab_wares), &box, _("Building materials"));
 
+	if (construction_site->get_settings()) {
+		const bool can_act = igbase()->can_act(construction_site->owner().player_number());
+		// Create the settings. Since we don't access an actual building, we create
+		// a simplified faksimile of the later building window that contains only
+		// the relevant options.
+		bool nothing_added = false;
+		UI::Box& settings_box = *new UI::Box(get_tabs(), 0, 0, UI::Box::Vertical);
+		if (upcast(Widelands::ProductionsiteSettings, ps, construction_site->get_settings())) {
+			for (const auto& pair : ps->ware_queues) {
+				InputQueueDisplay* queue = new InputQueueDisplay(&settings_box, 0, 0, *igbase(),
+						*construction_site, Widelands::wwWARE, pair.first);
+				settings_box.add(queue);
+				settings_box.add_space(8);
+				cs_ware_queues_.push_back(queue);
+			}
+			for (const auto& pair : ps->worker_queues) {
+				InputQueueDisplay* queue = new InputQueueDisplay(&settings_box, 0, 0, *igbase(),
+						*construction_site, Widelands::wwWORKER, pair.first);
+				settings_box.add(queue);
+				settings_box.add_space(8);
+				cs_ware_queues_.push_back(queue);
+			}
+			if (upcast(Widelands::TrainingsiteSettings, ts, ps)) {
+				UI::Box& soldier_capacity_box = *new UI::Box(&settings_box, 0, 0, UI::Box::Horizontal);
+				settings_box.add(&soldier_capacity_box, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+				cs_soldier_capacity_decrease_ = new UI::Button(&soldier_capacity_box,
+						"decrease", 0, 0, 32, 32, UI::ButtonStyle::kWuiMenu,
+						g_gr->images().get(pic_decrease_capacity),
+						_("Decrease capacity. Hold down Ctrl to set the capacity to the lowest value"));
+				cs_soldier_capacity_increase_ = new UI::Button(&soldier_capacity_box,
+						"increase", 0, 0, 32, 32, UI::ButtonStyle::kWuiMenu,
+						g_gr->images().get(pic_increase_capacity),
+						_("Increase capacity. Hold down Ctrl to set the capacity to the highest value"));
+				cs_soldier_capacity_display_ = new UI::Textarea(&soldier_capacity_box,
+						"", UI::Align::kCenter);
+				cs_soldier_capacity_decrease_->set_enabled(can_act);
+				cs_soldier_capacity_increase_->set_enabled(can_act);
+				cs_soldier_capacity_decrease_->sigclicked.connect([this, ts]() {
+					igbase()->game().send_player_change_soldier_capacity(
+							*construction_site_.get(igbase()->egbase()),
+							SDL_GetModState() & KMOD_CTRL ? 0 : ts->desired_capacity - 1);
+					});
+				cs_soldier_capacity_increase_->sigclicked.connect([this, ts]() {
+					igbase()->game().send_player_change_soldier_capacity(
+							*construction_site_.get(igbase()->egbase()),
+							SDL_GetModState() & KMOD_CTRL ? ts->max_capacity : ts->desired_capacity + 1);
+					});
+				soldier_capacity_box.add(cs_soldier_capacity_decrease_);
+				soldier_capacity_box.add_space(8);
+				soldier_capacity_box.add(cs_soldier_capacity_display_, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+				soldier_capacity_box.add_space(8);
+				soldier_capacity_box.add(cs_soldier_capacity_increase_);
+				settings_box.add_space(8);
+			}
+			cs_stopped_ = new UI::Checkbox(&settings_box, Vector2i::zero(),
+				 _("Stopped"),
+				 _("Stop this building’s work after completion"));
+			cs_stopped_->clickedto.connect([this, ps](bool stop) {
+				if (stop != ps->stopped) {
+					igbase()->game().send_player_start_stop_building(*construction_site_.get(igbase()->egbase()));
+				}
+			});
+			settings_box.add(cs_stopped_, UI::Box::Resizing::kFullSize);
+			settings_box.add_space(8);
+			cs_stopped_->set_enabled(can_act);
+		} else if (upcast(Widelands::MilitarysiteSettings, ms, construction_site->get_settings())) {
+			UI::Box& soldier_capacity_box = *new UI::Box(&settings_box, 0, 0, UI::Box::Horizontal);
+			settings_box.add(&soldier_capacity_box, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+			cs_soldier_capacity_decrease_ = new UI::Button(&soldier_capacity_box,
+					"decrease", 0, 0, 32, 32, UI::ButtonStyle::kWuiMenu,
+					g_gr->images().get(pic_decrease_capacity),
+					_("Decrease capacity. Hold down Ctrl to set the capacity to the lowest value"));
+			cs_soldier_capacity_increase_ = new UI::Button(&soldier_capacity_box,
+					"increase", 0, 0, 32, 32, UI::ButtonStyle::kWuiMenu,
+					g_gr->images().get(pic_increase_capacity),
+					_("Increase capacity. Hold down Ctrl to set the capacity to the highest value"));
+			cs_soldier_capacity_display_ = new UI::Textarea(&soldier_capacity_box,
+					"", UI::Align::kCenter);
+			cs_soldier_capacity_decrease_->set_enabled(can_act);
+			cs_soldier_capacity_increase_->set_enabled(can_act);
+			cs_soldier_capacity_decrease_->sigclicked.connect([this, ms]() {
+				igbase()->game().send_player_change_soldier_capacity(
+						*construction_site_.get(igbase()->egbase()),
+						SDL_GetModState() & KMOD_CTRL ? 0 : ms->desired_capacity - 1);
+				});
+			cs_soldier_capacity_increase_->sigclicked.connect([this, ms]() {
+				igbase()->game().send_player_change_soldier_capacity(
+						*construction_site_.get(igbase()->egbase()),
+						SDL_GetModState() & KMOD_CTRL ? ms->max_capacity : ms->desired_capacity + 1);
+				});
+			soldier_capacity_box.add(cs_soldier_capacity_decrease_);
+			soldier_capacity_box.add_space(8);
+			soldier_capacity_box.add(cs_soldier_capacity_display_, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+			soldier_capacity_box.add_space(8);
+			soldier_capacity_box.add(cs_soldier_capacity_increase_);
+			settings_box.add_space(8);
+
+			UI::Box& soldier_preference_box = *new UI::Box(&settings_box, 0, 0, UI::Box::Horizontal);
+			settings_box.add(&soldier_preference_box, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+			UI::Panel& soldier_preference_panel = *new UI::Panel(&soldier_preference_box, 0, 0, 64, 32);
+			soldier_preference_box.add(&soldier_preference_panel);
+			cs_prefer_heroes_rookies_.reset(new UI::Radiogroup());
+			cs_prefer_heroes_rookies_->add_button(&soldier_preference_panel, Vector2i::zero(),
+					g_gr->images().get("images/wui/buildings/prefer_rookies.png"),
+					_("Prefer rookies"));
+			cs_prefer_heroes_rookies_->add_button(&soldier_preference_panel, Vector2i(32, 0),
+					g_gr->images().get("images/wui/buildings/prefer_heroes.png"),
+					_("Prefer heroes"));
+			if (can_act) {
+				cs_prefer_heroes_rookies_->changedto.connect([this](int32_t state) {
+					igbase()->game().send_player_militarysite_set_soldier_preference(
+							*construction_site_.get(igbase()->egbase()),
+							state ? Widelands::SoldierPreference::kHeroes : Widelands::SoldierPreference::kRookies);
+				});
+			}
+			settings_box.add_space(8);
+		} else if (upcast(Widelands::WarehouseSettings, ws, construction_site->get_settings())) {
+			auto add_tab = [this, construction_site, can_act](Widelands::WareWorker ww, FakeWaresDisplay** display) {
+				UI::Box& mainbox = *new UI::Box(get_tabs(), 0, 0, UI::Box::Vertical);
+				*display = new FakeWaresDisplay(&mainbox, can_act, *construction_site, ww);
+				mainbox.add(*display, UI::Box::Resizing::kFullSize);
+				mainbox.add_space(8);
+				UI::Box& buttonsbox = *new UI::Box(&mainbox, 0, 0, UI::Box::Horizontal);
+				mainbox.add(&buttonsbox, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+				mainbox.add_space(8);
+				UI::Button& sp_normal = *new UI::Button(&buttonsbox, "stock_policy_normal", 0, 0, 34, 34,
+						UI::ButtonStyle::kWuiMenu, g_gr->images().get(pic_stock_policy_button_normal),
+						_("Normal policy"));
+				UI::Button& sp_prefer = *new UI::Button(&buttonsbox, "stock_policy_prefer", 0, 0, 34, 34,
+						UI::ButtonStyle::kWuiMenu, g_gr->images().get(pic_stock_policy_button_prefer),
+						_("Preferably store selected wares here"));
+				UI::Button& sp_dont = *new UI::Button(&buttonsbox, "stock_policy_dontstock", 0, 0, 34, 34,
+						UI::ButtonStyle::kWuiMenu, g_gr->images().get(pic_stock_policy_button_dontstock),
+						_("Do not store selected wares here"));
+				UI::Button& sp_remove = *new UI::Button(&buttonsbox, "stock_policy_remove", 0, 0, 34, 34,
+						UI::ButtonStyle::kWuiMenu, g_gr->images().get(pic_stock_policy_button_remove),
+						_("Remove selected wares from here"));
+				sp_remove.sigclicked.connect(
+						boost::bind(&ConstructionSiteWindow::change_policy, this, ww, Widelands::StockPolicy::kRemove));
+				sp_dont.sigclicked.connect(
+						boost::bind(&ConstructionSiteWindow::change_policy, this, ww, Widelands::StockPolicy::kDontStock));
+				sp_prefer.sigclicked.connect(
+						boost::bind(&ConstructionSiteWindow::change_policy, this, ww, Widelands::StockPolicy::kPrefer));
+				sp_normal.sigclicked.connect(
+						boost::bind(&ConstructionSiteWindow::change_policy, this, ww, Widelands::StockPolicy::kNormal));
+				sp_normal.set_enabled(can_act);
+				sp_dont.set_enabled(can_act);
+				sp_remove.set_enabled(can_act);
+				sp_prefer.set_enabled(can_act);
+				buttonsbox.add(&sp_normal);
+				buttonsbox.add_space(8);
+				buttonsbox.add(&sp_prefer);
+				buttonsbox.add_space(8);
+				buttonsbox.add(&sp_dont);
+				buttonsbox.add_space(8);
+				buttonsbox.add(&sp_remove);
+				if (ww == Widelands::wwWARE) {
+					get_tabs()->add("warehouse_wares", g_gr->images().get(pic_tab_settings_wares),
+							&mainbox, _("Ware settings to apply after construction"));
+				} else {
+					get_tabs()->add("warehouse_workers", g_gr->images().get(pic_tab_settings_workers),
+							&mainbox, _("Worker settings to apply after construction"));
+				}
+			};
+			add_tab(Widelands::wwWARE, &cs_warehouse_wares_);
+			add_tab(Widelands::wwWORKER, &cs_warehouse_workers_);
+			if (construction_site->get_info().becomes->get_isport()) {
+				cs_launch_expedition_ = new UI::Checkbox(&settings_box, Vector2i::zero(),
+					 _("Start an expedition"),
+					 _("Start an expedition from this port after completion"));
+				cs_launch_expedition_->clickedto.connect([this, ws](bool launch) {
+					if (launch != ws->launch_expedition) {
+						igbase()->game().send_player_start_or_cancel_expedition(
+								*construction_site_.get(igbase()->egbase()));
+					}
+				});
+				settings_box.add(cs_launch_expedition_, UI::Box::Resizing::kFullSize);
+				settings_box.add_space(8);
+				cs_launch_expedition_->set_enabled(can_act);
+			} else {
+				nothing_added = true;
+			}
+		} else {
+			NEVER_HERE();
+		}
+
+		if (can_act && construction_site->get_info().becomes->enhancement() != Widelands::INVALID_INDEX) {
+			const Widelands::BuildingDescr& building_descr = *igbase()->egbase().tribes().get_building_descr(
+				construction_site->get_info().becomes->enhancement());
+			std::string enhance_tooltip =
+			   (boost::format(_("Enhance to %s")) % building_descr.descname().c_str()).str() +
+			   "<br><font size=11>" + _("Construction costs:") + "</font><br>" +
+			   waremap_to_richtext(construction_site->owner().tribe(), building_descr.enhancement_cost());
+			cs_enhance_ = new UI::Button(&settings_box, "enhance", 0, 0, 34, 34, UI::ButtonStyle::kWuiMenu,
+			                  building_descr.icon(), enhance_tooltip);
+			cs_enhance_->sigclicked.connect([this, construction_site] {
+				if (SDL_GetModState() & KMOD_CTRL) {
+					igbase()->game().send_player_enhance_building(*construction_site, Widelands::INVALID_INDEX);
+				} else {
+				show_enhance_confirm(dynamic_cast<InteractivePlayer&>(*igbase()),
+						*construction_site, construction_site->get_info().becomes->enhancement(), true);
+				}
+			});
+			settings_box.add(cs_enhance_, UI::Box::Resizing::kAlign, UI::Align::kCenter);
+			settings_box.add_space(8);
+			nothing_added = false;
+		}
+		if (!nothing_added) {
+			get_tabs()->add("settings", g_gr->images().get(pic_tab_settings),
+					&settings_box, _("Settings to apply after construction"));
+		}
+	}
+
 	set_title((boost::format("(%s)") % construction_site->building().descname()).str());
 	think();
 }
 
+void ConstructionSiteWindow::change_policy(Widelands::WareWorker ww, Widelands::StockPolicy p) {
+	Widelands::ConstructionSite* construction_site = construction_site_.get(igbase()->egbase());
+	assert(construction_site);
+	upcast(Widelands::WarehouseSettings, ws, construction_site->get_settings());
+	assert(ws);
+	if (ww == Widelands::wwWARE) {
+		for (const auto& pair : ws->ware_preferences) {
+			if (cs_warehouse_wares_->ware_selected(pair.first)) {
+				igbase()->game().send_player_set_stock_policy(*construction_site,
+						Widelands::wwWARE, pair.first, p);
+			}
+		}
+	} else {
+		for (const auto& pair : ws->worker_preferences) {
+			if (cs_warehouse_workers_->ware_selected(pair.first)) {
+				igbase()->game().send_player_set_stock_policy(*construction_site,
+						Widelands::wwWORKER, pair.first, p);
+			}
+		}
+	}
+}
+
 /*
 ===============
 Make sure the window is redrawn when necessary.
@@ -77,5 +380,41 @@
 	if (construction_site == nullptr) {
 		return;
 	}
+
 	progress_->set_state(construction_site->get_built_per64k());
+
+	const bool can_act = igbase()->can_act(construction_site->owner().player_number());
+	// InputQueueDisplay and FakeWaresDisplay update themselves – we need to refresh the other settings
+	if (upcast(Widelands::ProductionsiteSettings, ps, construction_site->get_settings())) {
+		assert(cs_stopped_);
+		cs_stopped_->set_state(ps->stopped);
+	}
+	if (upcast(Widelands::TrainingsiteSettings, ts, construction_site->get_settings())) {
+		assert(cs_soldier_capacity_decrease_);
+		assert(cs_soldier_capacity_increase_);
+		assert(cs_soldier_capacity_display_);
+		cs_soldier_capacity_display_->set_text((boost::format(ngettext("%u soldier", "%u soldiers",
+				ts->desired_capacity)) % ts->desired_capacity).str());
+		cs_soldier_capacity_decrease_->set_enabled(can_act && ts->desired_capacity > 0);
+		cs_soldier_capacity_increase_->set_enabled(can_act && ts->desired_capacity < ts->max_capacity);
+	} else if (upcast(Widelands::MilitarysiteSettings, ms, construction_site->get_settings())) {
+		assert(cs_soldier_capacity_decrease_);
+		assert(cs_soldier_capacity_increase_);
+		assert(cs_soldier_capacity_display_);
+		assert(cs_prefer_heroes_rookies_);
+		cs_soldier_capacity_display_->set_text((boost::format(ngettext("%u soldier", "%u soldiers",
+				ms->desired_capacity)) % ms->desired_capacity).str());
+		cs_soldier_capacity_decrease_->set_enabled(can_act && ms->desired_capacity > 1);
+		cs_soldier_capacity_increase_->set_enabled(can_act && ms->desired_capacity < ms->max_capacity);
+		cs_prefer_heroes_rookies_->set_state(ms->prefer_heroes ? 1 : 0);
+	} else if (upcast(Widelands::WarehouseSettings, ws, construction_site->get_settings())) {
+		if (cs_launch_expedition_) {
+			cs_launch_expedition_->set_state(ws->launch_expedition);
+		}
+#ifndef NDEBUG
+		else {
+			assert(!ws->launch_expedition);
+		}
+#endif
+	}
 }

=== modified file 'src/wui/constructionsitewindow.h'
--- src/wui/constructionsitewindow.h	2019-02-23 11:00:49 +0000
+++ src/wui/constructionsitewindow.h	2019-06-19 09:23:26 +0000
@@ -20,9 +20,18 @@
 #ifndef WL_WUI_CONSTRUCTIONSITEWINDOW_H
 #define WL_WUI_CONSTRUCTIONSITEWINDOW_H
 
+#include <memory>
+#include <vector>
+
 #include "logic/map_objects/tribes/constructionsite.h"
+#include "ui_basic/button.h"
+#include "ui_basic/checkbox.h"
 #include "ui_basic/progressbar.h"
+#include "ui_basic/radiobutton.h"
+#include "ui_basic/tabpanel.h"
+#include "ui_basic/textarea.h"
 #include "wui/buildingwindow.h"
+#include "wui/inputqueuedisplay.h"
 
 /**
  * Status window for construction sites.
@@ -40,8 +49,38 @@
 	void init(bool avoid_fastclick, bool workarea_preview_wanted) override;
 
 private:
+	class FakeWaresDisplay : public WaresDisplay {
+	public:
+		FakeWaresDisplay(UI::Panel* parent,
+		                  bool can_act,
+		                  Widelands::ConstructionSite& cs,
+		                  Widelands::WareWorker type);
+
+	protected:
+		void draw_ware(RenderTarget& dst, Widelands::DescriptionIndex ware) override;
+
+	private:
+		Widelands::WarehouseSettings& settings_;
+		const Widelands::TribeDescr& tribe_;
+	};
+
 	Widelands::OPtr<Widelands::ConstructionSite> construction_site_;
 	UI::ProgressBar* progress_;
+
+	// BuildingSettings-related UI elements
+	UI::Button* cs_enhance_;
+	UI::Checkbox* cs_launch_expedition_;
+	std::unique_ptr<UI::Radiogroup> cs_prefer_heroes_rookies_;
+	UI::Button* cs_soldier_capacity_decrease_;
+	UI::Button* cs_soldier_capacity_increase_;
+	UI::Textarea* cs_soldier_capacity_display_;
+	std::vector<InputQueueDisplay*> cs_ware_queues_;
+	std::vector<InputQueueDisplay*> cs_worker_queues_;
+	UI::Checkbox* cs_stopped_;
+	FakeWaresDisplay* cs_warehouse_wares_;
+	FakeWaresDisplay* cs_warehouse_workers_;
+	void change_policy(Widelands::WareWorker, Widelands::StockPolicy);
+
 	DISALLOW_COPY_AND_ASSIGN(ConstructionSiteWindow);
 };
 

=== modified file 'src/wui/inputqueuedisplay.cc'
--- src/wui/inputqueuedisplay.cc	2019-05-29 06:24:42 +0000
+++ src/wui/inputqueuedisplay.cc	2019-06-19 09:23:26 +0000
@@ -46,7 +46,8 @@
    : UI::Panel(parent, x, y, 0, 28),
      igb_(igb),
      building_(building),
-     queue_(queue),
+     queue_(&queue),
+     settings_(nullptr),
      priority_radiogroup_(nullptr),
      increase_max_fill_(nullptr),
      decrease_max_fill_(nullptr),
@@ -58,12 +59,58 @@
      total_height_(0),
      show_only_(show_only) {
 	if (type_ == Widelands::wwWARE) {
-		const Widelands::WareDescr& ware = *queue.owner().tribe().get_ware_descr(queue_.get_index());
+		const Widelands::WareDescr& ware = *queue.owner().tribe().get_ware_descr(queue_->get_index());
 		set_tooltip(ware.descname().c_str());
 		icon_ = ware.icon();
 	} else {
 		const Widelands::WorkerDescr& worker =
-		   *queue.owner().tribe().get_worker_descr(queue_.get_index());
+		   *queue.owner().tribe().get_worker_descr(queue_->get_index());
+		set_tooltip(worker.descname().c_str());
+		icon_ = worker.icon();
+	}
+
+	uint16_t ph = max_fill_indicator_->height();
+
+	uint32_t priority_button_height = show_only ? 0 : 3 * PriorityButtonSize;
+	uint32_t image_height =
+	   show_only ? kWareMenuPicHeight : std::max<int32_t>(kWareMenuPicHeight, ph);
+
+	total_height_ = std::max(priority_button_height, image_height) + 2 * Border;
+
+	max_size_changed();
+
+	set_thinks(true);
+}
+
+InputQueueDisplay::InputQueueDisplay(UI::Panel* const parent,
+                                     int32_t const x,
+                                     int32_t const y,
+                                     InteractiveGameBase& igb,
+                                     Widelands::ConstructionSite& building,
+	                                 Widelands::WareWorker ww,
+	                                 Widelands::DescriptionIndex di,
+                                     bool show_only)
+   : UI::Panel(parent, x, y, 0, 28),
+     igb_(igb),
+     building_(building),
+     queue_(nullptr),
+     settings_(dynamic_cast<const Widelands::ProductionsiteSettings*>(building.get_settings())),
+     priority_radiogroup_(nullptr),
+     increase_max_fill_(nullptr),
+     decrease_max_fill_(nullptr),
+     index_(di),
+     type_(ww),
+     max_fill_indicator_(g_gr->images().get(pic_max_fill_indicator)),
+     total_height_(0),
+     show_only_(show_only) {
+	cache_size_ = check_max_size();
+	cache_max_fill_ = check_max_fill();
+	if (type_ == Widelands::wwWARE) {
+		const Widelands::WareDescr& ware = *building.owner().tribe().get_ware_descr(index_);
+		set_tooltip(ware.descname().c_str());
+		icon_ = ware.icon();
+	} else {
+		const Widelands::WorkerDescr& worker = *building.owner().tribe().get_worker_descr(index_);
 		set_tooltip(worker.descname().c_str());
 		icon_ = worker.icon();
 	}
@@ -85,6 +132,32 @@
 	delete priority_radiogroup_;
 }
 
+uint32_t InputQueueDisplay::check_max_size() const {
+	if (queue_) {
+		return queue_->get_max_size();
+	}
+	assert(settings_);
+	for (const auto& pair : type_ == Widelands::wwWARE ? settings_->ware_queues : settings_->worker_queues) {
+		if (pair.first == index_) {
+			return pair.second.max_fill;
+		}
+	}
+	NEVER_HERE();
+}
+
+uint32_t InputQueueDisplay::check_max_fill() const {
+	if (queue_) {
+		return queue_->get_max_fill();
+	}
+	assert(settings_);
+	for (const auto& pair : type_ == Widelands::wwWARE ? settings_->ware_queues : settings_->worker_queues) {
+		if (pair.first == index_) {
+			return pair.second.desired_fill;
+		}
+	}
+	NEVER_HERE();
+}
+
 /**
  * Recalculate the panel's size based on the size of the queue.
  *
@@ -94,7 +167,7 @@
 	uint32_t pbs = show_only_ ? 0 : PriorityButtonSize;
 	uint32_t ctrl_b_size = show_only_ ? 0 : 2 * kWareMenuPicWidth;
 
-	cache_size_ = queue_.get_max_size();
+	cache_size_ = check_max_size();
 
 	update_priority_buttons();
 	update_max_fill_buttons();
@@ -111,12 +184,12 @@
  * Compare the current InputQueue state with the cached state; update if necessary.
  */
 void InputQueueDisplay::think() {
-	if (static_cast<uint32_t>(queue_.get_max_size()) != cache_size_)
+	if (static_cast<uint32_t>(check_max_size()) != cache_size_)
 		max_size_changed();
 
 	// TODO(sirver): It seems cache_max_fill_ is not really useful for anything.
-	if (static_cast<uint32_t>(queue_.get_max_fill()) != cache_max_fill_) {
-		cache_max_fill_ = queue_.get_max_fill();
+	if (static_cast<uint32_t>(check_max_fill()) != cache_max_fill_) {
+		cache_max_fill_ = check_max_fill();
 		compute_max_fill_buttons_enabled_state();
 	}
 }
@@ -128,11 +201,12 @@
 	if (!cache_size_)
 		return;
 
-	cache_max_fill_ = queue_.get_max_fill();
+	cache_max_fill_ = check_max_fill();
 
-	uint32_t nr_inputs_to_draw = std::min(queue_.get_filled(), cache_size_);
+	uint32_t nr_inputs_to_draw = queue_ ? std::min(queue_->get_filled(), cache_size_) : cache_max_fill_;
 	uint32_t nr_missing_to_draw =
-	   std::min(queue_.get_missing(), cache_max_fill_) + cache_size_ - cache_max_fill_;
+	   queue_ ? std::min(queue_->get_missing(), cache_max_fill_) + cache_size_ - cache_max_fill_ :
+	   cache_size_ - cache_max_fill_;
 	if (nr_inputs_to_draw > cache_max_fill_) {
 		nr_missing_to_draw -= nr_inputs_to_draw - cache_max_fill_;
 	}
@@ -162,7 +236,7 @@
 		uint16_t pw = max_fill_indicator_->width();
 		point.y = Border;
 		point.x = Border + CellWidth + CellSpacing +
-		          (queue_.get_max_fill() * (CellWidth + CellSpacing)) - CellSpacing / 2 - pw / 2;
+		          (cache_max_fill_ * (CellWidth + CellSpacing)) - CellSpacing / 2 - pw / 2;
 		dst.blit(point, max_fill_indicator_);
 	}
 }
@@ -206,13 +280,13 @@
 
 	int32_t priority = building_.get_priority(type_, index_, false);
 	switch (priority) {
-	case HIGH_PRIORITY:
+	case Widelands::kPriorityHigh:
 		priority_radiogroup_->set_state(0);
 		break;
-	case DEFAULT_PRIORITY:
+	case Widelands::kPriorityNormal:
 		priority_radiogroup_->set_state(1);
 		break;
-	case LOW_PRIORITY:
+	case Widelands::kPriorityLow:
 		priority_radiogroup_->set_state(2);
 		break;
 	default:
@@ -314,13 +388,13 @@
 
 	switch (state) {
 	case 0:
-		priority = HIGH_PRIORITY;
+		priority = Widelands::kPriorityHigh;
 		break;
 	case 1:
-		priority = DEFAULT_PRIORITY;
+		priority = Widelands::kPriorityNormal;
 		break;
 	case 2:
-		priority = LOW_PRIORITY;
+		priority = Widelands::kPriorityLow;
 		break;
 	default:
 		return;

=== modified file 'src/wui/inputqueuedisplay.h'
--- src/wui/inputqueuedisplay.h	2019-05-06 10:53:42 +0000
+++ src/wui/inputqueuedisplay.h	2019-06-19 09:23:26 +0000
@@ -39,6 +39,8 @@
 
 namespace Widelands {
 class Building;
+class ConstructionSite;
+struct ProductionsiteSettings;
 class InputQueue;
 }  // namespace Widelands
 
@@ -51,6 +53,7 @@
 public:
 	enum { CellWidth = kWareMenuPicWidth, CellSpacing = 2, Border = 4, PriorityButtonSize = 10 };
 
+	// Constructor for real queues (e.g. in ProductionSites)
 	InputQueueDisplay(UI::Panel* parent,
 	                  int32_t x,
 	                  int32_t y,
@@ -58,6 +61,15 @@
 	                  Widelands::Building& building,
 	                  const Widelands::InputQueue& queue,
 	                  bool = false);
+	// Constructor for fake queues (e.g. in ConstructionSite settings)
+	InputQueueDisplay(UI::Panel* parent,
+	                  int32_t x,
+	                  int32_t y,
+	                  InteractiveGameBase&,
+	                  Widelands::ConstructionSite&,
+	                  Widelands::WareWorker,
+	                  Widelands::DescriptionIndex,
+	                  bool = false);
 	~InputQueueDisplay() override;
 
 	void think() override;
@@ -66,7 +78,8 @@
 private:
 	InteractiveGameBase& igb_;
 	Widelands::Building& building_;
-	const Widelands::InputQueue& queue_;
+	const Widelands::InputQueue* queue_;
+	const Widelands::ProductionsiteSettings* settings_;
 	UI::Radiogroup* priority_radiogroup_;
 	UI::Button* increase_max_fill_;
 	UI::Button* decrease_max_fill_;
@@ -90,6 +103,9 @@
 	void update_siblings_priority(int32_t);
 	void update_siblings_fill(int32_t);
 
+	uint32_t check_max_size() const;
+	uint32_t check_max_fill() const;
+
 	void compute_max_fill_buttons_enabled_state();
 };
 

=== modified file 'src/wui/warehousewindow.cc'
--- src/wui/warehousewindow.cc	2019-05-01 07:20:25 +0000
+++ src/wui/warehousewindow.cc	2019-06-19 09:23:26 +0000
@@ -75,19 +75,19 @@
 void WarehouseWaresDisplay::draw_ware(RenderTarget& dst, Widelands::DescriptionIndex ware) {
 	WaresDisplay::draw_ware(dst, ware);
 
-	Widelands::Warehouse::StockPolicy policy = warehouse_.get_stock_policy(get_type(), ware);
+	Widelands::StockPolicy policy = warehouse_.get_stock_policy(get_type(), ware);
 	const Image* pic = nullptr;
 	switch (policy) {
-	case Widelands::Warehouse::StockPolicy::kPrefer:
+	case Widelands::StockPolicy::kPrefer:
 		pic = g_gr->images().get(pic_policy_prefer);
 		break;
-	case Widelands::Warehouse::StockPolicy::kDontStock:
+	case Widelands::StockPolicy::kDontStock:
 		pic = g_gr->images().get(pic_policy_dontstock);
 		break;
-	case Widelands::Warehouse::StockPolicy::kRemove:
+	case Widelands::StockPolicy::kRemove:
 		pic = g_gr->images().get(pic_policy_remove);
 		break;
-	case Widelands::Warehouse::StockPolicy::kNormal:
+	case Widelands::StockPolicy::kNormal:
 		// don't draw anything for the normal policy
 		return;
 	}
@@ -106,7 +106,7 @@
 	                    Widelands::Warehouse&,
 	                    Widelands::WareWorker type);
 
-	void set_policy(Widelands::Warehouse::StockPolicy);
+	void set_policy(Widelands::StockPolicy);
 
 private:
 	InteractiveGameBase& gb_;
@@ -139,7 +139,7 @@
 	   buttons, #policy, 0, 0, 34, 34, UI::ButtonStyle::kWuiMenu,                                   \
 	   g_gr->images().get("images/wui/buildings/stock_policy_button_" #policy ".png"), tooltip),    \
 	b->sigclicked.connect(boost::bind(                                                              \
-	   &WarehouseWaresPanel::set_policy, this, Widelands::Warehouse::StockPolicy::k##policyname)),  \
+	   &WarehouseWaresPanel::set_policy, this, Widelands::StockPolicy::k##policyname)),  \
 	buttons->add(b);
 
 		ADD_POLICY_BUTTON(normal, Normal, _("Normal policy"))
@@ -152,7 +152,7 @@
 /**
  * Add Buttons policy buttons
  */
-void WarehouseWaresPanel::set_policy(Widelands::Warehouse::StockPolicy newpolicy) {
+void WarehouseWaresPanel::set_policy(Widelands::StockPolicy newpolicy) {
 	if (gb_.can_act(wh_.owner().player_number())) {
 		bool is_workers = type_ == Widelands::wwWORKER;
 		const std::set<Widelands::DescriptionIndex> indices =