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

[cghislai]

I'm not finished working on it yet, but I already put it on review so you can check changes and suggest design changes.

This is a refactoring in order to separate storages (entities storing wares/workers) from the warehouse class and garrisons (entities storing soldiers with control) from the militarysites/trainingsites.

I try to commit only playable revisions. Please note that post-b17 savegames may not be compatible.
My plan is to move portdock stuff out of warehouse class and add a an optional garrison on warehouses for headquarters.

[SirVer (sirver)]

that is a lot of code. I will review after I am done with the log_messages one.

[cghislai (charlyghislain)]

You don't have to review the whole thing now. At the very best I would appreciate knowing if I am in the wrong before putting much time in it.
The important files are new interfaces (storage.h garrison.h) and how they are used (militarysite.cc warehouse.cc)

[SirVer (sirver)]

Thanks, the pointer to the files to look at was very good. In general I think this is a great change and improves the design a lot - it also shows further places for refactoring which were much harder to see before this change. Here are some thoughts:

class Storage:
looks good. Could you use more empty lines to separate the methods? Also, it feels like wares and workers are disjunct, so maybe you can make a HasWares and HasWorkers Interface (those are the names I choose for Lua, consistency would be preferred, but not needed). I see that you use a lot of interfaces here - be aware that you cannot use double inheritance freely in the code as we static_cast a lot around and this breaks with double inheritance.

class Garrison:
I do not understand how you want to deal trainingssites with this one. It seems to implement the interface needed for warfare which will not be supported by trainingssites/warehouses. Otherwise looks good - then interface is a bit thicker than I would like it to be - but this is not your design error, but was there before. Maybe we can slim it out a bit later on.

About the use case: Interfaces are not a as good an idea in C++ than in Java. C++ does not have the concept and therefore creates storage for the classes. This leads to problems like the diamond inheritance[1]. This can be worked around using virtual inheritance, but then you can no longer static_cast your class pointers around. My suggestion for the design here would be to use composition [2] instead - and I would probably add getters into Building that return nullptr_t - productionsites and so on can then overwrite these getters to return correct values. So, by default a Building does not has_wares, nor has_workers nor has_soldiers, but some specialized buildings can overwrite these then.

[1] http://en.wikipedia.org/wiki/Diamond_inheritance#The_diamond_problem
[2] http://en.wikipedia.org/wiki/Composition_over_inheritance

review: Needs Fixing

[SirVer (sirver)]

This change would still be awesome to have in Widelands. Charly, you are not by any chance taking things on again soon?

[cghislai (charlyghislain)]

Im working on the fh1 branch, but I will have a look into that afterwards.

On Sun, Jul 20, 2014 at 9:56 PM, SirVer <email address hidden> wrote:

> This change would still be awesome to have in Widelands. Charly, you are
> not by any chance taking things on again soon?
> --
>
> https://code.launchpad.net/~widelands-dev/widelands/storages_garrisons/+merge/178704
> You proposed lp:~widelands-dev/widelands/storages_garrisons for merging.
>

[SirVer (sirver)]

Cool. I am working on getting rid of the old font renderer too in https://code.launchpad.net/~widelands-dev/widelands/text_area_richtext . Maybe we can join forces.

[cghislai (charlyghislain)]

Yep

Ill push my code as soons as I have this last bug gone with the editbox.

On Mon, Jul 21, 2014 at 6:53 AM, SirVer <email address hidden> wrote:

> Cool. I am working on getting rid of the old font renderer too in
> https://code.launchpad.net/~widelands-dev/widelands/text_area_richtext .
> Maybe we can join forces.
>
> --
>
> https://code.launchpad.net/~widelands-dev/widelands/storages_garrisons/+merge/178704
> You proposed lp:~widelands-dev/widelands/storages_garrisons for merging.
>

=== modified file 'global/militarysites/barracks.empire/conf'
--- global/militarysites/barracks.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/barracks.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=small
-heal_per_second=60 # very low -> smallest building
+buildable=no
+
+[garrison]
 conquers=6
 max_soldiers=1
-buildable=no
 prefer_heroes=false
+heal_per_second=60
 
 [idle]
 pics=../../../tribes/empire/barracks/barracks_i_??.png
 
=== modified file 'global/militarysites/barrier.barbarians/conf'
--- global/militarysites/barrier.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/barrier.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=medium
+buildable=no
+
+[garrison]
+conquers=8
 max_soldiers=5
+prefer_heroes=true
 heal_per_second=130
-conquers=8
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/barbarians/barrier/barrier_i_??.png
 
=== modified file 'global/militarysites/barrier.empire/conf'
--- global/militarysites/barrier.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/barrier.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=medium
+buildable=no
+
+[garrison]
+conquers=8
 max_soldiers=5
+prefer_heroes=true
 heal_per_second=130
-conquers=8
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/empire/barrier/barrier_i_??.png
 
=== modified file 'global/militarysites/castle.atlanteans/conf'
--- global/militarysites/castle.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/castle.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,8 +1,10 @@
 size=big
-max_soldiers=12
+buildable=no
+
+[garrison]
 heal_per_second=200
 conquers=12
-buildable=no
+max_soldiers=12
 prefer_heroes=true
 
 [idle]
 
=== modified file 'global/militarysites/castle.empire/conf'
--- global/militarysites/castle.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/castle.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=big
+buildable=no
+
+[garrison]
+conquers=12
 max_soldiers=12
+prefer_heroes=true
 heal_per_second=220
-conquers=12
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/empire/castle/castle_i_??.png
 
=== modified file 'global/militarysites/citadel.barbarians/conf'
--- global/militarysites/citadel.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/citadel.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=big
+buildable=no
+
+[garrison]
+conquers=12
 max_soldiers=12
+prefer_heroes=true
 heal_per_second=220
-conquers=12
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/barbarians/citadel/citadel_i_??.png
 
=== modified file 'global/militarysites/donjon.barbarians/conf'
--- global/militarysites/donjon.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/donjon.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,10 +1,12 @@
 size=medium
-max_soldiers=5
-heal_per_second=150
-conquers=8
 vision_range=17
 buildable=no
+
+[garrison]
+conquers=8
+max_soldiers=5
 prefer_heroes=true
+heal_per_second=150
 
 [idle]
 pics=../../../tribes/barbarians/donjon/donjon_i_??.png
 
=== modified file 'global/militarysites/fortress.barbarians/conf'
--- global/militarysites/fortress.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/fortress.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=big
+buildable=no
+
+[garrison]
+conquers=11
 max_soldiers=8
+prefer_heroes=true
 heal_per_second=170
-conquers=11
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/barbarians/fortress/fortress_i_??.png
 
=== modified file 'global/militarysites/fortress.empire/conf'
--- global/militarysites/fortress.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/fortress.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=big
+buildable=no
+
+[garrison]
+conquers=11
 max_soldiers=8
+prefer_heroes=true
 heal_per_second=170
-conquers=11
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/empire/fortress/fortress_i_??.png
 
=== modified file 'global/militarysites/guardhall.atlanteans/conf'
--- global/militarysites/guardhall.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/guardhall.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,8 +1,10 @@
 size=medium
-max_soldiers=7
+buildable=no
+
+[garrison]
 heal_per_second=140
 conquers=7
-buildable=no
+max_soldiers=7
 prefer_heroes=true
 
 [idle]
 
=== modified file 'global/militarysites/guardhouse.atlanteans/conf'
--- global/militarysites/guardhouse.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/guardhouse.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,8 +1,10 @@
 size=small
+buildable=no
+
+[garrison]
 heal_per_second=75
 conquers=6
 max_soldiers=2
-buildable=no
 prefer_heroes=false
 
 [idle]
 
=== modified file 'global/militarysites/high_tower.atlanteans/conf'
--- global/militarysites/high_tower.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/high_tower.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,10 +1,12 @@
 size=medium
-max_soldiers=5
-heal_per_second=170
-conquers=9
 vision_range=21
 buildable=no
+
+[garrison]
+conquers=9
+max_soldiers=5
 prefer_heroes=true
+heal_per_second=170
 
 [idle]
 pics=../../../tribes/atlanteans/high_tower/high_tower_i_??.png
 
=== modified file 'global/militarysites/outpost.empire/conf'
--- global/militarysites/outpost.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/outpost.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=medium
+buildable=no
+
+[garrison]
+conquers=7
 max_soldiers=3
+prefer_heroes=false
 heal_per_second=100
-conquers=7
-buildable=no
-prefer_heroes=false
 
 [idle]
 pics=../../../tribes/empire/outpost/outpost_i_??.png
 
=== modified file 'global/militarysites/sentry.barbarians/conf'
--- global/militarysites/sentry.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/sentry.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=small
-heal_per_second=80
+buildable=no
+
+[garrison]
 conquers=6
 max_soldiers=2
-buildable=no
 prefer_heroes=false
+heal_per_second=80
 
 [idle]
 pics=../../../tribes/barbarians/sentry/sentry_i_??.png
 
=== modified file 'global/militarysites/sentry.empire/conf'
--- global/militarysites/sentry.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/sentry.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=small
-heal_per_second=80
+buildable=no
+
+[garrison]
 conquers=6
 max_soldiers=2
-buildable=no
 prefer_heroes=false
+heal_per_second=80
 
 [idle]
 pics=../../../tribes/empire/sentry/sentry_i_??.png
 
=== modified file 'global/militarysites/small_tower.atlanteans/conf'
--- global/militarysites/small_tower.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/small_tower.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,10 +1,12 @@
 size=small
+vision_range=13
+buildable=no
+
+[garrison]
 heal_per_second=100
 conquers=5
-vision_range=13
 max_soldiers=3
-buildable=no
-prefer_heroes=false
+prefer_heroes=true
 
 [idle]
 pics=../../../tribes/atlanteans/small_tower/small_tower_i_??.png
 
=== modified file 'global/militarysites/stronghold.barbarians/conf'
--- global/militarysites/stronghold.barbarians/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/stronghold.barbarians/conf	2013-08-10 10:53:03 +0000
@@ -1,9 +1,11 @@
 size=medium
+buildable=no
+
+[garrison]
+conquers=7
 max_soldiers=3
+prefer_heroes=false
 heal_per_second=110
-conquers=7
-buildable=no
-prefer_heroes=false
 
 [idle]
 pics=../../../tribes/barbarians/stronghold/stronghold_i_??.png
 
=== modified file 'global/militarysites/tower.atlanteans/conf'
--- global/militarysites/tower.atlanteans/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/tower.atlanteans/conf	2013-08-10 10:53:03 +0000
@@ -1,10 +1,12 @@
 size=medium
-max_soldiers=4
+vision_range=17
+buildable=no
+
+[garrison]
 heal_per_second=120
 conquers=9
-vision_range=17
-buildable=no
-prefer_heroes=true
+max_soldiers=4
+prefer_heroes=false
 
 [idle]
 pics=../../../tribes/atlanteans/tower/tower_i_??.png
 
=== modified file 'global/militarysites/tower.empire/conf'
--- global/militarysites/tower.empire/conf	2013-06-11 16:37:44 +0000
+++ global/militarysites/tower.empire/conf	2013-08-10 10:53:03 +0000
@@ -1,10 +1,11 @@
 size=medium
+buildable=no
+
+[garrison]
+conquers=9
 max_soldiers=5
+prefer_heroes=true
 heal_per_second=150
-conquers=9
-vision_range=19
-buildable=no
-prefer_heroes=true
 
 [idle]
 pics=../../../tribes/empire/tower/tower_i_??.png
 
=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2013-07-26 20:19:36 +0000
+++ src/ai/defaultai.cc	2013-08-10 10:53:03 +0000
@@ -72,7 +72,7 @@
 	next_attack_consideration_due(300000),
 	inhibit_road_building        (0),
 	time_of_last_construction    (0),
-	numof_warehouses             (0)
+	numof_storages               (0)
 {}
 
 DefaultAI::~DefaultAI()
@@ -577,7 +577,7 @@
 
 					if (v > 0)
 						field.military_influence +=
-							v * v * militarysite->soldierCapacity();
+							v * v * militarysite->get_garrison()->soldierCapacity();
 				}
 
 				if (dynamic_cast<const ProductionSite *>(building))
@@ -626,7 +626,7 @@
 
 					if (v > 0)
 						field.military_influence +=
-							v * v * militarysite->soldierCapacity();
+							v * v * militarysite->get_garrison()->soldierCapacity();
 				}
 			}
 		}
@@ -881,8 +881,8 @@
 					// Check if the produced wares are needed
 					Ware_Index wt(static_cast<size_t>(bo.outputs.at(0)));
 					container_iterate(std::list<EconomyObserver *>, economies, l) {
-						// Don't check if the economy has no warehouse.
-						if ((*l.current)->economy.warehouses().empty())
+						// Don't check if the economy has no storage.
+						if ((*l.current)->economy.storages().empty())
 							continue;
 						if ((*l.current)->economy.needs_ware(wt))
 							prio += 1 + wares.at(bo.outputs.at(0)).preciousness;
@@ -918,8 +918,8 @@
 					// the ware they're refreshing
 					Ware_Index wt(static_cast<size_t>(bo.production_hint));
 					container_iterate(std::list<EconomyObserver *>, economies, l) {
-						// Don't check if the economy has no warehouse.
-						if ((*l.current)->economy.warehouses().empty())
+						// Don't check if the economy has no storages.
+						if ((*l.current)->economy.storages().empty())
 							continue;
 						if ((*l.current)->economy.needs_ware(wt)) {
 							prio += wares.at(bo.production_hint).preciousness * inout * 2;
@@ -964,8 +964,8 @@
 
 					// Check if the produced wares are needed
 					container_iterate(std::list<EconomyObserver *>, economies, l) {
-						// Don't check if the economy has no warehouse.
-						if ((*l.current)->economy.warehouses().empty())
+						// Don't check if the economy has no storages.
+						if ((*l.current)->economy.storages().empty())
 							continue;
 						for (uint32_t m = 0; m < bo.outputs.size(); ++m) {
 							Ware_Index wt(static_cast<size_t>(bo.outputs.at(m)));
@@ -1056,7 +1056,7 @@
 				//  needed for soldier training) near the frontier.
 				prio += productionsites.size() + mines.size();
 				prio += militarysites.size() / 3;
-				prio -= (bo.cnt_under_construction + numof_warehouses) * 35;
+				prio -= (bo.cnt_under_construction + numof_storages) * 35;
 				prio *= 2;
 
 				// take care about borders and enemies
@@ -1880,13 +1880,13 @@
 
 	if (map.find_fields(Area<FCoords>(f, vision), 0, find_unowned) == 0) {
 		// If no enemy in sight - decrease the number of stationed soldiers
-		// as long as it is > 1 - BUT take care that there is a warehouse in the
+		// as long as it is > 1 - BUT take care that there is a storage in the
 		// same economy where the thrown out soldiers can go to.
-		if (ms->economy().warehouses().size()) {
-			uint32_t const j = ms->soldierCapacity();
-			if (MilitarySite::kPrefersRookies != ms->get_soldier_preference())
+		if (ms->economy().storages().size()) {
+			uint32_t const j = ms->get_garrison()->soldierCapacity();
+			if (Garrison::SoldierPref::Rookies != ms->get_garrison()->get_soldier_preference())
 			{
-					game().send_player_militarysite_set_soldier_preference(*ms, MilitarySite::kPrefersRookies);
+					game().send_player_militarysite_set_soldier_preference(*ms, Garrison::SoldierPref::Rookies);
 			}
 			else
 			if (j > 1)
@@ -1912,7 +1912,7 @@
 						// the destruction of the flag avoids that defaultAI will have
 						// too many unused roads - if needed the road will be rebuild
 						// directly.
-						if (static_cast<int32_t>(ms->maxSoldierCapacity() * 4) < bf.military_influence) {
+						if (static_cast<int32_t>(ms->get_garrison()->maxSoldierCapacity() * 4) < bf.military_influence) {
 							if (ms->get_playercaps() & Widelands::Building::PCap_Dismantle) {
 								flags_to_be_removed.push_back(ms->base_flag().get_position());
 								game().send_player_dismantle(*ms);
@@ -1964,12 +1964,12 @@
 	} else {
 		// If an enemy is in sight and the number of stationed soldier is not
 		// at maximum - set it to maximum.
-		uint32_t const j = ms->maxSoldierCapacity();
-		uint32_t const k = ms->soldierCapacity();
+		uint32_t const j = ms->get_garrison()->maxSoldierCapacity();
+		uint32_t const k = ms->get_garrison()->soldierCapacity();
 		if (j > k)
 			game().send_player_change_soldier_capacity(*ms, j - k);
-		if (MilitarySite::kPrefersHeroes != ms->get_soldier_preference())
-			game().send_player_militarysite_set_soldier_preference(*ms, MilitarySite::kPrefersHeroes);
+		if (Garrison::SoldierPref::Heroes != ms->get_garrison()->get_soldier_preference())
+			game().send_player_militarysite_set_soldier_preference(*ms, Garrison::SoldierPref::Heroes);
 		changed = true;
 	}
 	reorder:;
@@ -2182,7 +2182,7 @@
 			militarysites.back().bo = &bo;
 			militarysites.back().checks = bo.desc->get_size();
 		} else if (bo.type == BuildingObserver::WAREHOUSE)
-			++numof_warehouses;
+			++numof_storages;
 	}
 }
 
@@ -2244,8 +2244,8 @@
 					break;
 				}
 		} else if (bo.type == BuildingObserver::WAREHOUSE) {
-			assert(numof_warehouses > 0);
-			--numof_warehouses;
+			assert(numof_storages > 0);
+			--numof_storages;
 		}
 	}
 	m_buildable_changed = true;
@@ -2310,41 +2310,28 @@
 	map.find_immovables
 		(Area<FCoords>(f, vision), &immovables, FindImmovableAttackable());
 
-	for (uint32_t j = 0; j < immovables.size(); ++j)
-		if (upcast(MilitarySite, bld, immovables.at(j).object)) {
-			if (!player->is_hostile(bld->owner()))
-				continue;
-			if (bld->canAttack()) {
-				int32_t ta = player->findAttackSoldiers(bld->base_flag());
-				if (type == NORMAL)
-					ta = ta * 2 / 3;
-				if (ta < 1)
-					continue;
-
-				int32_t const tc = ta - bld->presentSoldiers().size();
-				if (tc > chance) {
-					target = bld;
-					chance = tc;
-					attackers = ta;
-				}
-			}
-		} else if (upcast(Warehouse, wh, immovables.at(j).object)) {
-			if (!player->is_hostile(wh->owner()))
-				continue;
-			if (wh->canAttack()) {
-				int32_t ta = player->findAttackSoldiers(wh->base_flag());
-				if (ta < 1)
-					continue;
-
-				// extra priority push!
-				int32_t tc = ta * 2;
-				if (tc > chance) {
-					target = wh;
-					chance = tc;
-					attackers = ta;
-				}
+	for (uint32_t j = 0; j < immovables.size(); ++j) {
+		if (upcast(GarrisonOwner, go, immovables.at(j).object)) {
+			if (!player->is_hostile(go->get_garrison()->owner())) {
+				continue;
+			}
+			if (!go->get_garrison()->canAttack()) {
+				continue;
+			}
+			int32_t ta = player->findAttackSoldiers(go->get_building()->base_flag());
+			if (type == NORMAL)
+				ta = ta * 2 / 3;
+			if (ta < 1)
+				continue;
+
+			int32_t const tc = ta - go->get_garrison()->presentSoldiers().size();
+			if (tc > chance) {
+				target = go->get_building();
+				chance = tc;
+				attackers = ta;
 			}
 		}
+	}
 
 	// Reenque militarysite at the end of list
 	militarysites.push_back(militarysites.front());
 
=== modified file 'src/ai/defaultai.h'
--- src/ai/defaultai.h	2013-07-26 20:19:36 +0000
+++ src/ai/defaultai.h	2013-08-10 10:53:03 +0000
@@ -191,7 +191,7 @@
 	int32_t inhibit_road_building;
 	int32_t time_of_last_construction;
 
-	uint16_t numof_warehouses;
+	uint16_t numof_storages;
 };
 
 #endif
 
=== modified file 'src/economy/economy.cc'
--- src/economy/economy.cc	2013-07-26 20:19:36 +0000
+++ src/economy/economy.cc	2013-08-10 10:53:03 +0000
@@ -27,11 +27,10 @@
 #include "economy/route.h"
 #include "economy/routeastar.h"
 #include "economy/router.h"
-#include "economy/warehousesupply.h"
 #include "logic/game.h"
 #include "logic/player.h"
+#include "logic/storage.h"
 #include "logic/tribe.h"
-#include "logic/warehouse.h"
 #include "upcast.h"
 #include "wexception.h"
 
@@ -78,8 +77,8 @@
 		log("Warning: Economy still has requests left on destruction\n");
 	if (m_flags.size())
 		log("Warning: Economy still has flags left on destruction\n");
-	if (m_warehouses.size())
-		log("Warning: Economy still has warehouses left on destruction\n");
+	if (m_storages.size())
+		log("Warning: Economy still has storages left on destruction\n");
 
 	delete[] m_ware_target_quantities;
 	delete[] m_worker_target_quantities;
@@ -214,22 +213,22 @@
 };
 
 /**
- * Find the warehouse closest to the given starting flag.
+ * Find the storage owner closest to the given starting flag.
  *
  * If the search was successful and \p route is non-null,
  * a route is also computed.
  *
  * \param start starting flag
  * \param type whether to path-find as if the path were for a ware
- * \param route if non-null, fill in a route to the warehouse
+ * \param route if non-null, fill in a route to the storage
  * \param cost_cutoff if positive, find paths of at most
  * that length (in milliseconds)
  */
-Warehouse * Economy::find_closest_warehouse
+StorageOwner* Economy::find_closest_storage
 	(Flag & start, WareWorker type, Route * route, uint32_t cost_cutoff,
-	 const Economy::WarehouseAcceptFn & acceptfn)
+	 const Economy::StorageAcceptFn & acceptfn)
 {
-	if (!warehouses().size())
+	if (!storages().size())
 		return 0;
 
 	// A-star with zero estimator = Dijkstra
@@ -243,11 +242,11 @@
 			return 0;
 
 		Flag & flag = current->base_flag();
-		if (upcast(Warehouse, warehouse, flag.get_building())) {
-			if (!acceptfn || acceptfn(*warehouse)) {
+		if (upcast(StorageOwner, storage_owner, flag.get_building())) {
+			if (!acceptfn || acceptfn(storage_owner)) {
 				if (route)
 					astar.routeto(flag, *route);
-				return warehouse;
+				return storage_owner;
 			}
 		}
 	}
@@ -368,7 +367,7 @@
 
 /**
  * Call this whenever a ware is destroyed or consumed, e.g. food has been
- * eaten or a warehouse has been destroyed.
+ * eaten or a storage has been destroyed.
  * This is also called when a ware is removed from the economy through trade or
  * a split of the Economy.
 */
@@ -397,32 +396,32 @@
 }
 
 /**
- * Add the warehouse to our list of warehouses.
- * This also adds the wares in the warehouse to the economy. However, if wares
- * are added to the warehouse in the future, add_wares() must be called.
+ * Add the storage to our list of storages.
+ * This also adds the wares in the storage to the economy. However, if wares
+ * are added to the storage in the future, add_wares() must be called.
 */
-void Economy::add_warehouse(Warehouse & wh)
+void Economy::add_storage(Storage & storage)
 {
-	m_warehouses.push_back(&wh);
+	m_storages.push_back(&storage);
 }
 
 /**
- * Remove the warehouse and its wares from the economy.
+ * Remove the storage and its wares from the economy.
 */
-void Economy::remove_warehouse(Warehouse & wh)
+void Economy::remove_storage(Storage & storage)
 {
-	for (size_t i = 0; i < m_warehouses.size(); ++i)
-		if (m_warehouses[i] == &wh) {
-			m_warehouses[i] = *m_warehouses.rbegin();
-			m_warehouses.pop_back();
+	for (size_t i = 0; i < m_storages.size(); ++i)
+		if (m_storages[i] == &storage) {
+			m_storages[i] = *m_storages.rbegin();
+			m_storages.pop_back();
 			return;
 		}
 
 
-	//  This assert was modified, since on loading, warehouses might try to
+	//  This assert was modified, since on loading, storages might try to
 	//  remove themselves from their own economy, though they weren't added
 	//  (since they weren't initialized)
-	assert(m_warehouses.empty());
+	assert(m_storages.empty());
 }
 
 /**
@@ -495,8 +494,8 @@
 bool Economy::needs_ware(Ware_Index const ware_type) const {
 	uint32_t const t = ware_target_quantity(ware_type).permanent;
 	uint32_t quantity = 0;
-	container_iterate_const(std::vector<Warehouse *>, m_warehouses, wh) {
-		quantity += (*wh)->get_wares().stock(ware_type);
+	container_iterate_const(std::vector<Storage *>, m_storages, storage) {
+		quantity += (*storage)->get_wares().stock(ware_type);
 		if (t <= quantity)
 			return false;
 	}
@@ -507,8 +506,8 @@
 bool Economy::needs_worker(Ware_Index const worker_type) const {
 	uint32_t const t = worker_target_quantity(worker_type).permanent;
 	uint32_t quantity = 0;
-	container_iterate_const(std::vector<Warehouse *>, m_warehouses, wh) {
-		quantity += (*wh)->get_workers().stock(worker_type);
+	container_iterate_const(std::vector<Storage *>, m_storages, storage) {
+		quantity += (*storage)->get_workers().stock(worker_type);
 		if (t <= quantity)
 			return false;
 	}
@@ -796,7 +795,7 @@
 
 /**
  * Check whether there is a supply for the given request. If the request is a
- * worker request without supply, attempt to create a new worker in a warehouse.
+ * worker request without supply, attempt to create a new worker in a storage.
  */
 void Economy::_create_requested_worker(Game & game, Ware_Index index)
 {
@@ -820,7 +819,7 @@
 		return;
 
 	// We have worker demand that is not fulfilled by supplies
-	// Find warehouses where we can create the required workers,
+	// Find storages where we can create the required workers,
 	// and collect stats about existing build prerequisites
 	const Tribe_Descr & tribe = owner().tribe();
 	const Worker_Descr & w_desc = *tribe.get_worker_descr(index);
@@ -830,20 +829,20 @@
 
 	total_available.insert(total_available.begin(), cost.size(), 0);
 
-	for (uint32_t n_wh = 0; n_wh < warehouses().size(); ++n_wh) {
-		Warehouse * wh = m_warehouses[n_wh];
+	for (uint32_t storage_idx = 0; storage_idx < m_storages.size(); ++storage_idx) {
+		Storage * storage = m_storages[storage_idx];
 
-		uint32_t planned = wh->get_planned_workers(game, index);
+		uint32_t planned = storage->get_planned_workers(game, index);
 		total_planned += planned;
 
-		while (wh->can_create_worker(game, index)) {
-			wh->create_worker(game, index);
+		while (storage->can_create_worker(game, index)) {
+			storage->create_worker(game, index);
 			if (!--demand)
 				return;
 		}
 
 		std::vector<uint32_t> wh_available =
-			wh->calc_available_for_worker(game, index);
+			storage->calc_available_for_worker(game, index);
 		assert(wh_available.size() == total_available.size());
 
 		for (uint32_t idx = 0; idx < total_available.size(); ++idx)
@@ -870,25 +869,25 @@
 		// there are supplies for (otherwise, cyclic transportation might happen)
 		// Note that supplies might suddenly disappear outside our control because
 		// of loss of land or silly player actions.
-		for (uint32_t n_wh = 0; n_wh < warehouses().size(); ++n_wh) {
-			Warehouse * wh = m_warehouses[n_wh];
+		for (uint32_t storage_idx = 0; storage_idx < m_storages.size(); ++storage_idx) {
+			Storage * storage = m_storages[storage_idx];
 
-			uint32_t planned = wh->get_planned_workers(game, index);
+			uint32_t planned = storage->get_planned_workers(game, index);
 			uint32_t reduce = std::min(planned, total_planned - can_create);
-			wh->plan_workers(game, index, planned - reduce);
+			storage->plan_workers(game, index, planned - reduce);
 			total_planned -= reduce;
 		}
 	} else if (total_planned < demand) {
 		uint32_t plan_goal = std::min(can_create, demand);
 
-		for (uint32_t n_wh = 0; n_wh < warehouses().size(); ++n_wh) {
-			Warehouse * wh = m_warehouses[n_wh];
+		for (uint32_t storage_idx = 0; storage_idx < m_storages.size(); ++storage_idx) {
+			Storage * storage = m_storages[storage_idx];
 			uint32_t supply =
-				wh->calc_available_for_worker(game, index)[scarcest_idx];
+				storage->calc_available_for_worker(game, index)[scarcest_idx];
 
-			total_planned -= wh->get_planned_workers(game, index);
+			total_planned -= storage->get_planned_workers(game, index);
 			uint32_t plan = std::min(supply, plan_goal - total_planned);
-			wh->plan_workers(game, index, plan);
+			storage->plan_workers(game, index, plan);
 			total_planned += plan;
 		}
 	}
@@ -896,11 +895,11 @@
 
 /**
  * Walk all Requests and find requests of workers than aren't supplied. Then
- * try to create the worker at warehouses.
+ * try to create the worker at storages.
  */
 void Economy::_create_requested_workers(Game & game)
 {
-	if (!warehouses().size())
+	if (!storages().size())
 		return;
 
 	const Tribe_Descr & tribe = owner().tribe();
@@ -920,23 +919,23 @@
 /**
  * Helper function for \ref _handle_active_supplies
  */
-static bool accept_warehouse_if_policy
-	(Warehouse & wh, WareWorker type,
-	 Ware_Index ware, Warehouse::StockPolicy policy)
+static bool accept_storage_if_policy
+	(StorageOwner* storage, WareWorker type,
+	 Ware_Index ware, Storage::StockPolicy policy)
 {
-	return wh.get_stock_policy(type, ware) == policy;
+	return storage->get_storage()->get_stock_policy(type, ware) == policy;
 }
 
 /**
  * Send all active supplies (wares that are outside on the road network without
- * being sent to a specific request) to a warehouse.
+ * being sent to a specific request) to a storage.
  */
 void Economy::_handle_active_supplies(Game & game)
 {
-	if (!warehouses().size())
+	if (!storages().size())
 		return;
 
-	typedef std::vector<std::pair<Supply *, Warehouse *> > Assignments;
+	typedef std::vector<std::pair<Supply *, StorageOwner *> > Assignments;
 	Assignments assignments;
 
 	for (uint32_t idx = 0; idx < m_supplies.get_nrsupplies(); ++idx) {
@@ -950,38 +949,38 @@
 
 		bool haveprefer = false;
 		bool havenormal = false;
-		for (uint32_t nwh = 0; nwh < m_warehouses.size(); ++nwh) {
-			Warehouse * wh = m_warehouses[nwh];
-			Warehouse::StockPolicy policy = wh->get_stock_policy(type, ware);
-			if (policy == Warehouse::SP_Prefer) {
+		for (uint32_t storage_idx = 0; storage_idx < m_storages.size(); ++storage_idx) {
+			Storage * storage = m_storages[storage_idx];
+			Storage::StockPolicy policy = storage->get_stock_policy(type, ware);
+			if (policy == Storage::StockPolicy::Prefer) {
 				haveprefer = true;
 				break;
 			}
-			if (policy == Warehouse::SP_Normal)
+			if (policy == Storage::StockPolicy::Normal)
 				havenormal = true;
 		}
 		if (!havenormal && !haveprefer && type == wwWARE)
 			continue;
 
-		Warehouse * wh = find_closest_warehouse
+		StorageOwner * storage_owner = find_closest_storage
 			(supply.get_position(game)->base_flag(), type, 0, 0,
 			 (!haveprefer && !havenormal)
 			 ?
-			 WarehouseAcceptFn()
+			 StorageAcceptFn()
 			 :
 			 boost::bind
-				(&accept_warehouse_if_policy,
+				(&accept_storage_if_policy,
 				 _1, type, ware,
-				 haveprefer ? Warehouse::SP_Prefer : Warehouse::SP_Normal));
+				 haveprefer ? Storage::StockPolicy::Prefer : Storage::StockPolicy::Normal));
 
-		if (!wh) {
+		if (!storage_owner) {
 			log
 				("Warning: Economy::_handle_active_supplies "
-				 "didn't find warehouse\n");
+				 "didn't find storage\n");
 			return;
 		}
 
-		assignments.push_back(std::make_pair(&supply, wh));
+		assignments.push_back(std::make_pair(&supply, storage_owner));
 	}
 
 	// Actually start with the transfers in a separate second phase,
@@ -991,10 +990,10 @@
 	ss.Unsigned32(0x02decafa); // appears as facade02 in sync stream
 	ss.Unsigned32(assignments.size());
 
+	// FIXME CGH check thats working
 	container_iterate_const(Assignments, assignments, it) {
 		ss.Unsigned32(it.current->first->get_position(game)->serial());
-		ss.Unsigned32(it.current->second->serial());
-
+		ss.Unsigned32(it.current->second->get_building()->serial());
 		it.current->first->send_to_storage(game, it.current->second);
 	}
 }
 
=== modified file 'src/economy/economy.h'
--- src/economy/economy.h	2013-07-26 20:19:36 +0000
+++ src/economy/economy.h	2013-08-10 10:53:03 +0000
@@ -34,12 +34,15 @@
 
 
 namespace Widelands {
+
+class StorageOwner;
+
+class Storage;
 struct Player;
 struct Game;
 struct Flag;
 struct Route;
 struct RSPairStruct;
-class Warehouse;
 struct Request;
 struct Supply;
 struct Router;
@@ -102,11 +105,11 @@
 		 WareWorker type,
 		 int32_t cost_cutoff = -1);
 
-	typedef boost::function<bool (Warehouse &)> WarehouseAcceptFn;
-	Warehouse * find_closest_warehouse
+	typedef boost::function<bool (StorageOwner *)> StorageAcceptFn;
+	StorageOwner * find_closest_storage
 		(Flag & start, WareWorker type = wwWORKER, Route * route = 0,
 		 uint32_t cost_cutoff = 0,
-		 const WarehouseAcceptFn & acceptfn = WarehouseAcceptFn());
+		 const StorageAcceptFn & acceptfn = StorageAcceptFn());
 
 	std::vector<Flag *>::size_type get_nrflags() const {return m_flags.size();}
 	void    add_flag(Flag &);
@@ -122,9 +125,9 @@
 	void    add_workers(Ware_Index, uint32_t count = 1);
 	void remove_workers(Ware_Index, uint32_t count = 1);
 
-	void    add_warehouse(Warehouse &);
-	void remove_warehouse(Warehouse &);
-	const std::vector<Warehouse *>& warehouses() const {return m_warehouses;}
+	void    add_storage(Storage &);
+	void remove_storage(Storage &);
+	const std::vector<Storage *>& storages() const {return m_storages;}
 
 	void    add_request(Request &);
 	void remove_request(Request &);
@@ -208,7 +211,7 @@
 	Flags m_flags;
 	WareList m_wares;     ///< virtual storage with all wares in this Economy
 	WareList m_workers;   ///< virtual storage with all workers in this Economy
-	std::vector<Warehouse *> m_warehouses;
+	std::vector<Storage *> m_storages;
 
 	RequestList m_requests; ///< requests
 	SupplyList m_supplies;
 
=== modified file 'src/economy/idleworkersupply.cc'
--- src/economy/idleworkersupply.cc	2013-07-26 20:19:36 +0000
+++ src/economy/idleworkersupply.cc	2013-08-10 10:53:03 +0000
@@ -25,8 +25,8 @@
 #include "logic/player.h"
 #include "logic/requirements.h"
 #include "logic/soldier.h"
+#include "logic/storage.h"
 #include "logic/tribe.h"
-#include "logic/warehouse.h"
 #include "logic/worker.h"
 #include "wexception.h"
 
@@ -126,12 +126,12 @@
 	return m_worker;
 }
 
-void IdleWorkerSupply::send_to_storage(Game & game, Warehouse * wh)
+void IdleWorkerSupply::send_to_storage(Game & game, StorageOwner * storage_owner)
 {
 	assert(!has_storage());
 
 	Transfer * t = new Transfer(game, m_worker);
-	t->set_destination(*wh);
+	t->set_destination(*storage_owner->get_building());
 	m_worker.start_task_transfer(game, t);
 }
 
 
=== modified file 'src/economy/idleworkersupply.h'
--- src/economy/idleworkersupply.h	2013-07-26 20:19:36 +0000
+++ src/economy/idleworkersupply.h	2013-08-10 10:53:03 +0000
@@ -23,6 +23,8 @@
 #include "economy/supply.h"
 
 namespace Widelands {
+
+class StorageOwner;
 class Worker;
 class Economy;
 
@@ -36,7 +38,7 @@
 	virtual bool is_active() const throw ();
 	virtual bool has_storage() const throw ();
 	virtual void get_ware_type(WareWorker & type, Ware_Index & ware) const;
-	virtual void send_to_storage(Game &, Warehouse * wh);
+	virtual void send_to_storage(Game &, StorageOwner * storage_owner);
 
 	virtual uint32_t nr_supplies(const Game &, const Request &) const;
 	virtual WareInstance & launch_item(Game &, const Request &);
 
=== modified file 'src/economy/portdock.cc'
--- src/economy/portdock.cc	2013-07-26 20:19:36 +0000
+++ src/economy/portdock.cc	2013-08-10 10:53:03 +0000
@@ -488,7 +488,7 @@
 	// Put all wares from the WaresQueues back into the warehouse
 	const std::vector<WaresQueue *> & l_expedition_wares = m_warehouse->get_wares_queue_vector();
 	for (uint8_t i = 0; i < l_expedition_wares.size(); ++i) {
-		m_warehouse->insert_wares(l_expedition_wares.at(i)->get_ware(), l_expedition_wares.at(i)->get_filled());
+		m_warehouse->get_storage()->insert_wares(l_expedition_wares.at(i)->get_ware(), l_expedition_wares.at(i)->get_filled());
 		l_expedition_wares.at(i)->set_filled(0);
 		l_expedition_wares.at(i)->set_max_fill(0);
 	}
@@ -501,7 +501,7 @@
 		} else {
 			Worker * temp = ew.at(i)->worker;
 			ew.at(i)->worker = 0;
-			m_warehouse->incorporate_worker(game, *temp);
+			m_warehouse->get_storage()->incorporate_worker(game, *temp);
 		}
 	}
 	// Reset expedition workers list
 
=== modified file 'src/economy/request.cc'
--- src/economy/request.cc	2013-07-26 20:19:36 +0000
+++ src/economy/request.cc	2013-08-10 10:53:03 +0000
@@ -28,8 +28,8 @@
 #include "logic/player.h"
 #include "logic/productionsite.h"
 #include "logic/soldier.h"
+#include "logic/storage.h"
 #include "logic/tribe.h"
-#include "logic/warehouse.h"
 #include "logic/worker.h"
 #include "map_io/widelands_map_map_object_loader.h"
 #include "map_io/widelands_map_map_object_saver.h"
@@ -50,22 +50,27 @@
 	(PlayerImmovable & _target,
 	 Ware_Index const index,
 	 callback_t const cbfn,
-	 WareWorker const w)
+	 WareWorker const w,
+	 callback_tranfert_t const transfer_cb)
 	:
 	m_type             (w),
 	m_target           (_target),
 	m_target_building  (dynamic_cast<Building *>(&_target)),
 	m_target_productionsite  (dynamic_cast<ProductionSite *>(&_target)),
-	m_target_warehouse (dynamic_cast<Warehouse *>(&_target)),
+	m_target_storage   (nullptr),
 	m_target_constructionsite (dynamic_cast<ConstructionSite *>(&_target)),
 	m_economy          (_target.get_economy()),
 	m_index            (index),
 	m_count            (1),
 	m_callbackfn       (cbfn),
+	m_transfer_cb      (transfer_cb),
 	m_required_time    (_target.owner().egbase().get_gametime()),
 	m_required_interval(0),
 	m_last_request_time(m_required_time)
 {
+	if (upcast(StorageOwner, storage_owner, &_target)) {
+		m_target_storage = storage_owner->get_storage();
+	}
 	assert(m_type == wwWARE or m_type == wwWORKER);
 	if (w == wwWARE and _target.owner().tribe().get_nrwares() <= index)
 		throw wexception
@@ -354,8 +359,8 @@
 		modifier = m_target_building->get_priority(get_type(), get_index());
 		if (m_target_constructionsite)
 			is_construction_site = true;
-		else if (m_target_warehouse)
-			// if warehouse calculated a priority use it
+		else if (m_target_storage)
+			// if storage calculated a priority use it
 			// else lower priority based on cost
 			return
 				modifier != 100 ? modifier :
@@ -404,7 +409,7 @@
 		pri = m_target_building->get_priority(get_type(), get_index());
 		if (m_target_constructionsite)
 			return pri + 3;
-		else if (m_target_warehouse)
+		else if (m_target_storage)
 			return pri - 2;
 	}
 	return pri;
@@ -486,10 +491,13 @@
 		Worker & s = supp.launch_worker(game, *this);
 		ss.Unsigned32(s.serial());
 		t = new Transfer(game, *this, s);
+		if (m_transfer_cb) {
+			(*m_transfer_cb)(game, *this, m_index, &s, m_target);
+		}
 	} else {
 		//  Begin the transfer of an item. The item itself is passive.
 		//  launch_item() ensures the WareInstance is transported out of the
-		//  warehouse. Once it's on the flag, the flag code will decide what to
+		//  storage. Once it's on the flag, the flag code will decide what to
 		//  do with it.
 		WareInstance & item = supp.launch_item(game, *this);
 		ss.Unsigned32(item.serial());
@@ -533,7 +541,7 @@
  *
  * Re-open the request.
 */
-void Request::transfer_fail(Game &, Transfer & t) {
+void Request::transfer_fail(Game & game, Transfer & t) {
 	bool const wasopen = is_open();
 
 	t.m_worker = 0;
@@ -541,8 +549,12 @@
 
 	remove_transfer(find_transfer(t));
 
-	if (!wasopen)
+	if (!wasopen) {
 		m_economy->add_request(*this);
+	}
+	if (m_transfer_cb) {
+		m_transfer_cb(game, *this, m_index, nullptr, m_target);
+	}
 }
 
 /// Cancel the transfer with the given index.
 
=== modified file 'src/economy/request.h'
--- src/economy/request.h	2013-07-25 21:05:20 +0000
+++ src/economy/request.h	2013-08-10 10:53:03 +0000
@@ -20,6 +20,8 @@
 #ifndef REQUEST_H
 #define REQUEST_H
 
+#include <functional>
+
 #include "logic/requirements.h"
 #include "logic/wareworker.h"
 #include "logic/widelands.h"
@@ -39,11 +41,11 @@
 class RequestList;
 struct Requirements;
 struct Supply;
+class Storage;
 struct Transfer;
 class Worker;
 class Building;
 class ProductionSite;
-class Warehouse;
 class ConstructionSite;
 
 /**
@@ -63,8 +65,12 @@
 
 	typedef void (*callback_t)
 		(Game &, Request &, Ware_Index, Worker *, PlayerImmovable &);
+	typedef void (*callback_tranfert_t)
+		(Game &, Request &, Ware_Index, Worker *, PlayerImmovable &);
 
-	Request(PlayerImmovable & target, Ware_Index, callback_t, WareWorker);
+	Request
+		(PlayerImmovable & target, Ware_Index, callback_t, WareWorker,
+		 callback_tranfert_t transfer_cb = nullptr);
 	~Request();
 
 	PlayerImmovable & target() const throw () {return m_target;}
@@ -120,7 +126,7 @@
 	//  are filled with nulls.
 	Building        * m_target_building;
 	ProductionSite  * m_target_productionsite;
-	Warehouse       * m_target_warehouse;
+	Storage         * m_target_storage;
 	ConstructionSite * m_target_constructionsite;
 
 	Economy         * m_economy;
@@ -128,6 +134,7 @@
 	uint32_t          m_count;             //  how many do we need in total
 
 	callback_t        m_callbackfn;        //  called on request success
+	callback_tranfert_t m_transfer_cb; // called on worker transfer start/cancel
 
 	//  when do we need the first ware (can be in the past)
 	int32_t           m_required_time;
 
=== modified file 'src/economy/supply.h'
--- src/economy/supply.h	2013-07-26 19:16:51 +0000
+++ src/economy/supply.h	2013-08-10 10:53:03 +0000
@@ -25,10 +25,12 @@
 
 namespace Widelands {
 
+class StorageOwner;
+
 struct PlayerImmovable;
 struct Game;
 struct Request;
-class Warehouse;
+class StorageOwner;
 struct Ware_Index;
 class WareInstance;
 class Worker;
@@ -77,7 +79,7 @@
 	 * Sets up all the required transfers; assumes that \ref has_storage
 	 * returns \c false.
 	 */
-	virtual void send_to_storage(Game &, Warehouse * wh) = 0;
+	virtual void send_to_storage(Game &, StorageOwner * storage_owner) = 0;
 
 	/**
 	 * \return the number of items or workers that can be launched right
 
=== modified file 'src/economy/transfer.cc'
--- src/economy/transfer.cc	2013-07-26 20:19:36 +0000
+++ src/economy/transfer.cc	2013-08-10 10:53:03 +0000
@@ -191,6 +191,7 @@
 		Flag & curflag(m_route.get_flag(m_game, 0));
 		Flag & nextflag(m_route.get_flag(m_game, 1));
 		if (!curflag.get_road(nextflag)) {
+			//FIXME CGH
 			upcast(Warehouse, wh, curflag.get_building());
 			assert(wh);
 
 
=== modified file 'src/economy/ware_instance.cc'
--- src/economy/ware_instance.cc	2013-07-26 20:19:36 +0000
+++ src/economy/ware_instance.cc	2013-08-10 10:53:03 +0000
@@ -27,8 +27,8 @@
 #include "economy/transfer.h"
 #include "logic/game.h"
 #include "logic/ship.h"
+#include "logic/storage.h"
 #include "logic/tribe.h"
-#include "logic/warehouse.h"
 #include "logic/worker.h"
 #include "map_io/widelands_map_map_object_loader.h"
 #include "map_io/widelands_map_map_object_saver.h"
@@ -54,7 +54,7 @@
 	virtual bool is_active() const throw ();
 	virtual bool has_storage() const throw ();
 	virtual void get_ware_type(WareWorker & type, Ware_Index & ware) const;
-	virtual void send_to_storage(Game &, Warehouse * wh);
+	virtual void send_to_storage(Game &, StorageOwner * wh);
 
 	virtual uint32_t nr_supplies(const Game &, const Request &) const;
 	virtual WareInstance & launch_item(Game &, const Request &);
@@ -166,12 +166,12 @@
 	throw wexception("IdleWareSupply::launch_worker makes no sense");
 }
 
-void IdleWareSupply::send_to_storage(Game & game, Warehouse * wh)
+void IdleWareSupply::send_to_storage(Game & game, StorageOwner * storage_owner)
 {
 	assert(!has_storage());
 
 	Transfer * t = new Transfer(game, m_ware);
-	t->set_destination(*wh);
+	t->set_destination(*storage_owner->get_building());
 	m_ware.set_transfer(game, *t);
 }
 
@@ -290,8 +290,8 @@
 
 /**
  * Performs the state updates necessary for the current location:
- * - if it's a building, acknowledge the Request or incorporate into warehouse
- * - if it's a flag and we have no request, start the return to warehouse timer
+ * - if it's a building, acknowledge the Request or incorporate into strage
+ * - if it's a flag and we have no request, start the return to storage timer
  * and issue a Supply
  *
  * \note \ref update() may result in the deletion of this object.
@@ -405,22 +405,22 @@
 				return;
 			}
 
-			// There are some situations where we might end up in a warehouse
+			// There are some situations where we might end up in a storage
 			// as part of a requested route, and we need to move out of it
 			// again, e.g.:
 			//  - we were requested just when we were being carried into the
-			//    warehouse
+			//    storage
 			//  - we were carried into a harbour/warehouse to be
 			//    shipped across the sea, but a better, land-based route has been
 			//    found
-			if (upcast(Warehouse, warehouse, &building)) {
-				warehouse->do_launch_item(game, *this);
+			if (upcast(StorageOwner, storage_owner, &building)) {
+				storage_owner->get_storage()->do_launch_ware(game, *this);
 				return;
 			}
 
 			throw wexception
 				("MO(%u): ware(%s): do not know how to move from building %u (%s at (%u,%u)) "
-				 "to %u (%s) -> not a warehouse!",
+				 "to %u (%s) -> not a storage owner!",
 				 serial(), m_descr->name().c_str(), building.serial(),
 				 building.name().c_str(), building.get_position().x,
 				 building.get_position().y, nextstep->serial(),
 
=== removed file 'src/economy/warehousesupply.h'
--- src/economy/warehousesupply.h	2013-07-26 20:19:36 +0000
+++ src/economy/warehousesupply.h	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-/*
- * Copyright (C) 2008-2010 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 WAREHOUSESUPPLY_H
-#define WAREHOUSESUPPLY_H
-
-#include "logic/warelist.h"
-#include "logic/wareworker.h"
-#include "economy/supply.h"
-
-namespace Widelands {
-
-/*
-WarehouseSupply is the implementation of Supply that is used by Warehouses.
-It also manages the list of wares in the warehouse.
-*/
-struct WarehouseSupply : public Supply {
-	WarehouseSupply(Warehouse * const wh) : m_economy(0), m_warehouse(wh) {}
-	virtual ~WarehouseSupply();
-
-	void set_economy(Economy *);
-
-	void set_nrworkers(Ware_Index);
-	void set_nrwares  (Ware_Index);
-
-	const WareList & get_wares  () const {return m_wares;}
-	const WareList & get_workers() const {return m_workers;}
-	uint32_t stock_wares  (Ware_Index const i) const {
-		return m_wares  .stock(i);
-	}
-	uint32_t stock_workers(Ware_Index const i) const {
-		return m_workers.stock(i);
-	}
-	void add_wares     (Ware_Index, uint32_t count);
-	void remove_wares  (Ware_Index, uint32_t count);
-	void add_workers   (Ware_Index, uint32_t count);
-	void remove_workers(Ware_Index, uint32_t count);
-
-	// Supply implementation
-	virtual PlayerImmovable * get_position(Game &);
-	virtual bool is_active() const throw ();
-	virtual bool has_storage() const throw ();
-	virtual void get_ware_type(WareWorker & type, Ware_Index & ware) const;
-
-	virtual void send_to_storage(Game &, Warehouse * wh);
-	virtual uint32_t nr_supplies(const Game &, const Request &) const;
-	virtual WareInstance & launch_item(Game &, const Request &);
-	virtual Worker & launch_worker(Game &, const Request &);
-
-private:
-	Economy   * m_economy;
-	WareList    m_wares;
-	WareList    m_workers; //  we use this to keep the soldiers
-	Warehouse * m_warehouse;
-};
-
-}
-
-
-#endif
 
=== removed file 'src/logic/attackable.h'
--- src/logic/attackable.h	2012-02-15 21:25:34 +0000
+++ src/logic/attackable.h	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-/*
- * Copyright (C) 2008-2009 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 ATTACKABLE_H
-#define ATTACKABLE_H
-
-namespace Widelands {
-
-struct Player;
-class Soldier;
-
-enum {
-	/**
-	 * This is the maximum radius that a military building can protect
-	 * in the sense that an enemy soldier that enters the player's territory
-	 * will call \ref Attackable::aggressor if it is that close.
-	 */
-	MaxProtectionRadius = 25
-};
-
-/**
- * Buildings can implement this interface to indicate that
- * they can be attacked.
- */
-struct Attackable {
-	/**
-	 * Return the player that owns this attackable.
-	 */
-	virtual Player & owner() const = 0;
-
-	/**
-	 * Determines whether this building can be attacked right now.
-	 *
-	 * This should only return false for military sites that have not
-	 * been occupied yet.
-	 */
-	virtual bool canAttack() = 0;
-
-	/**
-	 * Called by an enemy soldier that enters a node with distance
-	 * less than or equal to \ref MaxProtectionRadius from the building.
-	 *
-	 * This allows the building to send protective forces to intercept
-	 * the soldier.
-	 */
-	virtual void aggressor(Soldier &) = 0;
-
-	/**
-	 * Called by a soldier who is standing on the building's flag
-	 * to attack the building.
-	 *
-	 * The building must send a soldier for defense, and return \c true.
-	 * Otherwise, i.e. if the building cannot defend itself anymore,
-	 * it must destroy itself or turn over to the attacking player,
-	 * and return \c false.
-	 *
-	 * \return \c true if a soldier was launched in defense of the building,
-	 * or \c false if the building cannot defend itself any longer.
-	 */
-	virtual bool attack(Soldier &) = 0;
-
-protected:
-	virtual ~Attackable() {}
-};
-
-}
-
-#endif
 
=== modified file 'src/logic/building.h'
--- src/logic/building.h	2013-08-08 19:55:12 +0000
+++ src/logic/building.h	2013-08-10 10:53:03 +0000
@@ -258,6 +258,9 @@
 	void set_defeating_player(Player_Number const player_number) {
 		m_defeating_player = player_number;
 	}
+	Player_Number get_defeating_player() {
+		return m_defeating_player;
+	}
 
 	void    add_worker(Worker &);
 	void remove_worker(Worker &);
 
=== modified file 'src/logic/findimmovable.cc'
--- src/logic/findimmovable.cc	2013-07-26 20:19:36 +0000
+++ src/logic/findimmovable.cc	2013-08-10 10:53:03 +0000
@@ -20,7 +20,6 @@
 #include "logic/findimmovable.h"
 
 #include "economy/flag.h"
-#include "logic/attackable.h"
 #include "logic/immovable.h"
 #include "logic/militarysite.h"
 #include "upcast.h"
@@ -61,7 +60,8 @@
 }
 
 bool FindImmovableAttackable        ::accept(const BaseImmovable & imm) const {
-	return dynamic_cast<Attackable const *>(&imm);
+	upcast(const GarrisonOwner, go, &imm);
+	return (go && go->get_garrison()->canAttack());
 }
 
 bool FindImmovableByDescr::accept(const BaseImmovable & baseimm) const {
 
=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2013-08-07 12:32:36 +0000
+++ src/logic/game.cc	2013-08-10 10:53:03 +0000
@@ -781,7 +781,8 @@
 		 	(get_gametime(), building.owner().player_number(), building));
 }
 
-void Game::send_player_militarysite_set_soldier_preference (Building & building, uint8_t my_preference)
+void Game::send_player_militarysite_set_soldier_preference
+	(Building & building, Garrison::SoldierPref my_preference)
 {
 	send_player_command
 		(*new Cmd_MilitarySiteSetSoldierPreference
 
=== modified file 'src/logic/game.h'
--- src/logic/game.h	2013-08-07 12:32:36 +0000
+++ src/logic/game.h	2013-08-10 10:53:03 +0000
@@ -22,6 +22,7 @@
 
 #include "logic/cmd_queue.h"
 #include "logic/editor_game_base.h"
+#include "logic/garrison.h"
 #include "md5.h"
 #include "random.h"
 #include "save_handler.h"
@@ -152,7 +153,7 @@
 	void send_player_build_road (int32_t, Path &);
 	void send_player_flagaction (Flag &);
 	void send_player_start_stop_building (Building &);
-	void send_player_militarysite_set_soldier_preference (Building &, uint8_t preference);
+	void send_player_militarysite_set_soldier_preference (Building &, Garrison::SoldierPref preference);
 	void send_player_start_or_cancel_expedition    (Building &);
 
 	void send_player_enhance_building (Building &, Building_Index);
 
=== added file 'src/logic/garrison.h'
--- src/logic/garrison.h	1970-01-01 00:00:00 +0000
+++ src/logic/garrison.h	2013-08-10 10:53:03 +0000
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2008-2009 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 GARRISON_H
+#define GARRISON_H
+
+#include <vector>
+
+#include "logic/widelands.h"
+
+namespace Widelands {
+
+class Building;
+
+
+class Building;
+class Editor_Game_Base;
+class Game;
+struct Player;
+class Soldier;
+
+enum {
+	/**
+	 * This is the maximum radius that a military building can protect
+	 * in the sense that an enemy soldier that enters the player's territory
+	 * will call \ref Attackable::aggressor if it is that close.
+	 */
+	MaxProtectionRadius = 25
+};
+/**
+ * A garrison represents a bunch of soldiers. Garrisons are owned by GarrisonOwner
+ * buildings. This interface provides various methods to deal with soldier control
+ * and attacks.
+ */
+class Garrison {
+public:
+	enum SoldierPref  : uint8_t {
+		None,
+		Rookies,
+		Heroes,
+	};
+	/**
+	 * Return the player that owns this attackable.
+	 */
+	virtual Player & owner() const = 0;
+
+	/**
+	 * Determines whether this building can be attacked right now.
+	 *
+	 * This should only return false for military sites that have not
+	 * been occupied yet, or by passivve garrison such as training sites.
+	 */
+	virtual bool canAttack() const = 0;
+
+	/**
+	 * Called by an enemy soldier that enters a node with distance
+	 * less than or equal to \ref MaxProtectionRadius from the building.
+	 *
+	 * This allows the building to send protective forces to intercept
+	 * the soldier.
+	 */
+	virtual void aggressor(Soldier &) = 0;
+
+	/**
+	 * Called by a soldier who is standing on the building's flag
+	 * to attack the building.
+	 *
+	 * The building must send a soldier for defense, and return \c true.
+	 * Otherwise, i.e. if the building cannot defend itself anymore,
+	 * it must destroy itself or turn over to the attacking player,
+	 * and return \c false.
+	 *
+	 * \return \c true if a soldier was launched in defense of the building,
+	 * or \c false if the building cannot defend itself any longer.
+	 */
+	virtual bool attack(Soldier &) = 0;
+
+	virtual bool is_passive() = 0;
+
+	virtual Building& get_building() = 0;
+
+	/**
+	 * \return a list of soldiers that are currently present in the building.
+	 */
+	virtual const std::vector<Soldier *> presentSoldiers() const = 0;
+
+	/**
+	 * \return a list of soldiers that are currently stationed in the building.
+	 * That is, all soldiers occupying a slot in the garrison.
+	 */
+	virtual const std::vector<Soldier *> stationedSoldiers() const = 0;
+
+	/**
+	 * \return the minimum number of soldiers that this building can be
+	 * configured to hold.
+	 */
+	virtual uint32_t minSoldierCapacity() const = 0;
+
+	/**
+	 * \return the maximum number of soldiers that this building can be
+	 * configured to hold.
+	 */
+	virtual uint32_t maxSoldierCapacity() const = 0;
+
+	/**
+	 * \return the number of soldiers this building is configured to hold
+	 * right now.
+	 */
+	virtual uint32_t soldierCapacity() const = 0;
+
+	/**
+	 * Sets the capacity for soldiers of this building.
+	 *
+	 * New soldiers will be requested and old soldiers will be evicted
+	 * as necessary.
+	 */
+	virtual void setSoldierCapacity(uint32_t capacity) = 0;
+	void changeSoldierCapacity(int32_t const difference) {
+		uint32_t const old_capacity = soldierCapacity();
+		uint32_t const new_capacity =
+			std::min
+				(static_cast<uint32_t>
+				 	(std::max
+				 	 	(static_cast<int32_t>(old_capacity) + difference,
+				 	 	 static_cast<int32_t>(minSoldierCapacity()))),
+				 static_cast<uint32_t>(maxSoldierCapacity()));
+		if (old_capacity != new_capacity)
+			setSoldierCapacity(new_capacity);
+	}
+	/**
+	 * Evict the given soldier from the building immediately,
+	 * without changing the building's capacity.
+	 *
+	 * \note This has no effect if the soldier is currently involved in a battle
+	 * or otherwise blocked from leaving the building.
+	 */
+	virtual void dropSoldier(Soldier &) = 0;
+
+	/**
+	 * Add a new soldier into this site. Returns -1 if there is no space
+	 * for him, 0 on success
+	 */
+	virtual int incorporateSoldier(Editor_Game_Base &, Soldier &) = 0;
+
+	/**
+	 * Remove a soldier from the internal list. Most SoldierControls will be
+	 * informed by the soldier when it is removed, but WareHouses for example
+	 * will not.
+	 */
+	virtual int outcorporateSoldier(Editor_Game_Base &, Soldier &) = 0;
+
+	/**
+	 * Returns the conquer radius of this garrison
+	 */
+	virtual uint32_t conquerRadius() const = 0;
+	/**
+	 * Set the soldier preference. Heroes or rookies?
+	 */
+	virtual void set_soldier_preference(SoldierPref p) = 0;
+	/**
+	 * \return the current soldier preference
+	 */
+	virtual SoldierPref get_soldier_preference() const = 0;
+	/**
+	 * Try to send the given soldier to attack the fiven target building.
+	 * This will fail if the soldier already has a job.
+	 */
+	virtual void sendAttacker(Soldier & soldier, Building & target, uint8_t retreat) = 0;
+};
+
+
+/**
+ * A Garrison owner holds a garrison. This interface is to be implemented by
+ * buildings that want to store some soldiers. The GarrionHandler Garrison
+ * implementation may be used as the Garrison provider.
+ */
+class GarrisonOwner {
+public:
+	/**
+	 * \return the garrison instance
+	 */
+	virtual Garrison* get_garrison() const = 0;
+	/**
+	 * @return the building owning the garrison
+	 */
+	virtual Building* get_building() = 0;
+	/**
+	 * Called when the garrison has been lost. \param defeating is set to the
+	 * enemy owner, or this owner if we keep military presence. if \param captured,
+	 * the enemy captured the building and a new one must be force built.
+	 *
+	 * Will not be called by passive garrisons
+	 */
+	virtual void garrison_lost(Game & game, Player_Number defeating, bool captured) = 0;
+	/**
+	 * Called when the garrison is occupied. You may light up the fire now
+	 *
+	 * Will not be called by passive garrison
+	 */
+	virtual void garrison_occupied() = 0;
+	/**
+	 * Called on the new site when a site has been conquered
+	 *
+	 * Will not be called by passive garrison
+	 */
+	virtual void reinit_after_conqueral(Game & game) = 0;
+};
+
+}
+
+#endif
 
=== added file 'src/logic/garrisonhandler.cc'
--- src/logic/garrisonhandler.cc	1970-01-01 00:00:00 +0000
+++ src/logic/garrisonhandler.cc	2013-08-10 10:53:03 +0000
@@ -0,0 +1,925 @@
+/*
+* Copyright (C) 2002-2004, 2006-2011 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/garrisonhandler.h"
+
+#include <functional>
+#include <memory>
+#include <vector>
+
+#include <boost/foreach.hpp>
+#include <boost/format.hpp>
+
+#include "container_iterate.h"
+#include "economy/flag.h"
+#include "economy/request.h"
+#include "log.h"
+#include "logic/building.h"
+#include "logic/findbob.h"
+#include "logic/instances.h"
+#include "logic/militarysite.h"
+#include "logic/player.h"
+#include "logic/soldier.h"
+#include "upcast.h"
+
+namespace Widelands {
+
+GarrisonHandler::GarrisonHandler
+	(Building& building, uint32_t min_soldiers, uint32_t max_soldiers, uint32_t conquer_radius,
+	uint32_t heal_per_second, SoldierPref soldier_pref, bool passive)
+: Garrison(),
+m_building(building),
+m_min_capacity(min_soldiers),
+m_max_capacity(max_soldiers),
+m_capacity(max_soldiers),
+m_passive(passive),
+m_heal_per_second(heal_per_second),
+m_last_heal_time(0),
+m_conquer_radius(conquer_radius),
+m_didconquer(false),
+m_soldier_preference(soldier_pref),
+m_last_swap_soldiers_time(0),
+m_try_soldier_upgrade(false),
+m_doing_upgrade_request(false)
+{
+	assert(is_a(GarrisonOwner, &m_building));
+}
+
+GarrisonHandler::~GarrisonHandler()
+{
+	assert(m_normal_soldier_request.get() == nullptr);
+	assert(m_upgrade_soldier_request.get() == nullptr);
+}
+
+void GarrisonHandler::load_finish(Editor_Game_Base& egbase)
+{
+	// If our soldiers array is empty (old savegame), fill it with soldiers
+	// found in building
+	if (m_soldiers.empty()) {
+		container_iterate_const(std::vector<Worker *>, m_building.get_workers(), i) {
+			if (upcast(Soldier, soldier, *i.current)) {
+				if (m_soldiers.size() < m_capacity) {
+					m_soldiers.push_back(soldier);
+				} else {
+					break;
+				}
+			}
+		}
+	}
+}
+
+void GarrisonHandler::init(Editor_Game_Base & egbase)
+{
+	// Ensure all soldiers are fresh and give them a new task
+	upcast(Game, game, &egbase);
+	container_iterate_const(std::vector<Soldier *>, m_soldiers, i) {
+		Soldier* soldier = *i.current;
+		assert(!soldier->get_state()); //  Should be newly created.
+		soldier->set_location_initially(m_building);
+		if (game) {
+			if (m_passive) {
+				soldier->start_task_idle(*game, 0, -1);
+			} else {
+				soldier->start_task_buildingwork(*game);
+			}
+		}
+	}
+	// Update requests and timers
+	update_soldier_request();
+	m_last_heal_time = egbase.get_gametime();
+}
+
+void GarrisonHandler::reinit_after_conqueral(Game& game)
+{
+	m_soldier_requirements = Requirements();
+	conquer_area(game);
+	update_soldier_request();
+}
+
+void GarrisonHandler::cleanup(Editor_Game_Base& egbase)
+{
+	if (m_didconquer && !m_passive) {
+		egbase.unconquer_area
+			(Player_Area<Area<FCoords> >
+				(owner().player_number(),
+					Area<FCoords>(egbase.map().get_fcoords(m_building.get_position()), m_conquer_radius)),
+		m_building.get_defeating_player());
+	}
+}
+
+void GarrisonHandler::cleanup_requests(Editor_Game_Base&)
+{
+	m_normal_soldier_request.reset();
+	m_upgrade_soldier_request.reset();
+}
+
+
+int32_t GarrisonHandler::act(Game& game)
+{
+	const int32_t timeofgame = game.get_gametime();
+	int32_t next_act = -1;
+	// Ensure requests integrity
+	if (m_normal_soldier_request && m_upgrade_soldier_request)
+	{
+		throw wexception("GarrisonHandler::act: Two soldier requests are ongoing -- should never happen!\n");
+	}
+	// Update requests periodically
+	bool full = stationedSoldiers().size() >= m_capacity;
+	if (!full && !m_doing_upgrade_request && !m_normal_soldier_request) {
+		// if we miss soldiers
+		update_soldier_request();
+	} else {
+		// If we may issue a new upgrade request
+		int32_t time_since_last_swap = (timeofgame - m_last_swap_soldiers_time);
+		if (time_since_last_swap > GARRISON_SWAP_TIMEOUT) {
+			time_since_last_swap = timeofgame;
+			update_soldier_request();
+			if (next_act < 0 || next_act > GARRISON_SWAP_TIMEOUT) {
+				next_act = GARRISON_SWAP_TIMEOUT;
+			}
+		}
+	}
+
+	// Calculate the amount of heal point to distribute
+	uint32_t to_heal_amount = static_cast<uint32_t>
+		((timeofgame - m_last_heal_time) * m_heal_per_second / 1000);
+	const std::vector<Soldier*> soldiers = presentSoldiers();
+	BOOST_FOREACH(Soldier* soldier, soldiers) {
+		uint32_t to_heal = soldier->get_max_hitpoints() - soldier->get_current_hitpoints();
+		if (to_heal > to_heal_amount) to_heal = to_heal_amount;
+		if (to_heal > 0) {
+			soldier->heal(to_heal);
+			to_heal_amount -= to_heal;
+			// Act once/s while healing
+			if (next_act < 0 || next_act > 1000) {
+				next_act = 1000;
+			}
+		}
+		if (to_heal_amount <= 0) break;
+	}
+	m_last_heal_time = timeofgame;
+	// Act once/5s when idle
+	if (next_act < 0) {
+		next_act = 5000;
+	}
+	return next_act;
+}
+
+void GarrisonHandler::popSoldier(Soldier* soldier)
+{
+	// Pop the soldier and update requests
+	popSoldierJob(soldier, nullptr, nullptr);
+	update_soldier_request();
+}
+
+void GarrisonHandler::set_economy(Economy * const e)
+{
+	// update requests
+	if (m_normal_soldier_request && e)
+		m_normal_soldier_request->set_economy(e);
+	if (m_upgrade_soldier_request && e)
+		m_upgrade_soldier_request->set_economy(e);
+}
+
+
+
+bool GarrisonHandler::get_garrison_work(Game& game, Soldier* soldier)
+{
+	// Evict soldiers that have returned home if the capacity is too low
+	if (m_capacity < stationedSoldiers().size()) {
+		evict_soldier(game, soldier);
+		return true;
+	}
+
+	bool stayhome;
+	uint8_t retreat;
+	if (Map_Object* enemy = popSoldierJob(soldier, &stayhome, &retreat)) {
+		if (upcast(Building, building, enemy)) {
+			soldier->start_task_attack(game, *building, retreat);
+			return true;
+		} else if (upcast(Soldier, opponent, enemy)) {
+			if (!opponent->getBattle()) {
+				soldier->start_task_defense(game, stayhome, retreat);
+				if (stayhome)
+					opponent->send_signal(game, "sleep");
+				return true;
+			}
+		} else
+			throw wexception("GarrisonHandler::get_garrison_work: bad SoldierJob");
+	}
+	return false;
+}
+
+void GarrisonHandler::set_soldier_requirements(Requirements req)
+{
+	m_soldier_requirements = req;
+}
+
+//
+// Garrison implementation
+//
+
+Player& GarrisonHandler::owner() const
+{
+	return m_building.owner();
+}
+
+bool GarrisonHandler::canAttack() const
+{
+	return m_didconquer && !m_passive;
+}
+
+void GarrisonHandler::aggressor(Soldier& enemy)
+{
+	Game & game = ref_cast<Game, Editor_Game_Base>(owner().egbase());
+	Map  & map  = game.map();
+	// Do not react if enemy is occupied or too far away
+	if
+		(enemy.get_owner() == &owner() || enemy.getBattle()
+		 || m_conquer_radius <= map.calc_distance
+			(enemy.get_position(), m_building.get_position()))
+	{
+		return;
+	}
+
+	// Do not react if enemy is at our door
+	if
+		(map.find_bobs
+		 	(Area<FCoords>(map.get_fcoords(m_building.base_flag().get_position()), 2), 0,
+		 	 FindBobEnemySoldier(&owner())))
+	{
+		return;
+	}
+
+	// Send some soldiers to defend, keeping min capacity inside
+	// This will send 1 soldier out to defend each time agressor()
+	// is called //FIXME?
+	const std::vector<Soldier*>& presents = presentSoldiers();
+	if (presents.size() >  m_min_capacity) {
+		container_iterate_const(std::vector<Soldier *>, presents, i) {
+			if (!haveSoldierJob(**i.current)) {
+				SoldierJob sj;
+				sj.soldier  = *i.current;
+				sj.enemy = &enemy;
+				sj.stayhome = false;
+				sj.retreat = owner().get_retreat_percentage();
+				m_soldierjobs.push_back(sj);
+				(*i.current)->update_task_buildingwork(game);
+				return;
+			}
+		}
+	}
+
+	// Inform the player, that we are under attack by adding a new entry to the
+	// message queue - a sound will automatically be played.
+	inform_owner(game, InfoType::AGGRESSSED);
+}
+
+bool GarrisonHandler::attack(Soldier& enemy)
+{
+	Game & game = ref_cast<Game, Editor_Game_Base>(owner().egbase());
+
+	const std::vector<Soldier*>& present = presentSoldiers();
+	Soldier * defender = 0;
+
+	if (!present.empty()) {
+		// Find soldier with greatest hitpoints
+		uint32_t current_max = 0;
+		container_iterate_const(std::vector<Soldier *>, present, i) {
+			if ((*i.current)->get_current_hitpoints() > current_max) {
+				defender = *i.current;
+				current_max = defender->get_current_hitpoints();
+			}
+		}
+	} else {
+		// If one of our stationed soldiers is currently walking into the
+		// building, give us another chance.
+		const std::vector<Soldier *>& stationed = stationedSoldiers();
+		container_iterate_const(std::vector<Soldier *>, stationed, i) {
+			if ((*i.current)->get_position() == m_building.get_position()) {
+				defender = *i.current;
+				break;
+			}
+		}
+	}
+
+	if (defender) {
+		popSoldierJob(defender); // defense overrides all other jobs
+
+		SoldierJob sj;
+		sj.soldier = defender;
+		sj.enemy = &enemy;
+		sj.stayhome = true;
+		sj.retreat = 0;         // Flag defenders could not retreat
+		m_soldierjobs.push_back(sj);
+
+		defender->update_task_buildingwork(game);
+
+		// Inform the player, that we are under attack by adding a new entry to
+		// the message queue - a sound will automatically be played.
+		inform_owner(game, InfoType::UNDER_ATTACK);
+		return true;
+	}
+
+	// The enemy has defeated our forces, we should inform the player
+	// Code for handling change of owner are handled in the garrison
+	// owner class.
+	upcast(GarrisonOwner, go, &m_building);
+	if (military_presence_kept(game)) {
+		inform_owner(game, InfoType::GARRISON_LOST);
+		go->garrison_lost(game, owner().player_number(), false);
+	} else {
+		inform_owner(game, InfoType::GARRISON_CAPTURED);
+		go->garrison_lost(game, enemy.owner().player_number(), true);
+	}
+	return false;
+}
+
+bool GarrisonHandler::is_passive()
+{
+	return m_passive;
+}
+
+Building& GarrisonHandler::get_building()
+{
+	return m_building;
+}
+
+
+
+const std::vector< Soldier* > GarrisonHandler::presentSoldiers() const
+{
+	std::vector<Soldier *> present_soldiers;
+	container_iterate_const(std::vector<Soldier*>, m_soldiers, i) {
+		if (isPresent(**i.current)) {
+			present_soldiers.push_back(*i.current);
+		}
+	}
+	return present_soldiers;
+}
+
+const std::vector< Soldier* > GarrisonHandler::stationedSoldiers() const
+{
+	return m_soldiers;
+}
+
+uint32_t GarrisonHandler::minSoldierCapacity() const
+{
+	return m_min_capacity;
+}
+
+uint32_t GarrisonHandler::maxSoldierCapacity() const
+{
+	return m_max_capacity;
+}
+
+uint32_t GarrisonHandler::soldierCapacity() const
+{
+	return m_capacity;
+}
+
+void GarrisonHandler::setSoldierCapacity(uint32_t capacity)
+{
+	assert(minSoldierCapacity() <= capacity);
+	assert                        (capacity <= maxSoldierCapacity());
+	assert(m_capacity != capacity);
+	m_capacity = capacity;
+	update_soldier_request();
+}
+
+void GarrisonHandler::dropSoldier(Soldier& soldier)
+{
+	Game & game = ref_cast<Game, Editor_Game_Base>(owner().egbase());
+
+	if (!isPresent(soldier)) {
+		// This can happen when the "drop soldier" player command is delayed
+		// by network delay or a client has bugs.
+		return;
+	}
+	// Ensure min capacity is respected
+	if (presentSoldiers().size() <= minSoldierCapacity()) {
+		return;
+	}
+	// Drop the soldier and update requests
+	evict_soldier(game, &soldier);
+	update_soldier_request();
+}
+
+int GarrisonHandler::incorporateSoldier(Editor_Game_Base& egbase, Soldier& s)
+{
+	// Adjust the soldier location if required.
+	if (s.get_location(egbase) != &m_building)
+	{
+		s.set_location(&m_building);
+	}
+	m_soldiers.push_back(&s);
+
+	upcast(Game, game, &egbase);
+	// If it's the first soldier, conquer the area
+	if (!m_passive && !m_didconquer) {
+		conquer_area(egbase);
+		if (game) {
+			inform_owner(*game, InfoType::GARRISON_OCCUPIED);
+		}
+		upcast(GarrisonOwner, go, &m_building);
+		go->garrison_occupied();
+	}
+
+	// Bind the worker into this house, hide him on the map
+	if (game) {
+		s.reset_tasks(*game);
+		if (m_passive) {
+			s.start_task_idle(*game, 0, -1);
+		} else {
+			s.start_task_buildingwork(*game);
+		}
+	}
+	// Make sure the request count is reduced or the request is deleted.
+	update_soldier_request();
+	return 0;
+}
+
+int GarrisonHandler::outcorporateSoldier(Editor_Game_Base&, Soldier&)
+{
+	// not needed
+	log("CGH Outcorporate called\n");
+	return -1;
+}
+
+uint32_t GarrisonHandler::conquerRadius() const
+{
+	return m_conquer_radius;
+}
+
+void GarrisonHandler::set_soldier_preference(GarrisonHandler::SoldierPref p)
+{
+	assert(SoldierPref::Heroes == p || SoldierPref::Rookies == p);
+	m_soldier_preference = p;
+	update_normal_soldier_request();
+}
+
+
+void GarrisonHandler::sendAttacker(Soldier& soldier, Building& target, uint8_t retreat)
+{
+	assert(isPresent(soldier));
+
+	if (haveSoldierJob(soldier)) {
+		return;
+	}
+
+	SoldierJob sj;
+	sj.soldier  = &soldier;
+	sj.enemy    = &target;
+	sj.stayhome = false;
+	sj.retreat  = retreat;
+	m_soldierjobs.push_back(sj);
+
+	soldier.update_task_buildingwork(ref_cast<Game, Editor_Game_Base>(owner().egbase()));
+}
+
+//
+// Private helper methods
+//
+void GarrisonHandler::inform_owner(Game& game, GarrisonHandler::InfoType info)
+{
+	if (m_passive) {
+		return;
+	}
+	std::string message;
+	std::string message_id;
+	std::string message_title;
+	std::string building_name = m_building.descname();
+	switch (info) {
+		case InfoType::AGGRESSSED:
+			message =
+				(boost::format
+					(_("Your %s discovered an aggressor")) % building_name)
+				.str();
+			message_id = "under_attack";
+			message_title = _("You are under attack");
+			break;
+		case InfoType::UNDER_ATTACK:
+			message =
+				(boost::format
+					(_("Your %s is under attack")) % building_name)
+				.str();
+			message_id = "under_attack";
+			message_title = _("You are under attack");
+			break;
+		case InfoType::GARRISON_LOST:
+			message =
+				(boost::format
+					(_("The enemy defeated your soldiers and destroyed your %s")) % building_name)
+				.str();
+			message_id = "garrison_lost";
+			message_title = _("Garrison lost");
+			break;
+		case InfoType::GARRISON_CAPTURED:
+			message =
+				(boost::format
+					(_("The enemy defeated your soldiers and captured your %s")) % building_name)
+				.str();
+			message_id = "garrison_lost";
+			message_title = _("Garrison captured");
+			break;
+		case InfoType::GARRISON_OCCUPIED:
+			message =
+				(boost::format
+					(_("Your soldier occupied your %s")) % building_name)
+				.str();
+			message_id = "garrison_occupied";
+			message_title = _("Garrison occupied");
+			break;
+		default:
+			assert(false);
+	}
+	m_building.send_message(game, message_id, message_title, message);
+}
+
+bool GarrisonHandler::isPresent(Soldier& soldier) const
+{
+	if
+		(soldier.get_location(owner().egbase()) != &m_building
+		|| soldier.get_position() != m_building.get_position())
+	{
+		return false;
+	}
+	// Present soldiers are working for the garrison only if it is not passive
+	if (!m_passive) {
+		return
+			soldier.get_state() == soldier.get_state(Worker::taskBuildingwork);
+	}
+	return true;
+}
+
+void GarrisonHandler::conquer_area(Editor_Game_Base& egbase)
+{
+	assert(!m_didconquer);
+	egbase.conquer_area
+		(Player_Area<Area<FCoords> >
+			(owner().player_number(),
+			Area<FCoords>
+				(egbase.map().get_fcoords(m_building.get_position()), m_conquer_radius)));
+	m_didconquer = true;
+}
+
+bool GarrisonHandler::military_presence_kept(Game& game)
+{
+	// collect information about immovables in the area
+	std::vector<ImmovableFound> immovables;
+
+	// Search in a radius of 3 (needed for big militarysites)
+	FCoords const fc = game.map().get_fcoords(m_building.get_position());
+	game.map().find_immovables(Area<FCoords>(fc, 3), &immovables);
+
+	for (uint32_t i = 0; i < immovables.size(); ++i) {
+		upcast(GarrisonOwner, go, immovables[i].object);
+		if (!go) {
+			continue;
+		}
+		Garrison* g = go->get_garrison();
+		upcast(GarrisonOwner, mygo, &m_building);
+		// NOCOM I changed the logic here to check for any stationed soldier
+		// and not for m_didconquer. So a msite with all slots empty and soldiers
+		// on their way won't keep military presence anymore.
+
+		// Presence kept if any non-empty garrison with higher conquer radius
+		// and owned by our owner is nearby
+		if
+			(mygo != go
+			&& owner().player_number() == g->owner().player_number()
+			&& conquerRadius() < g->conquerRadius()
+			&& !g->stationedSoldiers().empty())
+		{
+			return true;
+		}
+	}
+	return false;
+}
+
+//FIXME CGH use a cleaner way without polling required
+void GarrisonHandler::update_soldier_request(bool upgraded_in)
+{
+/*
+ * I have update_soldier_request
+ *        update_upgrade_soldier_request
+ *        update_normal_soldier_request
+ *
+ * The first one handles state switching between site fill (normal more)
+ * and grabbing soldiers with proper training (upgrade mode). The last
+ * two actually make the requests.
+ *
+ * The input parameter incd is true, if we just incorporated a new soldier
+ * as a result of an upgrade request. In such cases, we will re-arm the
+ * upgrade request.
+ */
+	const uint32_t capacity = soldierCapacity();
+	const uint32_t stationed = stationedSoldiers().size();
+
+	if (m_doing_upgrade_request) {
+		if (upgraded_in && m_upgrade_soldier_request) {// update requests always ask for one soldier at time!
+			m_upgrade_soldier_request.reset();
+		}
+		if (capacity > stationed) {
+			// Somebody is killing my soldiers in the middle of upgrade
+			// or I have kicked out his predecessor already.
+			if
+				((m_upgrade_soldier_request)
+				&& (m_upgrade_soldier_request->is_open() || 0 == m_upgrade_soldier_request->get_count()))
+			{
+				// Economy was not able to find the soldiers I need.
+				// I can safely drop the upgrade request and go to fill mode.
+				m_upgrade_soldier_request.reset();
+			}
+			if (!m_upgrade_soldier_request) {
+				//phoo -- I can safely request new soldiers.
+				m_doing_upgrade_request = false;
+				update_normal_soldier_request();
+			}
+			// else -- ohno please help me! Player is in trouble -- evil grin
+			// An upgraded soldier is on his way, but since we only make one request
+			// at a time, we have to wait for him to arrive before doing another
+			// request to fill capacity.
+			//FIXME
+		} else if (capacity < stationed) {// player is reducing capacity
+			drop_least_suited_soldier();
+		} else {// capacity == stationed size
+			update_upgrade_soldier_request();
+		}
+	} else {// not doing upgrade request
+		if ((capacity != stationed) or (m_normal_soldier_request)) {
+			update_normal_soldier_request();
+		}
+		if ((capacity == stationed) && (! m_normal_soldier_request) && !m_passive) {
+			// Our site is full, we might try to get upgraded soldiers
+			// TODO not allowed for passive garrison for now
+			if (presentSoldiers().size() == capacity && capacity > m_min_capacity) {
+				m_doing_upgrade_request = true;
+			}
+		}
+	}
+}
+
+void GarrisonHandler::update_normal_soldier_request()
+{
+	// Request new soldiers if needed
+	std::vector<Soldier*> soldiers = stationedSoldiers();
+	if (soldiers.size() < m_capacity) {
+		if (!m_normal_soldier_request) {
+			// No ongoing request, fill a new one
+			Request* r = new Request
+				(m_building, m_building.tribe().safe_worker_index("soldier"),
+				 GarrisonHandler::request_soldier_callback, wwWORKER);
+			r->set_requirements(m_soldier_requirements);
+			m_normal_soldier_request.reset(r);
+		}
+		// Already an ongoing request, update counts
+		m_normal_soldier_request->set_count(m_capacity - soldiers.size());
+	} else {
+		// No new soldier required. Destroy request if there is one
+		m_normal_soldier_request.reset();
+	}
+	// Evict present soldiers if required
+	const std::vector<Soldier *>& present = presentSoldiers();
+	if (present.size() > m_capacity) {
+		Game & game = ref_cast<Game, Editor_Game_Base>(owner().egbase());
+		for (uint32_t i = 0; i < present.size() - m_capacity; ++i) {
+			Soldier * soldier = present[i];
+			evict_soldier(game, soldier);
+		}
+	}
+}
+
+void GarrisonHandler::update_upgrade_soldier_request()
+{
+	bool reqirement_changed = update_upgrade_requirements();
+	// Update the requirements
+	if (!m_try_soldier_upgrade) {
+		return;
+	}
+	// Do not perform a new request if someone is on his way
+	// or if we are going to request the same thing
+	if (m_upgrade_soldier_request) {
+		if (!m_upgrade_soldier_request->is_open()) {
+			// upgraded soldier is on his way
+			return;
+		}
+		if (!reqirement_changed && m_upgrade_soldier_request->get_count() > 0) {
+			// Current request is still valid
+			return;
+		}
+	}
+	// Issue a new request
+	Request* r = new Request
+		(m_building, m_building.tribe().safe_worker_index("soldier"),
+		GarrisonHandler::request_soldier_callback, wwWORKER,
+		GarrisonHandler::request_soldier_transfer_callback);
+	// Honor soldier requirements if set by the garrison owner
+	RequireAnd upgrade_requirement;
+	upgrade_requirement.add(m_soldier_requirements);
+	upgrade_requirement.add(m_soldier_upgrade_requirements);
+	r->set_requirements(upgrade_requirement);
+	r->set_count(1);
+	m_upgrade_soldier_request.reset(r);
+}
+
+void GarrisonHandler::request_soldier_callback
+	(Game& game, Request&, Ware_Index, Worker* w, PlayerImmovable& pi)
+{
+	Soldier& s = ref_cast<Soldier, Worker>(*w);
+	upcast(GarrisonOwner, go, &pi);
+	upcast(GarrisonHandler, gh, go->get_garrison());
+
+	if (!gh->m_doing_upgrade_request) {
+		gh->incorporateSoldier(game, s);
+	} else {
+		gh->incorporateUpgradedSoldier(game, s);
+	}
+}
+
+void GarrisonHandler::request_soldier_transfer_callback
+	(Game&, Request&, Ware_Index, Worker* w, PlayerImmovable& pi)
+{
+	Soldier& s = ref_cast<Soldier, Worker>(*w);
+	upcast(GarrisonOwner, go, &pi);
+	upcast(GarrisonHandler, gh, go->get_garrison());
+
+	if (gh->m_doing_upgrade_request) {
+		gh->drop_least_suited_soldier(&s);
+	}
+}
+
+bool GarrisonHandler::update_upgrade_requirements()
+{
+	int32_t soldier_upgrade_required_min = m_soldier_upgrade_requirements.getMin();
+	int32_t soldier_upgrade_required_max = m_soldier_upgrade_requirements.getMax();
+
+	if
+		(SoldierPref::Heroes != m_soldier_preference
+		 && SoldierPref::Rookies != m_soldier_preference)
+	{
+		m_try_soldier_upgrade = false;
+		return false;
+	}
+
+	// Find the level of the soldier that is currently least-suited.
+	Soldier * worst_guy = find_least_suited_soldier();
+	if (worst_guy == nullptr) {
+		// There could be no soldier in the militarysite right now. No reason to freak out.
+		return false;
+	}
+	int32_t wg_level = worst_guy->get_level(atrTotal);
+
+	// Micro-optimization: I assume that the majority of military sites have only level-zero
+	// soldiers and prefer rookies. Handle them separately.
+	if (m_soldier_preference == SoldierPref::Rookies && wg_level == 0) {
+		m_try_soldier_upgrade = false;
+		return false;
+	}
+	m_try_soldier_upgrade = true;
+
+	// Now I actually build the new requirements.
+	int32_t reqmin = SoldierPref::Heroes == m_soldier_preference ? 1 + wg_level : 0;
+	int32_t reqmax = SoldierPref::Heroes == m_soldier_preference ? SHRT_MAX : wg_level - 1;
+
+	bool maxchanged = reqmax != soldier_upgrade_required_max;
+	bool minchanged = reqmin != soldier_upgrade_required_min;
+
+	if (maxchanged or minchanged) {
+		m_soldier_upgrade_requirements = RequireAttribute(atrTotal, reqmin, reqmax);
+		return true;
+	}
+	return false;
+}
+
+bool GarrisonHandler::incorporateUpgradedSoldier(Editor_Game_Base& egbase, Soldier& s)
+{
+	// Call to drop_least routine has side effects: it tries to drop a soldier. Order is important!
+	assert(isPresent(s));
+	std::vector<Soldier*> stationned = stationedSoldiers();
+	if (stationned.size() < m_capacity || drop_least_suited_soldier(&s)) {
+		Game & game = ref_cast<Game, Editor_Game_Base>(egbase);
+		s.set_location(&m_building);
+		m_soldiers.push_back(&s);
+		s.reset_tasks(game);
+		if (!m_passive) {
+			s.start_task_buildingwork(game);
+		} else {
+			s.start_task_idle(game, 0, -1);
+		}
+		// Reset timer for new request
+		m_upgrade_soldier_request.reset();
+		m_last_swap_soldiers_time = game.get_gametime();
+		return true;
+	}
+	return false;
+}
+
+Soldier* GarrisonHandler::find_least_suited_soldier()
+{
+	const std::vector<Soldier *>& present = presentSoldiers();
+	const int32_t multiplier = m_soldier_preference == SoldierPref::Heroes ? -1 : 1;
+	int worst_soldier_level = INT_MIN;
+	Soldier * worst_soldier = nullptr;
+	BOOST_FOREACH(Soldier * sld, present)
+	{
+		int this_soldier_level = multiplier * static_cast<int> (sld->get_level(atrTotal));
+		if (this_soldier_level > worst_soldier_level)
+		{
+			worst_soldier_level = this_soldier_level;
+			worst_soldier = sld;
+		}
+	}
+	return worst_soldier;
+}
+
+bool GarrisonHandler::drop_least_suited_soldier(Soldier* newguy)
+{
+	const std::vector<Soldier *>& present = presentSoldiers();
+	// Don't drop under the minimum capacity if new guy is not here yet
+	if (newguy == nullptr && present.size() <= m_min_capacity) {
+		return false;
+	}
+	Soldier * kickoutCandidate = find_least_suited_soldier();
+
+	// If the arriving guy is worse than worst present, I wont't release.
+	if (newguy != nullptr && kickoutCandidate != nullptr) {
+		int32_t old_level = kickoutCandidate->get_level(atrTotal);
+		int32_t new_level = newguy->get_level(atrTotal);
+		if (m_soldier_preference == SoldierPref::Heroes && old_level >= new_level) {
+			return false;
+		} else if (m_soldier_preference == SoldierPref::Rookies && old_level <= new_level) {
+			return false;
+		}
+	}
+
+	// Now I know that the new guy is worthy.
+	if (kickoutCandidate != nullptr) {
+		Game & game = ref_cast<Game, Editor_Game_Base>(owner().egbase());
+		evict_soldier(game, kickoutCandidate);
+		return true;
+	}
+	return false;
+}
+
+bool GarrisonHandler::haveSoldierJob(Soldier& soldier) const
+{
+	container_iterate_const(std::vector<SoldierJob>, m_soldierjobs, i) {
+		if (i.current->soldier == &soldier) {
+			return true;
+		}
+	}
+	return false;
+}
+
+Map_Object* GarrisonHandler::popSoldierJob(Soldier* soldier, bool* stayhome, uint8_t* retreat)
+{
+	container_iterate(std::vector<SoldierJob>, m_soldierjobs, i)
+		if (i.current->soldier == soldier) {
+			Map_Object * const enemy = i.current->enemy.get(owner().egbase());
+			if (stayhome)
+				*stayhome = i.current->stayhome;
+			if (retreat)
+				*retreat = i.current->retreat;
+			m_soldierjobs.erase(i.current);
+			return enemy;
+		}
+	return 0;
+}
+
+void GarrisonHandler::evict_soldier(Game& game, Soldier* s)
+{
+	assert(s);
+	upcast(StorageOwner, storage_owner, &m_building);
+	std::vector<Soldier*>::iterator it;
+	for (it = m_soldiers.begin(); it != m_soldiers.end(); ++it) {
+		if ((*it)->serial() == s->serial()) {
+			m_soldiers.erase(it);
+			s->reset_tasks(game);
+			if (storage_owner) {
+				storage_owner->get_storage()->incorporate_worker(game, *s);
+			} else {
+				s->start_task_leavebuilding(game, true);
+			}
+			return;
+		}
+	}
+}
+
+}
 
=== added file 'src/logic/garrisonhandler.h'
--- src/logic/garrisonhandler.h	1970-01-01 00:00:00 +0000
+++ src/logic/garrisonhandler.h	2013-08-10 10:53:03 +0000
@@ -0,0 +1,262 @@
+/*
+ * Copyright (C) 2002-2004, 2006-2011 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 GARRISON_HANDLER_H
+#define GARRISON_HANDLER_H
+
+#include "logic/instances.h"
+#include "logic/garrison.h"
+#include "logic/requirements.h"
+#include "logic/worker.h"
+
+namespace Widelands {
+
+struct Building;
+struct Request;
+class Soldier;
+
+#define GARRISON_SWAP_TIMEOUT 20000
+/**
+ * Implementation of the Garrison interface to used by GarrisonOwner.
+ */
+class GarrisonHandler : public Garrison {
+friend struct Map_Buildingdata_Data_Packet;
+public:
+	/**
+	 * Create a new garrison handler
+	 * \param building The building that holds this garrison. Must implements GarrisonOwner
+	 * \param min_soldiers The minimum soldiers to be present in the garrison
+	 * \param max_soldiers The maximum soldiers that can be present in this garrison
+	 * \param conquer_radius The radius of the area conqered by this garrison
+	 * \param heal_per_second The speed at which soldiers will be healed
+	 * \param soldier_pref The soldier preference for rookies or heroes
+	 * \param passive A passive garrison is only helpful to keep some soldiers around. It can't
+	 * attack nor be attacked. I think of training site or ships
+	 */
+	GarrisonHandler
+		(Building& building, uint32_t min_soldiers, uint32_t max_soldiers,
+		 uint32_t conquer_radius, uint32_t heal_per_second, SoldierPref soldier_pref,
+		 bool passive = false);
+	virtual ~GarrisonHandler();
+
+	void load_finish(Editor_Game_Base &);
+	/**
+	 * Must be called once
+	 */
+	void init(Editor_Game_Base &);
+	/**
+	 * Must be called once after conqueral
+	 */
+	void reinit_after_conqueral(Game & game);
+	/**
+	 * Cleanup handled objects
+	 */
+	void cleanup(Editor_Game_Base &);
+	/**
+	 * Eequests must be cleaned up after the building has
+	 * been cleaned up, hence this seperate function.
+	 */
+	void cleanup_requests(Editor_Game_Base &);
+	/**
+	 * Must be called regularly. It is not time dependant though.
+	 * \Return the time when the next act should occur
+	 */
+	int32_t act(Game &);
+	/**
+	 * Must be called when the owner building changes economy
+	 */
+	void set_economy(Economy * const e);
+	/**
+	 * Pop the given soldier out of the building, while keeping it
+	 * in the garrion.
+	 */
+	void popSoldier(Soldier* soldier);
+	/**
+	 * Get some work for a soldier that asks for it
+	 */
+	bool get_garrison_work(Game & game, Soldier* soldier);
+	/**
+	 * Set the requirements for that soldier. This will be used when filling
+	 * request for soldiers.
+	 */
+	void set_soldier_requirements(Requirements req);
+
+	// Garrison implementation
+	virtual Player & owner() const;
+	virtual bool canAttack() const;
+	virtual void aggressor(Soldier &);
+	virtual bool attack(Soldier &);
+	virtual bool is_passive();
+	virtual Building& get_building();
+	virtual const std::vector<Soldier *> presentSoldiers() const;
+	virtual const std::vector<Soldier *> stationedSoldiers() const;
+	virtual uint32_t minSoldierCapacity() const;
+	virtual uint32_t maxSoldierCapacity() const;
+	virtual uint32_t soldierCapacity() const;
+	virtual void setSoldierCapacity(uint32_t capacity);
+	virtual void dropSoldier(Soldier &);
+	virtual int incorporateSoldier(Editor_Game_Base &, Soldier &);
+	virtual int outcorporateSoldier(Editor_Game_Base &, Soldier &);
+	virtual uint32_t conquerRadius() const;
+	virtual void set_soldier_preference(SoldierPref p);
+	virtual SoldierPref get_soldier_preference() const {
+		return m_soldier_preference;
+	}
+	virtual void sendAttacker(Soldier & soldier, Building & target, uint8_t retreat);
+
+
+private:
+	enum class InfoType : uint8_t {
+		AGGRESSSED,
+		UNDER_ATTACK,
+		GARRISON_LOST,
+		GARRISON_CAPTURED,
+		GARRISON_OCCUPIED
+	};
+	// Helper methods
+	/**
+	 * Sends a message to the owner
+	 */
+	void inform_owner(Game&, InfoType);
+	/**
+	 * Check if a soldier is actually present in building
+	 */
+	bool isPresent(Soldier &) const;
+	/**
+	 * Conquers the area once a soldier occupied the site
+	 */
+	void conquer_area(Editor_Game_Base &);
+	/**
+	 * Check if we keep military influence once our garrison
+	 * has been conquered
+	 */
+	bool military_presence_kept(Game &);
+	/**
+	 * Update the soldier requests. If upgraded_incorporated, a soldier
+	 * requested by an upgrade request has just been incorporated. This
+	 * method handle requesting for normal case (filling slots) or for
+	 * upgrading to a better suited soldier
+	 */
+	void update_soldier_request(bool upgraded_incorporated = false);
+	/**
+	 * Request new soldiers or evict some to fill the capacity
+	 */
+	void update_normal_soldier_request();
+	/* There are two kinds of soldier requests: "normal", which is used whenever the military site needs
+	* more soldiers, and "upgrade" which is used when there is a preference for either heroes or
+	* rookies.
+	*
+	* In case of normal requests, the military site is filled. In case of upgrade requests, only one guy
+	* is exchanged at a time.
+	*
+	* There would be more efficient ways to get well trained soldiers. Now, new buildings appearing in battle
+	* field are more vulnerable at the beginning. This is intentional. The purpose of this upgrade thing is
+	* to reduce the benefits of site micromanagement. The intention is not to make gameplay easier
+	* in other ways.
+	*/
+	void update_upgrade_soldier_request();
+	/**
+	 * The callback function, called whenever one of our soldier requested arrived
+	 */
+	static void request_soldier_callback
+		(Game &, Request &, Ware_Index, Worker *, PlayerImmovable &);
+	/**
+	 * The transfer callback function, called whenever one of our requested
+	 * soldier started to move towards the garrison
+	 */
+	static void request_soldier_transfer_callback
+		(Game &, Request &, Ware_Index, Worker *, PlayerImmovable &);
+	/*
+	* When upgrading soldiers, we do not ask for just any soldiers, but soldiers
+	* that are better than what we already have. This routine sets the requirements
+	* used by the request.
+	*
+	* The routine returns true if upgrade request thresholds have changed. This information could be
+	* used to decide whether the soldier-Request should be upgraded. Additionally, the m_try_soldier_upgrade
+	* field will be set so to know if an attempt to get better soldier sould be performed.
+	*/
+	bool update_upgrade_requirements();
+	/**
+	 * Called when an upgraded soldier comes to join the garrison
+	 */
+	bool incorporateUpgradedSoldier(Editor_Game_Base & game, Soldier & s);
+	/**
+	 * Find the least suited soldier for this garrison. We don't play
+	 * in the same league
+	 */
+	Soldier * find_least_suited_soldier();
+	/**
+	 * Try to drop the lease suited soldier, return true on success.
+	 * If a new soldier s has arrived, extra care will be taken to not drop
+	 * anyone if the new one is even worst
+	 */
+	bool drop_least_suited_soldier(Soldier * s = nullptr);
+	/**
+	 * Return true if we hold a running job for that soldied
+	 */
+	bool haveSoldierJob(Soldier &) const;
+	/**
+	* \return the enemy, if any, that the given soldier was scheduled
+	* to attack, and remove the job.
+	*/
+	Map_Object * popSoldierJob(Soldier *, bool * stayhome = 0, uint8_t * retreat = 0);
+
+	void evict_soldier(Game&, Soldier*);
+
+	// Basic fields
+	Building& m_building;
+	uint32_t m_min_capacity;
+	uint32_t m_max_capacity;
+	uint32_t m_capacity;
+	bool m_passive;
+	std::vector<Soldier*> m_soldiers;
+
+	// Healing
+	uint32_t m_heal_per_second;
+	uint32_t m_last_heal_time;
+
+	// Requests
+	Requirements m_soldier_requirements; // This is used to grab a bunch of soldiers: Anything goes
+	RequireAttribute m_soldier_upgrade_requirements; // This is used when exchanging soldiers.
+	std::unique_ptr<Request> m_normal_soldier_request;  // filling the site
+	std::unique_ptr<Request> m_upgrade_soldier_request; // seeking for better soldiers
+
+	// Conqueral
+	uint32_t m_conquer_radius;
+	bool m_didconquer;
+
+	// Job
+	struct SoldierJob {
+		Soldier    * soldier;
+		Object_Ptr  enemy;
+		bool        stayhome;
+		uint8_t     retreat;
+	};
+	std::vector<SoldierJob> m_soldierjobs;
+
+	// Soldier preferences
+	SoldierPref m_soldier_preference;
+	uint32_t m_last_swap_soldiers_time;
+	bool m_try_soldier_upgrade; // optimization -- if everybody is zero-level, do not downgrade
+	bool m_doing_upgrade_request;
+};
+
+}
+
+#endif
 
=== modified file 'src/logic/item_ware_descr.h'
--- src/logic/item_ware_descr.h	2013-07-26 20:19:36 +0000
+++ src/logic/item_ware_descr.h	2013-08-10 10:53:03 +0000
@@ -41,7 +41,7 @@
 namespace Widelands {
 
 /**
- * Wares can be stored in warehouses. They can be transferred across an
+ * Wares can be stored in storages. They can be transferred across an
  * Economy. They can be traded.
  * Both items (lumber, stone, ...) and workers are considered wares.
  * Every ware has a unique name. Note that an item must not have the same
@@ -75,7 +75,7 @@
 	/// \return ware's localized descriptive text
 	const std::string & helptext() const throw () {return m_helptext;}
 
-	/// How much of the ware type that an economy should store in warehouses.
+	/// How much of the ware type that an economy should store in storages.
 	/// The special value std::numeric_limits<uint32_t>::max() means that the
 	/// the target quantity of this ware type will never be checked and should
 	/// not be configurable.
 
=== modified file 'src/logic/militarysite.cc'
--- src/logic/militarysite.cc	2013-08-08 19:55:12 +0000
+++ src/logic/militarysite.cc	2013-08-10 10:53:03 +0000
@@ -21,8 +21,10 @@
 
 #include <clocale>
 #include <cstdio>
+#include <memory>
 
 #include <boost/foreach.hpp>
+#include <boost/format.hpp>
 #include <libintl.h>
 
 #include "economy/flag.h"
@@ -33,6 +35,7 @@
 #include "logic/editor_game_base.h"
 #include "logic/findbob.h"
 #include "logic/game.h"
+#include "logic/garrisonhandler.h"
 #include "logic/message_queue.h"
 #include "logic/player.h"
 #include "logic/soldier.h"
@@ -55,13 +58,13 @@
 m_num_soldiers       (0),
 m_heal_per_second    (0)
 {
-	m_conquer_radius      = global_s.get_safe_int("conquers");
-	m_num_soldiers        = global_s.get_safe_int("max_soldiers");
-	m_heal_per_second     = global_s.get_safe_int("heal_per_second");
+	Section& garrison_s = prof.get_safe_section("garrison");
+	m_conquer_radius      = garrison_s.get_safe_int("conquers");
+	m_num_soldiers        = garrison_s.get_safe_int("max_soldiers");
+	m_heal_per_second     = garrison_s.get_safe_int("heal_per_second");
 	if (m_conquer_radius > 0)
 		m_workarea_info[m_conquer_radius].insert(descname() + _(" conquer"));
-	m_prefers_heroes_at_start = global_s.get_safe_bool("prefer_heroes");
-
+	m_prefers_heroes_at_start = garrison_s.get_safe_bool("prefer_heroes");
 }
 
 /**
@@ -83,96 +86,45 @@
 */
 
 MilitarySite::MilitarySite(const MilitarySite_Descr & ms_descr) :
-ProductionSite(ms_descr),
-m_didconquer  (false),
-m_capacity    (ms_descr.get_max_number_of_soldiers()),
-m_nexthealtime(0),
-m_soldier_preference(ms_descr.m_prefers_heroes_at_start ? kPrefersHeroes : kPrefersRookies),
-m_soldier_upgrade_try(false)
+ProductionSite(ms_descr)
 {
-	m_next_swap_soldiers_time = 0;
+	GarrisonHandler* gh = new GarrisonHandler
+		(*this, 1,
+		 descr().get_max_number_of_soldiers(),
+		 descr().get_conquers(), descr().get_heal_per_second(),
+		 descr().m_prefers_heroes_at_start ? GarrisonHandler::SoldierPref::Heroes
+			: GarrisonHandler::SoldierPref::Rookies);
+	m_garrison.reset(gh);
 }
 
-
 MilitarySite::~MilitarySite()
 {
-	assert(!m_normal_soldier_request);
-	assert(!m_upgrade_soldier_request);
 }
 
-
-/**
-===============
-Display number of soldiers.
-===============
-*/
-std::string MilitarySite::get_statistics_string()
+void MilitarySite::load_finish(Editor_Game_Base& egbase)
 {
-	char buffer[255];
-	std::string str;
-	uint32_t present = presentSoldiers().size();
-	uint32_t total = stationedSoldiers().size();
-
-	if (present == total) {
-		snprintf
-			(buffer, sizeof(buffer),
-			 ngettext("%u soldier", "%u soldiers", total),
-			 total);
-	} else {
-		snprintf
-			(buffer, sizeof(buffer),
-			 ngettext("%u(+%u) soldier", "%u(+%u) soldiers", total),
-			 present, total - present);
-	}
-	str = buffer;
-
-	if (m_capacity > total) {
-		snprintf(buffer, sizeof(buffer), " (+%u)", m_capacity - total);
-		str += buffer;
-	}
-
-	return str;
+	Widelands::Building::load_finish(egbase);
+	m_garrison->load_finish(egbase);
 }
 
-
 void MilitarySite::init(Editor_Game_Base & egbase)
 {
 	ProductionSite::init(egbase);
-
+	m_garrison->init(egbase);
 	upcast(Game, game, &egbase);
 
 	const std::vector<Worker*>& ws = get_workers();
-	container_iterate_const(std::vector<Worker *>, ws, i)
+	container_iterate_const(std::vector<Worker *>, ws, i) {
 		if (upcast(Soldier, soldier, *i.current)) {
 			soldier->set_location_initially(*this);
-			assert(!soldier->get_state()); //  Should be newly created.
-			if (game)
-				soldier->start_task_buildingwork(*game);
+			m_garrison->incorporateSoldier(egbase, *soldier);
 		}
-	update_soldier_request();
-
-	//  schedule the first healing
-	m_nexthealtime = egbase.get_gametime() + 1000;
-	if (game)
+	}
+	if (game) {
 		schedule_act(*game, 1000);
-}
-
-
-/**
-===============
-Change the economy for the wares queues.
-Note that the workers are dealt with in the PlayerImmovable code.
-===============
-*/
-void MilitarySite::set_economy(Economy * const e)
-{
-	ProductionSite::set_economy(e);
-
-	if (m_normal_soldier_request && e)
-		m_normal_soldier_request->set_economy(e);
-	if (m_upgrade_soldier_request && e)
-		m_upgrade_soldier_request->set_economy(e);
-}
+	}
+}
+
 
 /**
 ===============
@@ -181,16 +133,12 @@
 */
 void MilitarySite::cleanup(Editor_Game_Base & egbase)
 {
-	// unconquer land
-	if (m_didconquer)
-		egbase.unconquer_area
-			(Player_Area<Area<FCoords> >
-			 	(owner().player_number(),
-			 	 Area<FCoords>
-			 	 	(egbase.map().get_fcoords(get_position()), get_conquers())),
-			 m_defeating_player);
-
+	// Order matters. Building needed to unconquer, building
+	// cleanup will trigger new requests in garrison, garrison
+	// cleanup will destroy them
+	m_garrison->cleanup(egbase);
 	ProductionSite::cleanup(egbase);
+<<<<<<< TREE
 
 	// Note that removing workers during ProductionSite::cleanup can generate
 	// new requests; that's why we delete it at the end of this function.
@@ -538,6 +486,9 @@
 			// reason, hoping that all stationed soldiers would be present.
 		}
 	}
+=======
+	m_garrison->cleanup_requests(egbase);
+>>>>>>> MERGE-SOURCE
 }
 
 /*
@@ -554,60 +505,53 @@
 	// Maybe a new queueing system like MilitaryAct could be introduced.
 
 	ProductionSite::act(game, data);
-
-	const int32_t timeofgame = game.get_gametime();
-	if (m_normal_soldier_request && m_upgrade_soldier_request)
-	{
-		throw wexception("MilitarySite::act: Two soldier requests are ongoing -- should never happen!\n");
-	}
-
-	// I do not get a callback when stationed, non-present soldier returns --
-	// Therefore I must poll in some occasions. Let's do that rather infrequently,
-	// to keep the game lightweight.
-
-	//TODO: I would need two new callbacks, to get rid ot this polling.
-	if (timeofgame > m_next_swap_soldiers_time)
-		{
-			m_next_swap_soldiers_time = timeofgame + (m_soldier_upgrade_try ? 20000 : 100000);
-			update_soldier_request();
-		}
-
-	if (m_nexthealtime <= game.get_gametime()) {
-		uint32_t total_heal = descr().get_heal_per_second();
-		std::vector<Soldier *> soldiers = presentSoldiers();
-
-		for (uint32_t i = 0; i < soldiers.size(); ++i) {
-			Soldier & s = *soldiers[i];
-
-			// The healing algorithm is totally arbitrary
-			if (s.get_current_hitpoints() < s.get_max_hitpoints()) {
-				s.heal(total_heal);
-				break;
-			}
-		}
-
-		m_nexthealtime = game.get_gametime() + 1000;
-		schedule_act(game, 1000);
-	}
-}
-
-
-/**
- * The worker is about to be removed.
- *
- * After the removal of the worker, check whether we need to request
- * new soldiers.
- */
-void MilitarySite::remove_worker(Worker & w)
-{
-	ProductionSite::remove_worker(w);
-
-	if (upcast(Soldier, soldier, &w))
-		popSoldierJob(soldier, 0, 0);
-
-	update_soldier_request();
-}
-
+	m_garrison->act(game);
+	schedule_act(game, 1000);
+}
+
+/**
+===============
+Display number of soldiers.
+===============
+*/
+std::string MilitarySite::get_statistics_string()
+{
+	std::string str;
+	uint32_t present = m_garrison->presentSoldiers().size();
+	uint32_t total = m_garrison->stationedSoldiers().size();
+	uint32_t capacity = m_garrison->soldierCapacity();
+
+	if (present == total) {
+		str =
+			(boost::format
+				(ngettext(_("%u soldier"), _("%u soldiers"), total)) % total)
+				.str();
+	} else {
+		str =
+			(boost::format
+				(ngettext(_("%u(+%u) soldier"), _("%u(+%u) soldiers"), present))
+				% present % (total - present))
+				.str();
+	}
+
+	if (capacity > total) {
+		str += (boost::format(" (+%u)") %  (capacity - total)).str();
+	}
+
+	return str;
+}
+
+/**
+===============
+Change the economy for the wares queues.
+Note that the workers are dealt with in the PlayerImmovable code.
+===============
+*/
+void MilitarySite::set_economy(Economy * const e)
+{
+	ProductionSite::set_economy(e);
+	m_garrison->set_economy(e);
+}
 
 /**
  * Called by soldiers in the building.
@@ -615,41 +559,13 @@
 bool MilitarySite::get_building_work(Game & game, Worker & worker, bool)
 {
 	if (upcast(Soldier, soldier, &worker)) {
-		// Evict soldiers that have returned home if the capacity is too low
-		if (m_capacity < presentSoldiers().size()) {
-			worker.reset_tasks(game);
-			worker.start_task_leavebuilding(game, true);
-			return true;
-		}
-
-		bool stayhome;
-		uint8_t retreat;
-		if
-			(Map_Object * const enemy
-			 =
-			 popSoldierJob(soldier, &stayhome, &retreat))
-		{
-			if (upcast(Building, building, enemy)) {
-				soldier->start_task_attack
-					(game, *building, retreat);
-				return true;
-			} else if (upcast(Soldier, opponent, enemy)) {
-				if (!opponent->getBattle()) {
-					soldier->start_task_defense
-						(game, stayhome, retreat);
-					if (stayhome)
-						opponent->send_signal(game, "sleep");
-					return true;
-				}
-			} else
-				throw wexception("MilitarySite::get_building_work: bad SoldierJob");
-		}
+		return m_garrison->get_garrison_work(game, soldier);
 	}
-
 	return false;
 }
 
 
+<<<<<<< TREE
 /**
  * \return \c true if the soldier is currently present and idle in the building.
  */
@@ -885,7 +801,28 @@
 
 		// Now we destroy the old building before we place the new one.
 		set_defeating_player(enemy.owner().player_number());
+=======
+Garrison* MilitarySite::get_garrison() const
+{
+	return m_garrison.get();
+}
+
+Building* MilitarySite::get_building()
+{
+	return this;
+}
+
+void MilitarySite::garrison_occupied()
+{
+	start_animation(owner().egbase(), descr().get_animation("idle"));
+}
+
+void MilitarySite::garrison_lost(Game& game, Widelands::Player_Number defeating, bool captured)
+{
+	if (!captured) {
+>>>>>>> MERGE-SOURCE
 		schedule_destroy(game);
+<<<<<<< TREE
 
 		enemyplayer->force_building(coords, former_buildings);
 		BaseImmovable * const newimm = game.map()[coords].get_immovable();
@@ -907,17 +844,64 @@
 
 		return false;
 	}
+=======
+		return;
+	}
+	// The enemy conquers the building
+	// In fact we do not conquer it, but place a new building of same type at
+	// the old location.
+	Player            * enemyplayer = game.get_player(defeating);
+	const Tribe_Descr & enemytribe  = enemyplayer->tribe();
+
+	// Add suffix to all descr in former buildings in cases
+	// the new owner comes from another tribe
+	Building_Descr::FormerBuildings former_buildings;
+	BOOST_FOREACH(const Building_Descr * old_descr, m_old_buildings) {
+		std::string bldname = old_descr->name();
+		// Has this building already a suffix? == conquered building?
+		std::string::size_type const dot = bldname.rfind('.');
+		if (dot >= bldname.size()) {
+			// Add suffix, if the new owner uses another tribe than we.
+			if (enemytribe.name() != owner().tribe().name())
+				bldname += "." + owner().tribe().name();
+		} else if (enemytribe.name() == bldname.substr(dot + 1, bldname.size()))
+			bldname = bldname.substr(0, dot);
+		Building_Index bldi = enemytribe.safe_building_index(bldname.c_str());
+		const Building_Descr * former_descr = enemytribe.get_building_descr(bldi);
+		former_buildings.push_back(former_descr);
+	}
+
+	const Coords coords = get_position();
+	// Now we destroy the old building before we place the new one.
+	set_defeating_player(defeating);
+	schedule_destroy(game);
+
+	enemyplayer->force_building(coords, former_buildings);
+	BaseImmovable * const newimm = game.map()[coords].get_immovable();
+	upcast(GarrisonOwner, go, newimm);
+	go->reinit_after_conqueral(game);
+
+	// Of course we should inform the victorious player as well
+	upcast(Building, new_building, newimm);
+	std::string message =
+		(boost::format
+			(_("Your soldiers defeated the enemy at the %s."))
+			% new_building->descname())
+			.str();
+	new_building->send_message
+		(game, "site_defeated",
+			_("Enemy at site defeated!"),
+			message);
+>>>>>>> MERGE-SOURCE
 }
 
-/// Initialises the militarysite after it was "conquered" (the old was replaced)
-void MilitarySite::reinit_after_conqueration(Game & game)
+void MilitarySite::reinit_after_conqueral(Game& game)
 {
-	clear_requirements();
-	conquer_area(game);
-	update_soldier_request();
+	m_garrison->reinit_after_conqueral(game);
 	start_animation(game, descr().get_animation("idle"));
 }
 
+<<<<<<< TREE
 /// Calculates whether the military presence is still kept and \returns true if.
 bool MilitarySite::military_presence_kept(Game & game)
 {
@@ -1103,4 +1087,6 @@
 	m_next_swap_soldiers_time = 0;
 }
 
+=======
+>>>>>>> MERGE-SOURCE
 }
 
=== modified file 'src/logic/militarysite.h'
--- src/logic/militarysite.h	2013-07-26 20:19:36 +0000
+++ src/logic/militarysite.h	2013-08-10 10:53:03 +0000
@@ -20,10 +20,10 @@
 #ifndef MILITARYSITE_H
 #define MILITARYSITE_H
 
-#include "logic/attackable.h"
+#include "logic/garrison.h"
+#include "logic/garrisonhandler.h"
 #include "logic/productionsite.h"
 #include "logic/requirements.h"
-#include "logic/soldiercontrol.h"
 
 namespace Widelands {
 
@@ -53,121 +53,39 @@
 };
 
 class MilitarySite :
-	public ProductionSite, public SoldierControl, public Attackable
+	public ProductionSite, public GarrisonOwner
 {
 	friend struct Map_Buildingdata_Data_Packet;
 	MO_DESCR(MilitarySite_Descr);
 
 public:
-	// I assume elsewhere, that enum SoldierPreference fits to uint8_t.
-	enum SoldierPreference  : uint8_t {
-		kNoPreference,
-		kPrefersRookies,
-		kPrefersHeroes,
-	};
-
 	MilitarySite(const MilitarySite_Descr &);
 	virtual ~MilitarySite();
 
-	char const * type_name() const throw () {return "militarysite";}
-	virtual std::string get_statistics_string();
-
+	void load_finish(Editor_Game_Base &);
 	virtual void init(Editor_Game_Base &);
 	virtual void cleanup(Editor_Game_Base &);
 	virtual void act(Game &, uint32_t data);
-	virtual void remove_worker(Worker &);
+
+	char const * type_name() const throw () {return "militarysite";}
+	virtual std::string get_statistics_string();
 
 	virtual void set_economy(Economy *);
 	virtual bool get_building_work(Game &, Worker &, bool success);
 
-	// Begin implementation of SoldierControl
-	virtual std::vector<Soldier *> presentSoldiers() const;
-	virtual std::vector<Soldier *> stationedSoldiers() const;
-	virtual uint32_t minSoldierCapacity() const throw ();
-	virtual uint32_t maxSoldierCapacity() const throw ();
-	virtual uint32_t soldierCapacity() const;
-	virtual void setSoldierCapacity(uint32_t capacity);
-	virtual void dropSoldier(Soldier &);
-	virtual int incorporateSoldier(Editor_Game_Base & game, Soldier & s);
-	// End implementation of SoldierControl
-
-	// Begin implementation of Attackable
-	virtual Player & owner() const {return Building::owner();}
-	virtual bool canAttack();
-	virtual void aggressor(Soldier &);
-	virtual bool attack   (Soldier &);
-	// End implementation of Attackable
-
-	/**
-	 * Launch the given soldier on an attack towards the given
-	 * target building.
-	 */
-	void sendAttacker(Soldier &, Building &, uint8_t);
-
-	/// This methods are helper for use at configure this site.
-	void set_requirements  (const Requirements &);
-	void clear_requirements();
-	const Requirements & get_requirements () const {
-		return m_soldier_requirements;
-	}
-
-	void reinit_after_conqueration(Game &);
-
-	void update_soldier_request(bool i = false);
-
-	void set_soldier_preference(SoldierPreference);
-	SoldierPreference get_soldier_preference() const {
-			return m_soldier_preference;
-	}
+	// GarrisonOwner implementation
+	virtual Garrison* get_garrison() const;
+	virtual Building* get_building();
+	virtual void garrison_occupied();
+	virtual void garrison_lost(Game & game, Player_Number defeating, bool captured);
+	virtual void reinit_after_conqueral(Game& game);
 
 protected:
-	void conquer_area(Editor_Game_Base &);
-
 	virtual void create_options_window
 		(Interactive_GameBase &, UI::Window * & registry);
 
 private:
-	bool isPresent(Soldier &) const;
-	static void request_soldier_callback
-		(Game &, Request &, Ware_Index, Worker *, PlayerImmovable &);
-
-	Map_Object * popSoldierJob
-		(Soldier *, bool * stayhome = 0, uint8_t * retreat = 0);
-	bool haveSoldierJob(Soldier &);
-	bool military_presence_kept(Game &);
-	void informPlayer(Game &, bool discovered = false);
-	bool update_upgrade_requirements();
-	void update_normal_soldier_request();
-	void update_upgrade_soldier_request();
-	bool incorporateUpgradedSoldier(Editor_Game_Base & game, Soldier & s);
-	Soldier * find_least_suited_soldier();
-	bool drop_least_suited_soldier(bool new_has_arrived, Soldier * s);
-
-
-private:
-	Requirements m_soldier_requirements; // This is used to grab a bunch of soldiers: Anything goes
-	RequireAttribute m_soldier_upgrade_requirements; // This is used when exchanging soldiers.
-	std::unique_ptr<Request> m_normal_soldier_request;  // filling the site
-	std::unique_ptr<Request> m_upgrade_soldier_request; // seeking for better soldiers
-	bool m_didconquer;
-	uint32_t m_capacity;
-
-	/**
-	 * Next gametime where we should heal something.
-	 */
-	int32_t m_nexthealtime;
-
-	struct SoldierJob {
-		Soldier    * soldier;
-		Object_Ptr  enemy;
-		bool        stayhome;
-		uint8_t     retreat;
-	};
-	std::vector<SoldierJob> m_soldierjobs;
-	SoldierPreference m_soldier_preference;
-	int32_t m_next_swap_soldiers_time;
-	bool m_soldier_upgrade_try; // optimization -- if everybody is zero-level, do not downgrade
-	bool m_doing_upgrade_request;
+	std::unique_ptr<GarrisonHandler> m_garrison;
 };
 
 }
 
=== modified file 'src/logic/player.cc'
--- src/logic/player.cc	2013-08-08 20:02:13 +0000
+++ src/logic/player.cc	2013-08-10 10:53:03 +0000
@@ -38,7 +38,6 @@
 #include "logic/militarysite.h"
 #include "logic/playercommand.h"
 #include "logic/soldier.h"
-#include "logic/soldiercontrol.h"
 #include "logic/trainingsite.h"
 #include "logic/tribe.h"
 #include "logic/warehouse.h"
@@ -699,12 +698,14 @@
 
 void Player::military_site_set_soldier_preference(PlayerImmovable & imm, uint8_t m_soldier_preference)
 {
-	if (&imm.owner() == this)
-		if (upcast(MilitarySite, milsite, &imm))
-			milsite->set_soldier_preference(static_cast<MilitarySite::SoldierPreference>(m_soldier_preference));
+	if (&imm.owner() == this) {
+		if (upcast(GarrisonOwner, go, &imm)) {
+			Garrison* const garrison = go->get_garrison();
+			garrison->set_soldier_preference(static_cast<Garrison::SoldierPref>(m_soldier_preference));
+		}
+	}
 }
 
-
 /*
  * enhance this building, remove it, but give the constructionsite
  * an idea of enhancing
@@ -867,8 +868,9 @@
 		return;
 	if (soldier.get_worker_type() != Worker_Descr::SOLDIER)
 		return;
-	if (upcast(SoldierControl, ctrl, &imm))
-		ctrl->dropSoldier(soldier);
+	if (upcast(GarrisonOwner, go, &imm)) {
+		go->get_garrison()->dropSoldier(soldier);
+	}
 }
 
 /*
@@ -926,9 +928,10 @@
 
 	container_iterate_const(std::vector<BaseImmovable *>, flags, i) {
 		const Flag * attackerflag = static_cast<Flag *>(*i.current);
-		const MilitarySite * ms = static_cast<MilitarySite *>(attackerflag->get_building());
-		std::vector<Soldier *> const present = ms->presentSoldiers();
-		uint32_t const nr_staying = ms->minSoldierCapacity();
+		GarrisonOwner * go = dynamic_cast<GarrisonOwner *>(attackerflag->get_building());
+		Garrison * garrison = go->get_garrison();
+		std::vector<Soldier *> const present = garrison->presentSoldiers();
+		uint32_t const nr_staying = garrison->minSoldierCapacity();
 		uint32_t const nr_present = present.size();
 		if (nr_staying < nr_present) {
 			uint32_t const nr_taken =
@@ -964,8 +967,8 @@
 		log("enemyflagaction: count is 0\n");
 	else if (is_hostile(flag.owner()))
 		if (Building * const building = flag.get_building())
-			if (upcast(Attackable, attackable, building))
-				if (attackable->canAttack()) {
+			if (upcast(GarrisonOwner, go, building))
+				if (go->get_garrison()->canAttack()) {
 					std::vector<Soldier *> attackers;
 					findAttackSoldiers(flag, &attackers, count);
 					assert(attackers.size() <= count);
@@ -975,10 +978,10 @@
 					retreat = std::min
 						(retreat, tribe().get_military_data().get_max_retreat());
 
-					container_iterate_const(std::vector<Soldier *>, attackers, i)
-						ref_cast<MilitarySite, PlayerImmovable>
-							(*(*i.current)->get_location(egbase()))
-						.sendAttacker(**i.current, *building, retreat);
+					container_iterate_const(std::vector<Soldier *>, attackers, i) {
+						upcast(GarrisonOwner, igo, (*i.current)->get_location(egbase()));
+						igo->get_garrison()->sendAttacker(**i.current, *building, retreat);
+					}
 				}
 }
 
@@ -1177,13 +1180,13 @@
 
 	const uint32_t nrecos = get_nr_economies();
 	for (uint32_t i = 0; i < nrecos; ++i) {
-		const std::vector<Widelands::Warehouse *> & warehouses =
-			get_economy_by_number(i)->warehouses();
+		const std::vector<Widelands::Storage *> & storages =
+			get_economy_by_number(i)->storages();
 
 		for
-			(std::vector<Widelands::Warehouse *>::const_iterator it =
-			 warehouses.begin();
-			 it != warehouses.end();
+			(std::vector<Widelands::Storage *>::const_iterator it =
+			 storages.begin();
+			 it != storages.end();
 			 ++it)
 		{
 			const Widelands::WareList & wares = (*it)->get_wares();
 
=== modified file 'src/logic/player.h'
--- src/logic/player.h	2013-08-01 10:51:41 +0000
+++ src/logic/player.h	2013-08-10 10:53:03 +0000
@@ -638,7 +638,7 @@
 	std::vector< std::vector<uint32_t> > m_ware_consumptions;
 
 	/**
-	 * Statistics of wares stored inside of warehouses over the
+	 * Statistics of wares stored inside of storages over the
 	 * life of the game, indexed as
 	 * m_ware_stocks[ware_id][time_index]
 	 */
 
=== modified file 'src/logic/playercommand.cc'
--- src/logic/playercommand.cc	2013-08-07 12:32:36 +0000
+++ src/logic/playercommand.cc	2013-08-10 10:53:03 +0000
@@ -525,7 +525,7 @@
 PlayerCommand (0, des.Unsigned8())
 {
 	serial = des.Unsigned32();
-	preference = des.Unsigned8();
+	preference = static_cast<Garrison::SoldierPref>(des.Unsigned8());
 }
 
 void Cmd_MilitarySiteSetSoldierPreference::serialize (StreamWrite & ser)
@@ -533,7 +533,7 @@
 	ser.Unsigned8 (PLCMD_MILITARYSITESETSOLDIERPREFERENCE);
 	ser.Unsigned8 (sender());
 	ser.Unsigned32(serial);
-	ser.Unsigned8 (preference);
+	ser.Unsigned8 (static_cast<uint8_t>(preference));
 }
 
 void Cmd_MilitarySiteSetSoldierPreference::execute (Game & game)
@@ -554,7 +554,7 @@
 
 	// Now serial
 	const Map_Object & obj = *egbase.objects().get_object(serial);
-	fw.Unsigned8(preference);
+	fw.Unsigned8(static_cast<uint8_t>(preference));
 	fw.Unsigned32(mos.get_object_file_index(obj));
 }
 
@@ -566,7 +566,7 @@
 		const uint16_t packet_version = fr.Unsigned16();
 		if (packet_version == PLAYER_CMD_SOLDIERPREFERENCE_VERSION) {
 			PlayerCommand::Read(fr, egbase, mol);
-			preference = fr.Unsigned8();
+			preference = static_cast<Garrison::SoldierPref>(fr.Unsigned8());
 			const uint32_t building_serial = fr.Unsigned32();
 			try {
 				serial = mol.get<Map_Object>(building_serial).serial();
@@ -1724,8 +1724,8 @@
 {
 	if (upcast(Building, building, game.objects().get_object(serial)))
 		if (&building->owner() == game.get_player(sender()))
-			if (upcast(SoldierControl, ctrl, building))
-				ctrl->changeSoldierCapacity(val);
+			if (upcast(GarrisonOwner, go, building))
+				go->get_garrison()->changeSoldierCapacity(val);
 }
 
 void Cmd_ChangeSoldierCapacity::serialize (StreamWrite & ser)
@@ -2023,18 +2023,18 @@
 /*** struct Cmd_SetStockPolicy ***/
 Cmd_SetStockPolicy::Cmd_SetStockPolicy
 	(int32_t time, Player_Number p,
-	 Warehouse & wh, bool isworker, Ware_Index ware,
-	 Warehouse::StockPolicy policy)
+	 StorageOwner & storage_owner, bool isworker, Ware_Index ware,
+	 Storage::StockPolicy policy)
 : PlayerCommand(time, p)
 {
-	m_warehouse = wh.serial();
+	m_storage_owner = storage_owner.get_building()->serial();
 	m_isworker = isworker;
 	m_ware = ware;
 	m_policy = policy;
 }
 
 Cmd_SetStockPolicy::Cmd_SetStockPolicy()
-: PlayerCommand(), m_warehouse(0), m_isworker(false), m_policy()
+: PlayerCommand(), m_storage_owner(0), m_isworker(false), m_policy()
 {
 }
 
@@ -2047,20 +2047,20 @@
 {
 	// Sanitize data that could have come from the network
 	if (Player * plr = game.get_player(sender())) {
-		if (upcast(Warehouse, warehouse, game.objects().get_object(m_warehouse)))
+		if (upcast(StorageOwner, storage_owner, game.objects().get_object(m_storage_owner)))
 		{
-			if (&warehouse->owner() != plr) {
+			if (&storage_owner->get_building()->owner() != plr) {
 				log
-					("Cmd_SetStockPolicy: sender %u, but warehouse owner %u\n",
-					 sender(), warehouse->owner().player_number());
+					("Cmd_SetStockPolicy: sender %u, but storage owner %u\n",
+					 sender(), storage_owner->get_building()->owner().player_number());
 				return;
 			}
 
 			switch (m_policy) {
-			case Warehouse::SP_Normal:
-			case Warehouse::SP_Prefer:
-			case Warehouse::SP_DontStock:
-			case Warehouse::SP_Remove:
+			case Storage::StockPolicy::Normal:
+			case Storage::StockPolicy::Prefer:
+			case Storage::StockPolicy::DontStock:
+			case Storage::StockPolicy::Remove:
 				break;
 			default:
 				log
@@ -2069,7 +2069,7 @@
 				return;
 			}
 
-			const Tribe_Descr & tribe = warehouse->tribe();
+			const Tribe_Descr & tribe = storage_owner->get_building()->tribe();
 			if (m_isworker) {
 				if (!(m_ware < tribe.get_nrworkers())) {
 					log
@@ -2077,7 +2077,7 @@
 						 sender(), m_ware.value());
 					return;
 				}
-				warehouse->set_worker_policy(m_ware, m_policy);
+				storage_owner->get_storage()->set_worker_policy(m_ware, m_policy);
 			} else {
 				if (!(m_ware < tribe.get_nrwares())) {
 					log
@@ -2085,7 +2085,7 @@
 						 sender(), m_ware.value());
 					return;
 				}
-				warehouse->set_ware_policy(m_ware, m_policy);
+				storage_owner->get_storage()->set_ware_policy(m_ware, m_policy);
 			}
 		}
 	}
@@ -2094,20 +2094,20 @@
 Cmd_SetStockPolicy::Cmd_SetStockPolicy(StreamRead & des)
 	: PlayerCommand(0, des.Unsigned8())
 {
-	m_warehouse = des.Unsigned32();
+	m_storage_owner = des.Unsigned32();
 	m_isworker = des.Unsigned8();
 	m_ware = Ware_Index(des.Unsigned8());
-	m_policy = static_cast<Warehouse::StockPolicy>(des.Unsigned8());
+	m_policy = static_cast<Storage::StockPolicy>(des.Unsigned8());
 }
 
 void Cmd_SetStockPolicy::serialize(StreamWrite & ser)
 {
 	ser.Unsigned8(PLCMD_SETSTOCKPOLICY);
 	ser.Unsigned8(sender());
-	ser.Unsigned32(m_warehouse);
+	ser.Unsigned32(m_storage_owner);
 	ser.Unsigned8(m_isworker);
 	ser.Unsigned8(m_ware.value());
-	ser.Unsigned8(m_policy);
+	ser.Unsigned8(static_cast<uint8_t>(m_policy));
 }
 
 #define PLAYER_CMD_SETSTOCKPOLICY_VERSION 1
@@ -2119,10 +2119,10 @@
 		if (version != PLAYER_CMD_SETSTOCKPOLICY_VERSION)
 			throw game_data_error("unknown/unhandled version %u", version);
 		PlayerCommand::Read(fr, egbase, mol);
-		m_warehouse = fr.Unsigned32();
+		m_storage_owner = fr.Unsigned32();
 		m_isworker = fr.Unsigned8();
 		m_ware = Ware_Index(fr.Unsigned8());
-		m_policy = static_cast<Warehouse::StockPolicy>(fr.Unsigned8());
+		m_policy = static_cast<Storage::StockPolicy>(fr.Unsigned8());
 	} catch (const std::exception & e) {
 		throw game_data_error("Cmd_SetStockPolicy: %s", e.what());
 	}
@@ -2133,10 +2133,10 @@
 {
 	fw.Unsigned8(PLAYER_CMD_SETSTOCKPOLICY_VERSION);
 	PlayerCommand::Write(fw, egbase, mos);
-	fw.Unsigned32(m_warehouse);
+	fw.Unsigned32(m_storage_owner);
 	fw.Unsigned8(m_isworker);
 	fw.Unsigned8(m_ware.value());
-	fw.Unsigned8(m_policy);
+	fw.Unsigned8(static_cast<uint8_t>(m_policy));
 }
 
 }
 
=== modified file 'src/logic/playercommand.h'
--- src/logic/playercommand.h	2013-08-05 14:05:21 +0000
+++ src/logic/playercommand.h	2013-08-10 10:53:03 +0000
@@ -24,8 +24,8 @@
 #include "economy/flag.h"
 #include "logic/message_id.h"
 #include "logic/path.h"
+#include "logic/storage.h"
 #include "logic/trainingsite.h"
-#include "logic/warehouse.h"
 #include "logic/worker.h"
 
 namespace Widelands {
@@ -196,7 +196,8 @@
 
 struct Cmd_MilitarySiteSetSoldierPreference : public PlayerCommand {
 	Cmd_MilitarySiteSetSoldierPreference() : PlayerCommand(), serial(0) {} // For savegame loading
-	Cmd_MilitarySiteSetSoldierPreference (const int32_t t, const Player_Number p, Building & b, uint8_t prefs)
+	Cmd_MilitarySiteSetSoldierPreference
+		(const int32_t t, const Player_Number p, Building & b, Garrison::SoldierPref prefs)
 		: PlayerCommand(t, p), serial(b.serial()), preference(prefs)
 	{}
 
@@ -212,7 +213,7 @@
 
 private:
 	Serial serial;
-	uint8_t preference;
+	Garrison::SoldierPref preference;
 };
 struct Cmd_StartOrCancelExpedition : public PlayerCommand {
 	Cmd_StartOrCancelExpedition() : PlayerCommand() {} // For savegame loading
@@ -764,13 +765,13 @@
 };
 
 /**
- * Command to change the stock policy for a ware or worker in a warehouse.
+ * Command to change the stock policy for a ware or worker in a storage.
  */
 struct Cmd_SetStockPolicy : PlayerCommand {
 	Cmd_SetStockPolicy
 		(int32_t time, Player_Number p,
-		 Warehouse & wh, bool isworker, Ware_Index ware,
-		 Warehouse::StockPolicy policy);
+		 StorageOwner & storage_owner, bool isworker, Ware_Index ware,
+		 Storage::StockPolicy policy);
 
 	virtual uint8_t id() const;
 
@@ -786,10 +787,10 @@
 	void Read (FileRead  &, Editor_Game_Base &, Map_Map_Object_Loader &);
 
 private:
-	Serial m_warehouse;
+	Serial m_storage_owner;
 	bool m_isworker;
 	Ware_Index m_ware;
-	Warehouse::StockPolicy m_policy;
+	Storage::StockPolicy m_policy;
 };
 
 }
 
=== modified file 'src/logic/production_program.cc'
--- src/logic/production_program.cc	2013-08-08 19:55:12 +0000
+++ src/logic/production_program.cc	2013-08-10 10:53:03 +0000
@@ -32,12 +32,12 @@
 #include "logic/findnode.h"
 #include "logic/game.h"
 #include "logic/game_data_error.h"
+#include "logic/garrison.h"
 #include "logic/mapregion.h"
 #include "logic/message_queue.h"
 #include "logic/player.h"
 #include "logic/productionsite.h"
 #include "logic/soldier.h"
-#include "logic/soldiercontrol.h"
 #include "logic/trainingsite.h"
 #include "logic/tribe.h"
 #include "logic/worker_program.h"
@@ -1274,8 +1274,13 @@
 void ProductionProgram::ActCheck_Soldier::execute
 	(Game & game, ProductionSite & ps) const
 {
-	SoldierControl & ctrl = dynamic_cast<SoldierControl &>(ps);
-	const std::vector<Soldier *> soldiers = ctrl.presentSoldiers();
+	GarrisonOwner * go = dynamic_cast<GarrisonOwner *>(&ps);
+	if (!go) {
+		log("CGH no garrison owner for %s %u\n", ps.descr().descname().c_str(), ps.serial());
+		return;
+	}
+	Garrison* ga = go->get_garrison();
+	const std::vector<Soldier *> soldiers = ga->presentSoldiers();
 	const std::vector<Soldier *>::const_iterator soldiers_end = soldiers.end();
 
 	ps.molog("  Checking soldier (%u) level %d)\n", attribute, level);
@@ -1360,8 +1365,10 @@
 void ProductionProgram::ActTrain::execute
 	(Game & game, ProductionSite & ps) const
 {
-	SoldierControl & ctrl = dynamic_cast<SoldierControl &>(ps);
-	const std::vector<Soldier *> soldiers = ctrl.presentSoldiers();
+	GarrisonOwner * go = dynamic_cast<GarrisonOwner *>(&ps);
+	assert(go);
+	const Garrison* ga = go->get_garrison();
+	const std::vector<Soldier *> soldiers = ga->presentSoldiers();
 	const std::vector<Soldier *>::const_iterator soldiers_end =
 		soldiers.end();
 	std::vector<Soldier *>::const_iterator it = soldiers.begin();
 
=== modified file 'src/logic/productionsite.cc'
--- src/logic/productionsite.cc	2013-07-26 20:19:36 +0000
+++ src/logic/productionsite.cc	2013-08-10 10:53:03 +0000
@@ -113,7 +113,7 @@
 			} catch (const _wexception & e) {
 				throw wexception("%s=\"%s\": %s", v->get_name(), v->get_string(), e.what());
 			}
-	if (working_positions().empty() and not global_s.has_val("max_soldiers"))
+	if (working_positions().empty() and prof.get_section("garrison") == nullptr)
 		throw wexception("no working/soldier positions");
 
 	// Get programs
 
=== modified file 'src/logic/soldier.cc'
--- src/logic/soldier.cc	2013-08-07 03:51:32 +0000
+++ src/logic/soldier.cc	2013-08-10 10:53:03 +0000
@@ -28,7 +28,6 @@
 #include "graphic/graphic.h"
 #include "graphic/rendertarget.h"
 #include "helper.h"
-#include "logic/attackable.h"
 #include "logic/battle.h"
 #include "logic/building.h"
 #include "logic/checkstep.h"
@@ -38,11 +37,11 @@
 #include "logic/findnode.h"
 #include "logic/game.h"
 #include "logic/game_data_error.h"
+#include "logic/garrison.h"
 #include "logic/message_queue.h"
 #include "logic/militarysite.h"
 #include "logic/player.h"
 #include "logic/tribe.h"
-#include "logic/warehouse.h"
 #include "map_io/widelands_map_map_object_loader.h"
 #include "map_io/widelands_map_map_object_saver.h"
 #include "profile/profile.h"
@@ -764,7 +763,11 @@
 struct FindNodeOwned {
 	FindNodeOwned(Player_Number owner) : m_owner(owner)
 	{};
+<<<<<<< TREE
 	bool accept(const Map&, const FCoords& coords) const {
+=======
+	bool accept(const Map &, const FCoords & coords) const {
+>>>>>>> MERGE-SOURCE
 		return (coords.field->get_owned_by() == m_owner);
 	}
 private:
@@ -789,8 +792,6 @@
 void Soldier::start_task_attack
 	(Game & game, Building & building, uint8_t retreat)
 {
-	//dynamic_cast<const Attackable &>(building);
-
 	push_task(game, taskAttack);
 	State & state  = top_state();
 	state.objvar1  = &building;
@@ -960,13 +961,8 @@
 
 	// Count remaining defenders
 	if (enemy) {
-		if (upcast(MilitarySite, ms, enemy)) {
-			defenders = ms->presentSoldiers().size();
-		}
-		if (upcast(Warehouse, wh, enemy)) {
-			Requirements noreq;
-			defenders = wh->count_workers
-				(game, wh->tribe().worker_index("soldier"), noreq);
+		if (upcast(GarrisonOwner, garrison_owner, enemy)) {
+			defenders = garrison_owner->get_garrison()->presentSoldiers().size();
 		}
 		//  Any enemy soldier at baseflag count as defender.
 		std::vector<Bob *> soldiers;
@@ -996,6 +992,7 @@
 			BaseImmovable * const newimm = game.map()[state.coords].get_immovable();
 			upcast(MilitarySite, newsite, newimm);
 			if (newsite and (&newsite->owner() == &owner())) {
+<<<<<<< TREE
 				if (upcast(SoldierControl, ctrl, newsite)) {
 					state.objvar1 = 0;
 					// We may also have our location destroyed in between
@@ -1011,6 +1008,20 @@
 						newsite->update_soldier_request();
 						return schedule_act(game, 10);
 					}
+=======
+				state.objvar1 = 0;
+				if
+					(newsite->get_garrison()->stationedSoldiers().size()
+						< newsite->get_garrison()->soldierCapacity() and
+					location->base_flag().get_position()
+					!=
+					newsite ->base_flag().get_position())
+				{
+					molog("[attack] enemy belongs to us now, move in\n");
+					pop_task(game);
+					set_location(newsite);
+					return schedule_act(game, 10);
+>>>>>>> MERGE-SOURCE
 				}
 			}
 		}
@@ -1040,12 +1051,12 @@
 		}
 	}
 
-	upcast(Attackable, attackable, enemy);
-	assert(attackable);
+	upcast(GarrisonOwner, garrison_o, enemy);
+	assert(garrison_o);
 
 	molog("[attack] attacking target building\n");
 	//  give the enemy soldier some time to act
-	schedule_act(game, attackable->attack(*this) ? 1000 : 10);
+	schedule_act(game, garrison_o->get_garrison()->attack(*this) ? 1000 : 10);
 }
 
 void Soldier::attack_pop(Game & game, State &)
@@ -1789,13 +1800,17 @@
 			 CheckStepWalkOn(descr().movecaps(), false),
 			 FindImmovableAttackable());
 
-		container_iterate_const(std::vector<BaseImmovable *>, attackables, i)
+		container_iterate_const(std::vector<BaseImmovable *>, attackables, i) {
+			const BaseImmovable* base_imm = *i.current;
 			if
-				(ref_cast<PlayerImmovable const, BaseImmovable const>(**i.current)
-				 .get_owner()->player_number()
-				 ==
-				 land_owner)
-				dynamic_cast<Attackable &>(**i.current).aggressor(*this);
+				(ref_cast<PlayerImmovable const, BaseImmovable const>(*base_imm)
+				 .get_owner()->player_number() == land_owner)
+			{
+				if (upcast(const GarrisonOwner, go, base_imm)) {
+					go->get_garrison()->aggressor(*this);
+				}
+			}
+		}
 	}
 }
 
 
=== removed file 'src/logic/soldiercontrol.h'
--- src/logic/soldiercontrol.h	2012-02-15 21:25:34 +0000
+++ src/logic/soldiercontrol.h	1970-01-01 00:00:00 +0000
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2008 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 SOLDIERCONTROL_H
-#define SOLDIERCONTROL_H
-
-#include <vector>
-
-namespace Widelands {
-
-class Soldier;
-
-/**
- * This interface is implemented by buildings that explicitly house soldiers.
- *
- * It is used to implement queries for building UI and to implement commands
- * that change the soldiers stationed in a building.
- *
- * Soldiers are \em stationed in a building if that building is their
- * \ref Worker::location. Stationed soldiers are \em present in a building
- * if their current position is inside the building. So for a TrainingSite,
- * the two concepts are equal. However, they're different for a MilitarySite,
- * where soldiers can be outside in combat.
- */
-struct SoldierControl {
-	/**
-	 * \return a list of soldiers that are currently present in the building.
-	 */
-	virtual std::vector<Soldier *> presentSoldiers() const = 0;
-
-	/**
-	 * \return a list of soldiers that are currently stationed in the building.
-	 */
-	virtual std::vector<Soldier *> stationedSoldiers() const = 0;
-
-	/**
-	 * \return the minimum number of soldiers that this building can be
-	 * configured to hold.
-	 */
-	virtual uint32_t minSoldierCapacity() const = 0;
-
-	/**
-	 * \return the maximum number of soldiers that this building can be
-	 * configured to hold.
-	 */
-	virtual uint32_t maxSoldierCapacity() const = 0;
-
-	/**
-	 * \return the number of soldiers this building is configured to hold
-	 * right now.
-	 */
-	virtual uint32_t soldierCapacity() const = 0;
-
-	/**
-	 * Sets the capacity for soldiers of this building.
-	 *
-	 * New soldiers will be requested and old soldiers will be evicted
-	 * as necessary.
-	 */
-	virtual void setSoldierCapacity(uint32_t capacity) = 0;
-
-	void changeSoldierCapacity(int32_t const difference) {
-		uint32_t const old_capacity = soldierCapacity();
-		uint32_t const new_capacity =
-			std::min
-				(static_cast<uint32_t>
-				 	(std::max
-				 	 	(static_cast<int32_t>(old_capacity) + difference,
-				 	 	 static_cast<int32_t>(minSoldierCapacity()))),
-				 maxSoldierCapacity());
-		if (old_capacity != new_capacity)
-			setSoldierCapacity(new_capacity);
-	}
-
-	/**
-	 * Evict the given soldier from the building immediately,
-	 * without changing the building's capacity.
-	 *
-	 * \note This has no effect if the soldier is currently involved in a battle
-	 * or otherwise blocked from leaving the building.
-	 */
-	virtual void dropSoldier(Soldier &) = 0;
-
-	/**
-	 * Add a new soldier into this site. Returns -1 if there is no space
-	 * for him, 0 on success
-	 */
-	virtual int incorporateSoldier(Editor_Game_Base &, Soldier &) = 0;
-
-	/**
-	 * Remove a soldier from the internal list. Most SoldierControls will be
-	 * informed by the soldier when it is removed, but WareHouses for example
-	 * will not.
-	 */
-	virtual int outcorporateSoldier(Editor_Game_Base &, Soldier &) {return 0;}
-
-protected:
-	virtual ~SoldierControl() {}
-};
-
-}
-
-#endif // SOLDIERCONTROL_H
 
=== added file 'src/logic/storage.h'
--- src/logic/storage.h	1970-01-01 00:00:00 +0000
+++ src/logic/storage.h	2013-08-10 10:53:03 +0000
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2002-2004, 2006-2011 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 STORAGE_H
+#define STORAGE_H
+
+#include <vector>
+
+#include "logic/requirements.h"
+#include "logic/wareworker.h"
+#include "logic/widelands.h"
+
+namespace Widelands {
+
+class Building;
+class Worker;
+class Editor_Game_Base;
+class Game;
+class WareInstance;
+class WareList;
+class Player;
+
+/**
+ *  A storage represents wares and workers stocks. It is owned by StrorageOwner buildings.
+ * This interface contains various method used to deal with wares requests, prioriies
+ * and disponibility.
+ */
+class Storage {
+public:
+	/**
+	 * Each ware and worker type has an associated per-storage
+	 * 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 : uint8_t {
+		/**
+		 * The default policy allows stocking wares without any special priority.
+		 */
+		Normal = 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.
+		 */
+		Prefer = 1,
+
+		/**
+		 * If a ware has this stock policy, no new items of this ware will enter
+		 * the warehouse.
+		 */
+		DontStock = 2,
+
+		/**
+		 * Like \ref SP_DontStock, but in addition, existing stock of this ware
+		 * will be transported out of the warehouse over time.
+		 */
+		Remove = 3,
+	};
+
+	/**
+	 * \return the player that own this storage
+	 */
+	virtual Player & owner() const = 0;
+	/**
+	 * \return the wares present in this storage
+	 */
+	virtual const WareList & get_wares() const = 0;
+	/**
+	 * \return the workers present in this storage
+	 */
+	virtual const WareList & get_workers() const = 0;
+	/**
+	 * Increase the stock of the specified ware type
+	 */
+	virtual void insert_wares  (Ware_Index, uint32_t count) = 0;
+	/**
+	 * Decrease the stock of the specified ware type
+	 */
+	virtual void remove_wares  (Ware_Index, uint32_t count) = 0;
+	/**
+	 * Increase the stock of the specified worker type
+	 */
+	virtual void insert_workers(Ware_Index, uint32_t count) = 0;
+	/**
+	 * Decrease the stock of the specified worker type
+	 */
+	virtual void remove_workers(Ware_Index, uint32_t count) = 0;
+	/**
+	 * Get a specified ware from the storage.
+	 * \return the wareinstance
+	 */
+	virtual WareInstance & launch_ware(Game &, Ware_Index) = 0;
+	/**
+	 * Launch a ware already instanciated
+	 */
+	virtual void do_launch_ware(Game &, WareInstance&) = 0;
+	/**
+	 * Adds the specified ware to the storage. The ware might
+	 * be removed from the game following this call.
+	 */
+	virtual void incorporate_ware(Editor_Game_Base &, WareInstance &) = 0;
+	/**
+	 * Get the specified worker from the storage.
+	 * \return the worker
+	 */
+	virtual Worker & launch_worker(Game &, Ware_Index, const Requirements & = Requirements()) = 0;
+	/**
+	 * Adds the specified worker to the storage. The worker might
+	 * be removed from the game following this call.
+	 */
+	virtual void incorporate_worker(Editor_Game_Base &, Worker &) = 0;
+	/**
+	 * \return the storage stock policy for the specified ware
+	 */
+	virtual StockPolicy get_ware_policy(Ware_Index ware) const = 0;
+	/**
+	 * \return the storage stock policy for the specified worker
+	 */
+	virtual StockPolicy get_worker_policy(Ware_Index ware) const = 0;
+	/**
+	 * \return the sotrage stock policy for the specified ware or worker
+	 */
+	virtual StockPolicy get_stock_policy(WareWorker waretype, Ware_Index wareindex) const = 0;
+	/**
+	 * Set the storage stock policy for the specified ware
+	 */
+	virtual void set_ware_policy(Ware_Index ware, StockPolicy policy) = 0;
+	/**
+	 * Set the storage stock policy for the specified worker
+	 */
+	virtual void set_worker_policy(Ware_Index ware, StockPolicy policy) = 0;
+	/**
+	 * Return true if the storage has all requirement in stock to create
+	 * the specified worker
+	 */
+	virtual bool can_create_worker(Game& game, Ware_Index ware_index) = 0;
+	/**
+	 * Create a worker.
+	 */
+	virtual void create_worker(Game& game, Ware_Index worker_idx) = 0;
+	/**
+	 * Return the amount of planned worker of the given worker idx
+	 */
+	virtual uint32_t get_planned_workers(Game &, Ware_Index index) const = 0;
+	/**
+	 * Plan to create the specified workers
+	 */
+	virtual void plan_workers(Game &, Ware_Index index, uint32_t amount) = 0;
+	/**
+	 * Calculate the supply of wares available to this warehouse in each of the
+	 * buildcost items for the given worker.
+	 *
+	 * This is the current stock plus any incoming transfers.
+	 */
+	virtual std::vector<uint32_t> calc_available_for_worker(Game &, Ware_Index index) const = 0;
+};
+
+/**
+ * A Storage owner holds a sorage instance.
+ */
+class StorageOwner {
+public:
+	/**
+	 * Return the storage instance
+	 */
+	virtual Storage* get_storage() const = 0;
+	/**
+	 * Return the building owning the storage
+	 */
+	virtual Building* get_building() = 0;
+};
+
+}
+
+#endif
 
=== added file 'src/logic/storagehandler.cc'
--- src/logic/storagehandler.cc	1970-01-01 00:00:00 +0000
+++ src/logic/storagehandler.cc	2013-08-10 10:53:03 +0000
@@ -0,0 +1,1127 @@
+/*
+ * Copyright (C) 2002-2004, 2006-2011 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/storagehandler.h"
+
+#include <utility>
+
+#include <boost/foreach.hpp>
+
+#include "economy/economy.h"
+#include "economy/flag.h"
+#include "helper.h"
+#include "logic/player.h"
+#include "logic/soldier.h"
+#include "upcast.h"
+
+namespace Widelands {
+
+//************************************************************
+// CLASS Storage Handler
+//************************************************************
+
+StorageHandler::StorageHandler(Building& building)
+:  m_building(building),
+	m_supply(new StorageSupply(this))
+{
+}
+
+StorageHandler::~StorageHandler()
+{
+}
+
+
+void StorageHandler::init(Editor_Game_Base&)
+{
+	Ware_Index const nr_wares   = owner().tribe().get_nrwares  ();
+	Ware_Index const nr_workers = owner().tribe().get_nrworkers();
+	m_supply->set_nrwares  (nr_wares);
+	m_supply->set_nrworkers(nr_workers);
+	m_ware_policy.resize(nr_wares.value(), Storage::StockPolicy::Normal);
+	m_worker_policy.resize(nr_workers.value(), Storage::StockPolicy::Normal);
+
+	// Init autospawn
+	const std::vector <Widelands::Ware_Index> worker_types_without_cost =
+		owner().tribe().worker_types_without_cost();
+	BOOST_FOREACH(Ware_Index idx, worker_types_without_cost) {
+		const Worker_Descr & worker_descr = *owner().tribe().get_worker_descr(idx);
+		if (not worker_descr.is_buildable()) {
+			continue;
+		}
+		if (!owner().is_worker_type_allowed(idx)) {
+			continue;
+		}
+		if (worker_descr.buildcost().empty()) {
+			//  Workers of this type can be spawned in warehouses. Start it.
+			add_worker_spawn(idx);
+		}
+	}
+}
+
+void StorageHandler::load_finish(Editor_Game_Base&)
+{
+	// Ensure consistency of PlannedWorker requests
+	uint32_t pwidx = 0;
+	while (pwidx < m_planned_workers.size()) {
+		if (!load_finish_planned_workers(m_planned_workers[pwidx])) {
+			m_planned_workers[pwidx].cleanup();
+			m_planned_workers.erase(m_planned_workers.begin() + pwidx);
+		} else {
+			pwidx++;
+		}
+	}
+	// Verify autospawning for free workers
+	const std::vector <Widelands::Ware_Index> worker_types_without_cost =
+		owner().tribe().worker_types_without_cost();
+	BOOST_FOREACH(Ware_Index idx, worker_types_without_cost) {
+		if (!owner().is_worker_type_allowed(idx)) {
+			continue;
+		}
+		if (is_worker_spawn_set(idx)) {
+			continue;
+		}
+		add_worker_spawn(idx);
+		log
+			("WARNING: player %u is allowed to create worker type %s but his "
+				"%s %u at (%i, %i) does not have spawning set for that "
+				"worker type; setting it to default values\n",
+				owner().player_number(),
+				owner().tribe().get_worker_descr(idx)->descname().c_str(),
+				m_building.descname().c_str(), m_building.serial(),
+			   m_building.get_position().x, m_building.get_position().y);
+	}
+}
+
+
+void StorageHandler::cleanup(Editor_Game_Base&)
+{
+	while (!m_planned_workers.empty()) {
+		m_planned_workers.back().cleanup();
+		m_planned_workers.pop_back();
+	}
+}
+
+//TODO return a value so the owner can schedule_act
+uint32_t StorageHandler::act(Game& game)
+{
+	uint32_t gametime = static_cast<uint32_t>(game.get_gametime());
+	uint32_t spawn_act = update_spawns(game, gametime);
+	uint32_t removal_act = update_removals(game, gametime);
+	// Update planned workers; this is to update the request amounts and
+	// check because whether we suddenly can produce a requested worker. This
+	// is mostly previously available wares may become unavailable due to
+	// secondary requests.
+	update_all_planned_workers(game);
+	// Act in 5 sec, or before if timers will run down
+	uint32_t min_act = 5000;
+	if (spawn_act > 0 && spawn_act < min_act) {
+		min_act = spawn_act;
+	}
+	if (removal_act > 0 && removal_act < min_act) {
+		min_act = removal_act;
+	}
+	return min_act;
+}
+
+void StorageHandler::set_economy(Economy* economy)
+{
+	Economy * const old = m_building.get_economy();
+
+	if (old == economy) {
+		return;
+	}
+
+	if (old) {
+		old->remove_storage(*this);
+	}
+
+	m_supply->set_economy(economy);
+
+	container_iterate_const(std::vector<PlannedWorkers>, m_planned_workers, pw_it) {
+		container_iterate_const(std::vector<Request *>, pw_it.current->requests, req_it) {
+				(*req_it.current)->set_economy(economy);
+			}
+	}
+
+	if (economy) {
+		economy->add_storage(*this);
+	}
+}
+
+uint32_t StorageHandler::count_workers(Game& game, Ware_Index idx, const Requirements& req)
+{
+	uint32_t stock = m_supply->stock_workers(idx);
+	if (stock <= 0) {
+		return stock;
+	}
+	uint32_t matching = 0;
+	// Get list of those for which we stored the attributes
+	// This is similar logic than in launch_worker
+	std::vector<const StockedWorkerAtr*> workers_with_atr;
+	BOOST_FOREACH(StockedWorkerAtr& atr, m_stocked_workers_atr) {
+		if (atr.index == idx) {
+			workers_with_atr.push_back(&atr);
+		}
+	}
+	// First check those without atr
+	Worker* w;
+	bool checkpass = false;
+	const Worker_Descr & workerdescr = *owner().tribe().get_worker_descr(idx);
+	if (stock > workers_with_atr.size()) {
+		w = &workerdescr.create(game, owner(), &m_building, m_building.get_position());
+		checkpass = req.check(*w);
+		if (checkpass) {
+			matching += stock - workers_with_atr.size();
+		}
+		w->remove(game);
+	}
+	// Check with our atr
+	// TODO CGH use smarter way of storing atr, maybe with map
+	BOOST_FOREACH(const StockedWorkerAtr* atr, workers_with_atr) {
+		w = create_with_atr(game, *atr);
+		checkpass = req.check(*w);
+		if (checkpass) {
+			matching++;
+		}
+		w->remove(game);
+	}
+	return matching;
+}
+
+
+void StorageHandler::launch_all_workers(Game & game, bool exp_only, const WareList& excluded)
+{
+	if (!exp_only) {
+		for (Ware_Index id = Ware_Index::First(); id < m_supply->get_workers().get_nrwareids(); ++id) {
+			if (excluded.stock(id)) {
+				continue;
+			}
+			const uint32_t stock = m_supply->get_workers().stock(id);
+			if (stock > 0) {
+				for (uint32_t i = 0; i < stock; ++i) {
+					launch_worker(game, id).start_task_leavebuilding(game, true);
+				}
+			}
+		}
+		return;
+	}
+	BOOST_FOREACH(StockedWorkerAtr atr, m_stocked_workers_atr) {
+		if (excluded.stock(atr.index)) {
+			continue;
+		}
+		if (m_supply->get_workers().stock(atr.index) <= 0) {
+			continue;
+		}
+		Worker* w = create_with_atr(game, atr);
+		w->start_task_leavebuilding(game, true);
+		m_supply->remove_workers(atr.index, 1);
+	}
+}
+
+void StorageHandler::add_ware_spawn
+	(const Ware_Index idx, uint32_t interval, uint32_t stock_max, uint32_t counter, bool dont_exceed)
+{
+	if (m_spawn_wares.count(idx)) {
+		remove_ware_spawn(idx);
+	}
+	if (dont_exceed) {
+		std::vector<uint32_t> values = {interval, interval, stock_max};
+		m_spawn_wares.insert(std::make_pair(idx, values));
+	} else {
+		std::vector<uint32_t> values = {interval, interval, stock_max, counter};
+		m_spawn_wares.insert(std::make_pair(idx, values));
+	}
+}
+
+void StorageHandler::remove_ware_spawn(const Ware_Index idx)
+{
+	m_spawn_wares.erase(idx);
+}
+bool StorageHandler::is_ware_spawn_set(Ware_Index idx)
+{
+	return m_spawn_wares.count(idx);
+}
+
+
+void StorageHandler::add_worker_spawn
+	(const Ware_Index idx, uint32_t interval, uint32_t stock_max, uint32_t counter, bool dont_exceed)
+{
+	if (m_spawn_workers.count(idx)) {
+		remove_worker_spawn(idx);
+	}
+	if (dont_exceed) {
+		std::vector<uint32_t> values = {interval, interval, stock_max};
+		m_spawn_workers.insert(std::make_pair(idx, values));
+	} else {
+		std::vector<uint32_t> values = {interval, interval, stock_max, counter};
+		m_spawn_workers.insert(std::make_pair(idx, values));
+	}
+}
+
+void StorageHandler::remove_worker_spawn(const Ware_Index idx)
+{
+	m_spawn_workers.erase(idx);
+}
+bool StorageHandler::is_worker_spawn_set(Ware_Index idx)
+{
+	return m_spawn_workers.count(idx);
+}
+
+//
+//
+//  Storage implementation
+//
+//
+
+Player& StorageHandler::owner() const
+{
+	return m_building.owner();
+}
+
+const WareList& StorageHandler::get_wares() const
+{
+	return m_supply->get_wares();
+}
+
+const WareList& StorageHandler::get_workers() const
+{
+	return m_supply->get_workers();
+}
+
+void StorageHandler::insert_wares(Ware_Index idx, uint32_t count)
+{
+	m_supply->add_wares(idx, count);
+}
+
+void StorageHandler::remove_wares(Ware_Index idx, uint32_t count)
+{
+	m_supply->remove_wares(idx, count);
+}
+
+void StorageHandler::insert_workers(Ware_Index idx, uint32_t count)
+{
+	m_supply->add_workers(idx, count);
+}
+
+void StorageHandler::remove_workers(Ware_Index idx, uint32_t count)
+{
+	m_supply->remove_workers(idx, count);
+}
+
+WareInstance& StorageHandler::launch_ware(Game& game, Ware_Index idx)
+{
+	WareInstance & item = *new WareInstance(idx, owner().tribe().get_ware_descr(idx));
+	item.init(game);
+	do_launch_ware(game, item);
+
+	m_supply->remove_wares(idx, 1);
+
+	return item;
+}
+
+
+void StorageHandler::do_launch_ware(Game& game, WareInstance& ware_inst)
+{
+	// Create a carrier
+	Ware_Index const carrierid = owner().tribe().worker_index("carrier");
+	const Worker_Descr & workerdescr = *owner().tribe().get_worker_descr(carrierid);
+
+	Worker & worker = workerdescr.create(game, owner(), &m_building, m_building.get_position());
+
+	// Yup, this is cheating.
+	if (m_supply->stock_workers(carrierid))
+		m_supply->remove_workers(carrierid, 1);
+
+	// Setup the carrier
+	worker.start_task_dropoff(game, ware_inst);
+}
+
+
+void StorageHandler::incorporate_ware(Editor_Game_Base& egbase, WareInstance& item)
+{
+	m_supply->add_wares(item.descr_index(), 1);
+	return item.destroy(egbase);
+}
+
+Worker& StorageHandler::launch_worker(Game& game, Ware_Index idx, const Requirements& req)
+{
+	do {
+		uint32_t stock = m_supply->stock_workers(idx);
+		if (stock > 0) {
+			// Get list of those for which we stored the attributes, as pointers to actual objects
+			// TODO smarter storage for atrs
+			std::vector<const StockedWorkerAtr*> workers_with_atr;
+			for
+				(std::vector<StockedWorkerAtr>::iterator it = m_stocked_workers_atr.begin();
+					it != m_stocked_workers_atr.end(); ++it)
+			{
+				if (it->index == idx) {
+					workers_with_atr.push_back(&(*it));
+				}
+			}
+			// First check if one without atr is enough
+			Worker* w;
+			if (stock > workers_with_atr.size()) {
+				const Worker_Descr & workerdescr = *owner().tribe().get_worker_descr(idx);
+				w = &workerdescr.create(game, owner(), &m_building, m_building.get_position());
+				if (req.check(*w)) {
+					m_supply->remove_workers(idx, 1);
+					return *w;
+				}
+			}
+			// Check with our atr
+			BOOST_FOREACH(const StockedWorkerAtr* atr, workers_with_atr) {
+				w = create_with_atr(game, *atr);
+				if (req.check(*w)) {
+					// We need to find back our atr in original vector to erase it
+					bool removed = false;
+					for
+						(std::vector<StockedWorkerAtr>::iterator it = m_stocked_workers_atr.begin();
+						 it != m_stocked_workers_atr.end(); ++it)
+					{
+						if (&(*it) == atr) {
+							m_stocked_workers_atr.erase(it);
+							removed = true;
+							break;
+						}
+					}
+					assert(removed);
+					m_supply->remove_workers(idx, 1);
+					return *w;
+				}
+			}
+		}
+		// Check if we got the tools to create a new one
+		if (can_create_worker(game, idx)) {
+			// don't want to use an upgraded worker, so create new one.
+			create_worker(game, idx);
+		} else {
+			idx = owner().tribe().get_worker_descr(idx)->becomes();
+		}
+	} while (idx != Ware_Index::Null());
+
+	throw wexception
+		("StorageHandler::launch_worker: worker does not actually exist");
+}
+
+void StorageHandler::incorporate_worker(Editor_Game_Base& egbase, Worker& w)
+{
+	assert(w.get_owner() == &owner());
+	// Rescue carried ware
+	if (WareInstance * const item = w.fetch_carried_item(egbase)) {
+		incorporate_ware(egbase, *item);
+	}
+	// Add to supply
+	Ware_Index worker_index = owner().tribe().worker_index(w.name().c_str());
+	m_supply->add_workers(worker_index, 1);
+
+	// Store the attributes.
+	// FIXME CGH handle soldiers : hp & healing
+	StockedWorkerAtr* atr = store_worker_atr(w);
+	if (atr != nullptr) {
+		m_stocked_workers_atr.push_back(*atr);
+	}
+	// Destroy the instance
+	w.remove(egbase);
+}
+
+Storage::StockPolicy StorageHandler::get_ware_policy(Ware_Index ware) const
+{
+	assert(ware.value() < m_ware_policy.size());
+	return m_ware_policy[ware.value()];
+}
+
+Storage::StockPolicy StorageHandler::get_worker_policy(Ware_Index ware) const
+{
+	assert(ware.value() < m_worker_policy.size());
+	return m_worker_policy[ware.value()];
+}
+
+Storage::StockPolicy StorageHandler::get_stock_policy(WareWorker waretype, Ware_Index wareindex) const
+{
+	if (waretype == wwWORKER)
+		return get_worker_policy(wareindex);
+	else
+		return get_ware_policy(wareindex);
+}
+
+void StorageHandler::set_ware_policy(Ware_Index ware, Storage::StockPolicy policy)
+{
+	assert(ware.value() < m_ware_policy.size());
+	m_ware_policy[ware.value()] = policy;
+}
+
+void StorageHandler::set_worker_policy(Ware_Index ware, Storage::StockPolicy policy)
+{
+	assert(ware.value() < m_worker_policy.size());
+	m_worker_policy[ware.value()] = policy;
+}
+
+bool StorageHandler::can_create_worker(Game&, Ware_Index worker_idx)
+{
+	if (not (worker_idx < m_supply->get_workers().get_nrwareids())) {
+		throw wexception
+			("worker type %d does not exists (max is %d)",
+			 worker_idx.value(), m_supply->get_workers().get_nrwareids().value());
+	}
+
+	const Worker_Descr & w_desc = *owner().tribe().get_worker_descr(worker_idx);
+	assert(&w_desc);
+	if (not w_desc.is_buildable()) {
+		return false;
+	}
+
+	//  see if we have the resources
+	const Worker_Descr::Buildcost & buildcost = w_desc.buildcost();
+	container_iterate_const(Worker_Descr::Buildcost, buildcost, it) {
+		const std::string & input_name = it.current->first;
+		if (Ware_Index id_w = owner().tribe().ware_index(input_name)) {
+			if (m_supply->stock_wares  (id_w) < it.current->second)
+				return false;
+		} else if ((id_w = owner().tribe().worker_index(input_name))) {
+			if (m_supply->stock_workers(id_w) < it.current->second)
+				return false;
+		} else
+			throw wexception
+				("worker type %s needs \"%s\" to be built but that is neither "
+				 "a ware type nor a worker type defined in the tribe %s",
+				 w_desc.descname().c_str(), input_name.c_str(),
+				 owner().tribe().name().c_str());
+	}
+	return true;
+}
+
+void StorageHandler::create_worker(Game& game, Ware_Index worker_idx)
+{
+	assert(can_create_worker (game, worker_idx));
+
+	const Worker_Descr & w_desc = *owner().tribe().get_worker_descr(worker_idx);
+	const Worker_Descr::Buildcost & buildcost = w_desc.buildcost();
+	container_iterate_const(Worker_Descr::Buildcost, buildcost, i) {
+		const std::string & input = i.current->first;
+		if (Ware_Index const id_ware = owner().tribe().ware_index(input)) {