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

[TiborB]

This is extension of player class to keep some AI data. Not all, only handfull of them. So the savegame compatibility is broken.

This contains also redesign of placing of new buidings - both production and militarysites. I tried to simplify the code and improve performance.

I also added a "time aspect" - this means the score of a building reflects also how long the building has been needed.

There are two bugs attached, these issue should be fixed / significantly improved.

The change is really big, and I spent quite a lot of time on tweaking this. I know it will be near to imposible for anyone to properly review this and understand the code. But you can still test it in game :)

[TiborB (tiborb95)]

Please hold on, I will do some changes and resubmit...

[TiborB (tiborb95)]

should be again ready for review

review: Needs Resubmitting

[GunChleoc (gunchleoc)]

I have added 2 replays to https://bugs.launchpad.net/widelands/+bug/1499678 - seems like this still needs some tweaking.

[TiborB (tiborb95)]

I will look at replays, of course.

But do you want to say that AI for atlanteans is systematically weaker then for other tribes? There is only one AI, but there are some aspects that can make difference, of course. I have never tried to compare performance per tribe. But I will investigate...

[TiborB (tiborb95)]

But you replays are not good, both are too short and one even fails to load altogether

[GunChleoc (gunchleoc)]

I didn't know that there was a basic binary file to add in addition to the dir, which I have now accidentally deleted. So, I'll have to recreate them. I player Long, Long Way with the first 3 AIs set to Atlanteans and the rest to Barbarians and Empire.

[GunChleoc (gunchleoc)]

I can't say anything about how good the heuristics are, but I have added some code style comments / ideas.

[TiborB (tiborb95)]

Thanks for review, I will incorporate comments (most of them at least :)). See also my comments to your comments in the diff.

[GunChleoc (gunchleoc)]

Added comments to your comments :)

[TiborB (tiborb95)]

my turn now, see my comments to your comments...

[GunChleoc (gunchleoc)]

Dito :)

I just noticed that you didn't increase the version number for the savegame packet where you made the changes. This is needed so that Widelands will show an error message instead of crashing when a user tries to load an older game.

[TiborB (tiborb95)]

@GunChleoc - I incorporated you comments (most of them). Also see one comment in the diff.

[TiborB (tiborb95)]

Oh, I forget about that packet - I will look at it...

[TiborB (tiborb95)]

packet increased, see question in diff.

[GunChleoc (gunchleoc)]

Increase it to 17 please.

[TiborB (tiborb95)]

done, trunk merged...

just another issue, when I tried to open some random older savegame - the game crashed with "pure virtual method called" - perhaps problem with conf files... Is not there a better way how to identify incompatible savegame?

[TiborB (tiborb95)]

Oh, this is bt I got:

#0 0xb7fdcd3c in __kernel_vsyscall ()
#1 0xb784b307 in __GI_raise (sig=sig@entry=6) at ../nptl/sysdeps/unix/sysv/linux/raise.c:56
#2 0xb784c9c3 in __GI_abort () at abort.c:89
#3 0xb7a77a25 in __gnu_cxx::__verbose_terminate_handler() () from /usr/lib/i386-linux-gnu/libstdc++.so.6
#4 0xb7a75733 in ?? () from /usr/lib/i386-linux-gnu/libstdc++.so.6
#5 0xb7a757ad in std::terminate() () from /usr/lib/i386-linux-gnu/libstdc++.so.6
#6 0xb7a76514 in __cxa_pure_virtual () from /usr/lib/i386-linux-gnu/libstdc++.so.6
#7 0x08c12013 in ChatOverlay::Impl::recompute (this=0x9cbd048) at /var/widelands/ai_persistent_data/src/wui/chatoverlay.cc:119
#8 0x08c11fcd in ChatOverlay::recompute (this=0x9cbcfd8) at /var/widelands/ai_persistent_data/src/wui/chatoverlay.cc:105
#9 0x08a77d7e in InteractiveBase::InteractiveBase(Widelands::EditorGameBase&, Section&)::{lambda(GraphicResolutionChanged const&)#1}::operator()(GraphicResolutionChanged const&) const () at /var/widelands/ai_persistent_data/src/wui/interactive_base.cc:115
#10 0x08a7bf01 in std::_Function_handler<void(const GraphicResolutionChanged&), InteractiveBase::InteractiveBase(Widelands::EditorGameBase&, Section&)::<lambda(const GraphicResolutionChanged&)> >::_M_invoke(const std::_Any_data &, const GraphicResolutionChanged &) (__functor=..., __args#0=...)
    at /usr/include/c++/4.9/functional:2039
#11 0x0885b94b in std::function<void (GraphicResolutionChanged const&)>::operator()(GraphicResolutionChanged const&) const (this=0x9a891bc, __args#0=...)
    at /usr/include/c++/4.9/functional:2439
#12 0x0885b753 in Notifications::NotificationsManager::publish<GraphicResolutionChanged> (this=0x917dd80 <Notifications::NotificationsManager::get()::instance>,
    message=...) at /var/widelands/ai_persistent_data/src/notifications/notifications_impl.h:75
#13 0x0885affb in Notifications::publish<GraphicResolutionChanged> (message=...) at /var/widelands/ai_persistent_data/src/notifications/notifications.h:51
#14 0x0885a48d in Graphic::resolution_changed (this=0x91ea080) at /var/widelands/ai_persistent_data/src/graphic/graphic.cc:193
#15 0x0885a3d5 in Graphic::change_resolution (this=0x91ea080, w=1200, h=900) at /var/widelands/ai_persistent_data/src/graphic/graphic.cc:182
#16 0x087be6fb in WLApplication::refresh_graphics (this=0x9181f38) at /var/widelands/ai_persistent_data/src/wlapplication.cc:709
#17 0x087c113e in WLApplication::mainmenu (this=0x9181f38) at /var/widelands/ai_persistent_data/src/wlapplication.cc:1042
#18 0x087bd8b4 in WLApplication::run (this=0x9181f38) at /var/widelands/ai_persistent_data/src/wlapplication.cc:456
#19 0x087bbfd5 in main (argc=1, argv=0xbffffa24) at /var/widelands/ai_persistent_data/src/main.cc:155

Is it related to notifications? Is it specific to this branch? I dont know...

[TiborB (tiborb95)]

sorry, I wanted to say chat, not notifications

[GunChleoc (gunchleoc)]

I am getting this error on trunk as well.

[TiborB (tiborb95)]

So it has nothing to do with savegame (in)compatibility probably...

[GunChleoc (gunchleoc)]

My guess is that it does - but not caused by this branch. So, this can go in now :)

review: Approve

=== modified file 'src/ai/ai_help_structs.h'
--- src/ai/ai_help_structs.h	2015-08-19 19:29:56 +0000
+++ src/ai/ai_help_structs.h	2015-10-24 18:56:46 +0000
@@ -42,6 +42,8 @@
 class MilitarySite;
 
 enum class ExtendedBool : uint8_t {kUnset, kTrue, kFalse};
+enum class BuildingNecessity : uint8_t
+	{kForced, kNeeded, kNotNeeded, kUnset, kNotBuildable, kAllowed, kNeededPending};
 
 struct CheckStepRoadAI {
 	CheckStepRoadAI(Player* const pl, uint8_t const mc, bool const oe)
@@ -239,7 +241,7 @@
 	uint8_t unowned_land_nearby_;
 	// to identify that field is too close to border and no production building should be built there
 	bool near_border_;
-	uint8_t unowned_mines_pots_nearby_;
+	uint8_t unowned_mines_spots_nearby_;
 	uint8_t trees_nearby_;
 	uint8_t stones_nearby_;
 	int16_t water_nearby_;
@@ -248,6 +250,7 @@
 	int8_t critters_nearby_;
 	int8_t ground_water_;  // used by wells
 	uint8_t space_consumers_nearby_;
+	uint8_t rangers_nearby_;
 	// to manage the military better following variables exists:
 	// capacity of nearby buildings:
 	int16_t area_military_capacity_;
@@ -268,9 +271,15 @@
 	bool port_nearby_;  // to increase priority if a port is nearby,
 	// especially for new colonies
 	Widelands::ExtendedBool portspace_nearby_;  // prefer military buildings closer to the portspace
+	int32_t max_buildcap_nearby_;
+	// it is not necessary to check resources (stones, fish...) too frequently as they do not change fast
+	// this stores time of last check
+	uint32_t last_resources_check_time_;
 
 	std::vector<uint8_t> consumers_nearby_;
 	std::vector<uint8_t> producers_nearby_;
+	// and for rangers, fishbreeders:
+	std::vector<uint8_t> supporters_nearby_;
 
 	BuildableField(const Widelands::FCoords& fc)
 	   : coords(fc),
@@ -279,7 +288,7 @@
 	     enemy_nearby_(0),
 	     unowned_land_nearby_(0),
 	     near_border_(false),
-	     unowned_mines_pots_nearby_(0),
+	     unowned_mines_spots_nearby_(0),
 	     trees_nearby_(0),
 	     // explanation of starting values
 	     // this is done to save some work for AI (CPU utilization)
@@ -295,6 +304,7 @@
 	     critters_nearby_(-1),
 	     ground_water_(1),
 	     space_consumers_nearby_(0),
+	     rangers_nearby_(0),
 	     area_military_capacity_(0),
 	     military_loneliness_(1000),
 	     military_in_constr_nearby_(0),
@@ -303,7 +313,13 @@
 	     military_unstationed_(0),
 	     is_portspace_(false),
 	     port_nearby_(false),
-	     portspace_nearby_(Widelands::ExtendedBool::kUnset) {
+	     portspace_nearby_(Widelands::ExtendedBool::kUnset),
+	     max_buildcap_nearby_(0),
+	     last_resources_check_time_(0) {
+	}
+
+	int32_t own_military_sites_nearby_() {
+		return military_stationed_ + military_unstationed_;
 	}
 };
 
@@ -352,9 +368,11 @@
 		MINE
 	} type;
 
-	bool prod_build_material_;
 	bool plants_trees_;
 	bool recruitment_;  // is "producing" workers?
+	Widelands::BuildingNecessity new_building_;
+	uint32_t new_building_overdue_;
+	int32_t primary_priority_;
 	bool is_buildable_;
 	bool need_trees_;   // lumberjack = true
 	bool need_stones_;  // quarry = true
@@ -372,8 +390,7 @@
 	uint32_t forced_after_;     // do not wait until ware is needed
 	TrainingSiteType trainingsite_type_;
 
-	bool unoccupied_;
-	uint16_t unconnected_;  // to any warehouse (count of such buildings)
+	uint16_t unconnected_count_;  // to any warehouse (count of such buildings)
 
 	int32_t mines_;           // type of resource it mines_
 	uint16_t mines_percent_;  // % of res it can mine
@@ -383,7 +400,13 @@
 	std::vector<int16_t> outputs_;
 	std::vector<Widelands::WareIndex> critical_built_mat_;
 
+	bool built_mat_producer_;
+
+	// an enhancement to this building:
+	// produces all wares as current building, and perhaps more
 	bool upgrade_substitutes_;
+	// produces some additional wares
+	bool upgrade_extends_;
 
 	// It seems that fish and meat are subsitutes (for trainingsites), so
 	// when testing if a trainingsite is supplied enough
@@ -394,10 +417,7 @@
 	int16_t production_hint_;
 
 	// information needed for decision on new building construction
-	// these should be calculated only once during one run of construct_building()
-	// function
-	Widelands::ExtendedBool output_needed_;
-	int16_t max_preciousness;
+	int16_t max_preciousness_;
 	int16_t max_needed_preciousness_;
 
 	int32_t cnt_built_;
@@ -409,6 +429,9 @@
 	int32_t stocklevel_time;  // time when stocklevel_ was last time recalculated
 	int32_t last_dismantle_time_;
 	int32_t construction_decision_time_;
+
+	uint32_t unoccupied_count_;
+
 	bool build_material_shortage_;
 
 	int32_t total_count() const {
@@ -424,7 +447,7 @@
 	uint32_t built_time_;
 	uint32_t unoccupied_till_;
 	uint8_t stats_zero_;
-	uint8_t no_resources_count;
+	uint32_t no_resources_since_;
 	BuildingObserver* bo;
 };
 
@@ -501,8 +524,21 @@
 	uint16_t in_construction;
 	uint16_t finished;
 
+	uint16_t total_count() const {
+		return in_construction + finished;
+	}
+
 	MineTypesObserver() : in_construction(0), finished(0) {
 	}
 };
 
+// this is used to count militarysites by their size
+struct MilitarySiteSizeObserver {
+	uint16_t in_construction;
+	uint16_t finished;
+
+	MilitarySiteSizeObserver() : in_construction(0), finished(0) {
+	}
+};
+
 #endif  // end of include guard: WL_AI_AI_HELP_STRUCTS_H

=== modified file 'src/ai/ai_hints.cc'
--- src/ai/ai_hints.cc	2015-05-07 20:46:32 +0000
+++ src/ai/ai_hints.cc	2015-10-24 18:56:46 +0000
@@ -32,7 +32,7 @@
      fighting_(section ? section->get_bool("fighting") : false),
      mountain_conqueror_(section ? section->get_bool("mountain_conqueror") : false),
      prohibited_till_(section ? section->get_natural("prohibited_till", 0) : 0),
-     forced_after_(section ? section->get_natural("forced_after", 864000) : 0),  // 10 days default
+     forced_after_(section ? section->get_natural("forced_after", 864000) : 864000),  // 10 days default
      mines_percent_(section ? section->get_int("mines_percent", 100) : 0),
      trainingsite_type_(TrainingSiteType::kNoTS)
 

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2015-08-28 19:09:59 +0000
+++ src/ai/defaultai.cc	2015-10-24 18:56:46 +0000
@@ -52,7 +52,6 @@
 #include "profile/profile.h"
 
 // following is in miliseconds (widelands counts time in ms)
-// constexpr int kFieldUpdateInterval = 2000;
 constexpr int kFieldInfoExpiration = 12 * 1000;
 constexpr int kMineFieldInfoExpiration = 20 * 1000;
 constexpr int kNewMineConstInterval = 19000;
@@ -68,10 +67,21 @@
 // this is intended for map developers, by default should be off
 constexpr bool kPrintStats = false;
 
-// Some buildings have to be built close to borders and their
-// priority might be decreased below 0, so this is to
-// compensate
-constexpr int32_t kDefaultPrioBoost = 12;
+constexpr int kPersistentData  = 0; //int16_t
+constexpr int kMilitLoneliness = 1;
+constexpr int kAttacker        = 2;
+constexpr int kAttackMargin    = 0; //uint32_t
+constexpr int kLastAttack      = 1;
+constexpr int kProdRatio       = 2;
+constexpr int kColonyScan      = 3;
+constexpr int kTreesAround     = 4;
+constexpr int kEarlyMilitary   = 5;
+constexpr int kWoodDiff        = 0; //int32_t
+constexpr int kTargetMilit     = 1;
+constexpr int kLeastMilit      = 2;
+
+// duration of military campaign
+constexpr int kCampaignDuration = 15 * 60 * 1000;
 
 using namespace Widelands;
 
@@ -85,25 +95,26 @@
      type_(t),
      player_(nullptr),
      tribe_(nullptr),
-     num_constructionsites_(0),
-     num_milit_constructionsites(0),
      num_prod_constructionsites(0),
      num_ports(0),
      last_attacked_player_(std::numeric_limits<uint16_t>::max()),
+     last_attack_time_(0),
      enemysites_check_delay_(60),
-     wood_policy_(WoodPolicy::kStartRangers),
+     target_military_score_(0),
+     least_military_score_(100),
+     wood_policy_(WoodPolicy::kAllowRangers),
      next_ai_think_(0),
      next_mine_construction_due_(0),
      inhibit_road_building_(0),
      time_of_last_construction_(0),
-     enemy_last_seen_(0),
+     enemy_last_seen_(std::numeric_limits<uint32_t>::max()),
      numof_warehouses_(0),
      new_buildings_stop_(false),
      resource_necessity_territory_(100),
      resource_necessity_mines_(100),
      resource_necessity_water_(0),
      resource_necessity_water_needed_(false),
-     unstationed_milit_buildings_(0),
+     trees_around_cutters_(0),
      military_last_dismantle_(0),
      military_last_build_(0),
      seafaring_economy(false),
@@ -115,7 +126,12 @@
      ts_advanced_count_(0),
      ts_advanced_const_count_(0),
      ts_without_trainers_(0),
-     scheduler_delay_counter_(0) {
+     scheduler_delay_counter_(0),
+     ai_personality_military_loneliness_(0),
+     ai_personality_attack_margin_(0),
+     ai_personality_wood_difference_(0),
+     ai_productionsites_ratio_(0),
+	  ai_personality_early_militarysites(0) {
 
 	// Subscribe to NoteFieldPossession.
 	field_possession_subscriber_ =
@@ -296,7 +312,11 @@
 			if (check_economies()) {  // economies must be consistent
 				return;
 			}
-			taskDue[ScheduleTasks::kConstructBuilding] = gametime + 6000;
+			if (gametime < 15000) { //more frequent on the beginning of game
+				taskDue[ScheduleTasks::kConstructBuilding] = gametime + 2000;
+			} else {
+				taskDue[ScheduleTasks::kConstructBuilding] = gametime + 6000;
+			}
 			if (construct_building(gametime)) {
 				time_of_last_construction_ = gametime;
 			}
@@ -349,7 +369,7 @@
 			break;
 		case ScheduleTasks::kCountMilitaryVacant :
 			count_military_vacant_positions();
-			taskDue[ScheduleTasks::kCountMilitaryVacant] = gametime + 60 * 1000;
+			taskDue[ScheduleTasks::kCountMilitaryVacant] = gametime + 45 * 1000;
 			break;
 		case ScheduleTasks::kWareReview :
 			if (check_economies()) {  // economies must be consistent
@@ -420,8 +440,10 @@
 		bo.build_material_shortage_ = false;
 		bo.production_hint_ = -1;
 		bo.current_stats_ = 0;
-		bo.unoccupied_ = false;
-		bo.unconnected_ = 0;
+		bo.unoccupied_count_ = 0;
+		bo.unconnected_count_ = 0;
+		bo.new_building_overdue_ = 0;
+		bo.primary_priority_ = 0;
 		bo.is_buildable_ = bld.is_buildable();
 		bo.need_trees_ = bh.is_logproducer();
 		bo.need_stones_ = bh.is_stoneproducer();
@@ -437,8 +459,9 @@
 		bo.is_port_ = bld.get_isport();
 		bo.trainingsite_type_ = TrainingSiteType::kNoTS;
 		bo.upgrade_substitutes_ = false;
-		bo.output_needed_ = ExtendedBool::kUnset;
-		bo.max_preciousness = 0;
+		bo.upgrade_extends_ = false;
+		bo.built_mat_producer_ = false;
+		bo.max_preciousness_ = 0;
 		bo.max_needed_preciousness_ = 0;
 
 		if (bh.renews_map_resource()) {
@@ -519,17 +542,33 @@
 						break;
 					}
 				}
-			}
-
-			// plus some manually picked buildings,
-			// see preferred_upgrade list
-			for (const char* pb : preferred_upgrade) {
-				if (strcmp(bld.name().c_str(), pb) == 0) {
-					bo.upgrade_substitutes_ = true;
-				}
-			}
-
-			continue;
+
+				std::unordered_set<WareIndex> cur_outputs;
+				// collecting wares that are produced in enhanced building
+				for (const WareIndex& ware : bo.outputs_) {
+						cur_outputs.insert(ware);
+					}
+				bo.upgrade_extends_ = false;
+				for (WareIndex ware : enh_outputs) {
+					if (cur_outputs.count(ware) == 0) {
+						bo.upgrade_extends_ = true;
+						break;
+					}
+				}
+			}
+
+			// now we identify producers of critical build materials
+			// hardwood now
+			for (WareIndex ware : bo.outputs_) {
+				// iterating over wares subsitutes
+				if (tribe_->ware_index("wood")     == ware ||
+				    tribe_->ware_index("blackwood") == ware ||
+				    tribe_->ware_index("marble") == ware ||
+				    tribe_->ware_index("planks")   == ware) {
+						bo.built_mat_producer_ = true;
+				}
+			}
+		continue;
 		}
 
 		// now for every military building, we fill critical_built_mat_ vector
@@ -539,13 +578,11 @@
 			bo.type = BuildingObserver::MILITARYSITE;
 			const MilitarySiteDescr& milit = dynamic_cast<const MilitarySiteDescr&>(bld);
 			for (const std::pair<unsigned char, unsigned char>& temp_buildcosts : milit.buildcost()) {
-				// bellow are non-critical wares
+				// bellow are non-critical wares (well, various types of wood)
 				if (tribe_->ware_index("log") == temp_buildcosts.first ||
 				    tribe_->ware_index("blackwood") == temp_buildcosts.first ||
 				    tribe_->ware_index("planks") == temp_buildcosts.first ||
-				    tribe_->ware_index("wood") == temp_buildcosts.first ||
-				    tribe_->ware_index("raw_stone") == temp_buildcosts.first ||
-				    tribe_->ware_index("stone") == temp_buildcosts.first)
+				    tribe_->ware_index("wood") == temp_buildcosts.first)
 					continue;
 
 				bo.critical_built_mat_.push_back(temp_buildcosts.first);
@@ -571,8 +608,16 @@
 				    tribe_->ware_index("smoked_fish") == temp_input.first) {
 					bo.substitute_inputs_.insert(temp_input.first);
 				}
+
+				for (const std::pair<unsigned char, unsigned char>& temp_buildcosts : train.buildcost()) {
+					// critical wares for trainingsites
+					if (tribe_->ware_index("spidercloth") == temp_buildcosts.first ||
+						tribe_->ware_index("gold") == temp_buildcosts.first ||
+						tribe_->ware_index("grout") == temp_buildcosts.first) {
+						bo.critical_built_mat_.push_back(temp_buildcosts.first);
+					}
+				}
 			}
-
 			bo.trainingsite_type_ = bh.get_trainingsite_type();
 			// it would behave badly if no type was set
 			// make sure all TS have its type set properly in conf files
@@ -586,8 +631,6 @@
 		}
 	}
 
-
-
 	// atlanteans they consider water as a resource
 	// (together with mines, stones and wood)
 	if (tribe_->name() == "atlanteans") {
@@ -690,8 +733,73 @@
 	taskDue[ScheduleTasks::kUnbuildableFCheck] = 1000;
 	taskDue[ScheduleTasks::kWareReview] = 15 * 60 * 1000;
 	taskDue[ScheduleTasks::kPrintStats] = 30 * 60 * 1000;
-	taskDue[ScheduleTasks::kCountMilitaryVacant] = 10 * 60 * 1000;
+	taskDue[ScheduleTasks::kCountMilitaryVacant] = 1 * 60 * 1000;
 	taskDue[ScheduleTasks::kCheckEnemySites] = 10 * 60 * 1000;
+
+	// Here the AI persistent data either exists - then they are read
+	// or does not exist, then they are created and saved
+	int16_t persistent_data_exists_ = 0;
+	player_->get_ai_data(&persistent_data_exists_, kPersistentData);
+
+	// 0 implies no saved data exits yet
+	if (persistent_data_exists_ == 0) {
+		player_->set_ai_data(static_cast<int16_t>(1), kPersistentData);
+
+		// these random values to make some small differences between players
+		// they are immediately saved
+		// these values are never changed
+		ai_personality_military_loneliness_ = std::rand() % 5 * 30 - 60;
+		player_->set_ai_data(ai_personality_military_loneliness_, kMilitLoneliness);
+
+		ai_personality_attack_margin_ = std::max(std::rand() % 20 - 5, 0);
+		player_->set_ai_data(ai_personality_attack_margin_, kAttackMargin);
+
+		ai_personality_wood_difference_ = std::rand() % 40 - 20;
+		player_->set_ai_data(ai_personality_wood_difference_, kWoodDiff);
+
+		ai_productionsites_ratio_ = std::rand() % 5 + 7;
+		player_->set_ai_data(ai_productionsites_ratio_, kProdRatio);
+
+		ai_personality_early_militarysites = std::rand() % 20 + 20;
+		player_->set_ai_data(ai_personality_early_militarysites, kEarlyMilitary);
+
+	} else {
+		log (" %d: restoring saved AI data...\n", player_number());
+
+		// Restoring data and doing some basic check
+		player_->get_ai_data(&ai_personality_military_loneliness_, kMilitLoneliness);
+		check_range<int16_t>
+			(ai_personality_military_loneliness_, -60, 60, "ai_personality_military_loneliness_");
+
+		player_->get_ai_data(&ai_personality_attack_margin_, kAttackMargin);
+		check_range<uint32_t>(ai_personality_attack_margin_, 15, "ai_personality_attack_margin_");
+
+		player_->get_ai_data(&ai_personality_wood_difference_, kWoodDiff);
+		check_range<int32_t>(ai_personality_wood_difference_, -20, 19, "ai_personality_wood_difference_");
+
+		player_->get_ai_data(&ai_productionsites_ratio_, kProdRatio);
+		check_range<uint32_t>(ai_productionsites_ratio_, 5, 15, "ai_productionsites_ratio_");
+
+		player_->get_ai_data(&ai_personality_early_militarysites, kEarlyMilitary);
+		check_range<uint32_t>(ai_personality_early_militarysites, 20, 40, "ai_personality_early_militarysites");
+
+		// Now some runtime values that are generated and saved during course of game
+		player_->get_ai_data(&last_attack_time_, kLastAttack);
+
+		player_->get_ai_data(&last_attacked_player_, kAttacker);
+		check_range<int16_t>(last_attacked_player_, 0, 8, "last_attacked_player_");
+
+		player_->get_ai_data(&colony_scan_area_, kColonyScan);
+		check_range<uint32_t>(colony_scan_area_, 50, "colony_scan_area_");
+
+		player_->get_ai_data(&trees_around_cutters_, kTreesAround);
+
+		player_->get_ai_data(&least_military_score_, kLeastMilit);
+		check_range<uint32_t>(least_military_score_, 0, 1000, "least_military_score_");
+
+		player_->get_ai_data(&target_military_score_, kTargetMilit);
+		check_range<uint32_t>(target_military_score_, least_military_score_, 1000, "target_military_score_");
+	}
 }
 
 /**
@@ -821,7 +929,7 @@
 void DefaultAI::update_buildable_field(BuildableField& field, uint16_t range, bool military) {
 	// look if there is any unowned land nearby
 	Map& map = game().map();
-	const int32_t gametime = game().get_gametime();
+	const uint32_t gametime = game().get_gametime();
 	FindNodeUnowned find_unowned(player_, game());
 	FindNodeUnownedMineable find_unowned_mines_pots(player_, game());
 	PlayerNumber const pn = player_->player_number();
@@ -841,9 +949,19 @@
 		}
 	}
 
+
+	// are we going to count resources now?
+	bool resource_count_now = false;
+	// Testing in first 10 seconds or if last testing was more then 60 sec ago
+	if (field.last_resources_check_time_ < 10000 ||
+		field.last_resources_check_time_ - gametime > 60 * 1000) {
+			resource_count_now = true;
+			field.last_resources_check_time_ = gametime;
+	}
+
 	// to save some CPU
-	if ((mines_.size() > 8 && gametime % 3 > 0) || field.unowned_land_nearby_ == 0) {
-		field.unowned_mines_pots_nearby_ = 0;
+	if (mines_.size() > 8 && !resource_count_now) {
+		field.unowned_mines_spots_nearby_ = 0;
 	} else {
 		uint32_t close_mines =
 		   map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_unowned_mines_pots);
@@ -852,9 +970,9 @@
 		                   nullptr,
 		                   find_unowned_mines_pots);
 		distant_mines = distant_mines - close_mines;
-		field.unowned_mines_pots_nearby_ = 4 * close_mines + distant_mines / 2;
+		field.unowned_mines_spots_nearby_ = 4 * close_mines + distant_mines / 2;
 		if (distant_mines > 0) {
-			field.unowned_mines_pots_nearby_ += 15;
+			field.unowned_mines_spots_nearby_ += 15;
 		}
 	}
 
@@ -889,6 +1007,19 @@
 		field.port_nearby_ = false;
 	}
 
+	// testing fields in radius 1 to find biggest buildcaps.
+	// This is to calculate capacity that will be lost if something is
+	// built here
+	field.max_buildcap_nearby_ = 0;
+	MapRegion<Area<FCoords>> mr(map, Area<FCoords>(field.coords, 1));
+		do {
+			if ((player_->get_buildcaps(mr.location()) & BUILDCAPS_SIZEMASK) > field.max_buildcap_nearby_) {
+				field.max_buildcap_nearby_ = player_->get_buildcaps(mr.location()) & BUILDCAPS_SIZEMASK;
+			}
+		} while (mr.advance(map));
+
+	assert ((player_->get_buildcaps(field.coords) & BUILDCAPS_SIZEMASK) <= field.max_buildcap_nearby_);
+
 	// collect information about resources in the area
 	std::vector<ImmovableFound> immovables;
 	// Search in a radius of range
@@ -906,10 +1037,13 @@
 		field.military_stationed_ = 0;
 		field.trees_nearby_ = 0;
 		field.space_consumers_nearby_ = 0;
+		field.rangers_nearby_ = 0;
 		field.producers_nearby_.clear();
 		field.producers_nearby_.resize(wares.size());
 		field.consumers_nearby_.clear();
 		field.consumers_nearby_.resize(wares.size());
+		field.supporters_nearby_.clear();
+		field.supporters_nearby_.resize(wares.size());
 		std::vector<Coords> water_list;
 		std::vector<Coords> resource_list;
 		std::vector<Bob*> critters_list;
@@ -927,7 +1061,7 @@
 		}
 
 		// counting fields with fish
-		if (field.water_nearby_ > 0 && (field.fish_nearby_ == -1 || gametime % 10 == 0)) {
+		if (field.water_nearby_ > 0 && (field.fish_nearby_ == -1 || resource_count_now)) {
 			map.find_fields(Area<FCoords>(field.coords, 6),
 			                &resource_list,
 			                FindNodeResource(world.get_resource("fish")));
@@ -936,7 +1070,7 @@
 
 		// counting fields with critters (game)
 		// not doing this always, this does not change fast
-		if (gametime % 10 == 0) {
+		if (resource_count_now) {
 			map.find_bobs(Area<FCoords>(field.coords, 6), &critters_list, FindBobCritter());
 			field.critters_nearby_ = critters_list.size();
 		}
@@ -965,25 +1099,16 @@
 
 					continue;
 				}
-			}
-
-			if (upcast(Building const, building, &base_immovable)) {
-				if (upcast(ConstructionSite const, constructionsite, building)) {
+				// here we identify the buiding (including expected building if constructionsite)
+				// and calculate some statistics about nearby buildings
+				if (upcast(ProductionSite const, productionsite, player_immovable)) {
+					BuildingObserver& bo = get_building_observer(productionsite->descr().name().c_str());
+					consider_productionsite_influence(field, immovables.at(i).coords, bo);
+				}
+				if (upcast(ConstructionSite const, constructionsite, player_immovable)) {
 					const BuildingDescr& target_descr = constructionsite->building();
-
-					if (dynamic_cast<ProductionSiteDescr const*>(&target_descr)) {
-						consider_productionsite_influence(
-						   field,
-						   immovables.at(i).coords,
-						   get_building_observer(constructionsite->descr().name().c_str()));
-					}
-				}
-
-				if (dynamic_cast<const ProductionSite*>(building)) {
-					consider_productionsite_influence(
-					   field,
-					   immovables.at(i).coords,
-					   get_building_observer(building->descr().name().c_str()));
+					BuildingObserver& bo = get_building_observer(target_descr.name().c_str());
+					consider_productionsite_influence(field, immovables.at(i).coords, bo);
 				}
 			}
 
@@ -993,7 +1118,7 @@
 		}
 
 		// stones are not renewable, we will count them only if previous state is nonzero
-		if (field.stones_nearby_ > 0 && gametime % 3 == 0) {
+		if (field.stones_nearby_ > 0 && resource_count_now) {
 
 			field.stones_nearby_ =
 				map.find_immovables(Area<FCoords>(map.get_fcoords(field.coords), 6),
@@ -1037,7 +1162,6 @@
 				if (player_->is_hostile(player_immovable->owner())) {
 					field.enemy_nearby_ = true;
 				}
-
 				continue;
 			}
 		}
@@ -1142,8 +1266,8 @@
 	// Reset statistics for all buildings
 	for (uint32_t i = 0; i < buildings_.size(); ++i) {
 		buildings_.at(i).current_stats_ = 0;
-		buildings_.at(i).unoccupied_ = false;
-		buildings_.at(i).unconnected_ = 0;
+		buildings_.at(i).unoccupied_count_ = 0;
+		buildings_.at(i).unconnected_count_ = 0;
 	}
 
 	// Check all available productionsites
@@ -1165,10 +1289,11 @@
 			}
 
 			// Check whether this building is completely occupied
-			productionsites.front().bo->unoccupied_ |=
-			   !productionsites.front().site->can_start_working();
+			if (!productionsites.front().site->can_start_working()) {
+				productionsites.front().bo->unoccupied_count_ += 1;
+			}
 		} else {
-			productionsites.front().bo->unconnected_ += 1;
+			productionsites.front().bo->unconnected_count_ += 1;
 		}
 
 		// Now reorder the buildings
@@ -1199,9 +1324,11 @@
 			// Add statistics value
 			mines_.front().bo->current_stats_ += mines_.front().site->get_statistics_percent();
 			// Check whether this building is completely occupied
-			mines_.front().bo->unoccupied_ |= !mines_.front().site->can_start_working();
+			if (!mines_.front().site->can_start_working()) {
+				mines_.front().bo->unoccupied_count_ += 1;
+			}
 		} else {
-			mines_.front().bo->unconnected_ += 1;
+			mines_.front().bo->unconnected_count_ += 1;
 		}
 
 		// Now reorder the buildings
@@ -1211,9 +1338,9 @@
 
 	// Scale statistics down
 	for (uint32_t i = 0; i < buildings_.size(); ++i) {
-		if ((buildings_.at(i).cnt_built_ - buildings_.at(i).unconnected_) > 0) {
+		if ((buildings_.at(i).cnt_built_ - buildings_.at(i).unconnected_count_) > 0) {
 			buildings_.at(i).current_stats_ /=
-			   (buildings_.at(i).cnt_built_ - buildings_.at(i).unconnected_);
+			   (buildings_.at(i).cnt_built_ - buildings_.at(i).unconnected_count_);
 		}
 	}
 }
@@ -1261,7 +1388,6 @@
 
 	// here we possible stop building of new buildings
 	new_buildings_stop_ = false;
-	MilitaryStrategy expansion_mode = MilitaryStrategy::kResourcesOrDefense;
 
 	// helper variable - we need some proportion of free spots vs productionsites
 	// the proportion depends on size of economy
@@ -1278,11 +1404,63 @@
 		needed_spots = 1300 + (productionsites.size() - 200) * 20;
 	}
 
+	// *_military_scores are used as minimal score for a new military building
+	// to be built. As AI does not traverse all building fields at once, these thresholds
+	// are gradually going down until it finds a field&building that are above threshold
+	// and this combination is used...
+	// least_military_score_ is hardlimit, floating very slowly
+	// target_military_score_ is always set according to latest best building (using the same
+	// score) and quickly falling down until it reaches the least_military_score_
+	// this one (=target_military_score_) is actually used to decide if building&field is allowed
+	// candidate
+	// least_military_score_ is allowed to get bellow 100 only if there is no military site in construction
+	// right now in order to (try to) avoid expansion lockup
+
+	// this is just helpers to improve readability of code
+	const bool too_many_ms_constructionsites =
+		(pow(msites_in_constr(), 2) > militarysites.size());
+	const bool too_many_vacant_mil =
+		(vacant_mil_positions_ * 3 > static_cast<int32_t>(militarysites.size()));
+	const int32_t kUpperLimit = 275;
+	const int32_t kBottomLimit = 40; // to prevent too dense militarysites
+	// modifying least_military_score_, down if more military sites are needed and vice versa
+	if (too_many_ms_constructionsites || too_many_vacant_mil) {
+		if (least_military_score_ < kUpperLimit) { //no sense to let it grow too hight
+			least_military_score_ += 2;
+		}
+	} else {
+		least_military_score_ -= 4;
+		// do not get bellow 100 if there is at least one ms in construction
+		if ((msites_in_constr() > 0 || too_many_vacant_mil) && least_military_score_ < kBottomLimit) {
+			least_military_score_ = kBottomLimit;
+		}
+		if (least_military_score_ < 0) {
+			least_military_score_ = 0;
+		}
+	}
+
+	// This is effective score, falling down very quickly
+	if (target_military_score_ > 350) {
+		target_military_score_ = 8 * target_military_score_ / 10;
+	} else {
+		target_military_score_ = 9 * target_military_score_ / 10;
+	}
+	if (target_military_score_ < least_military_score_) {
+		target_military_score_ = least_military_score_;
+	}
+	player_->set_ai_data(target_military_score_, kTargetMilit);
+	player_->set_ai_data(least_military_score_, kLeastMilit);
+
+
 	// there are many reasons why to stop building production buildings
 	// (note there are numerous exceptions)
 	// 1. to not have too many constructionsites
-	if (num_prod_constructionsites > productionsites.size() / 7 + 2) {
-		new_buildings_stop_ = true;
+	if ((num_prod_constructionsites + mines_in_constr())
+		>
+		(productionsites.size() + mines_built())
+		/
+		ai_productionsites_ratio_ + 2) {
+			new_buildings_stop_ = true;
 	}
 	// 2. to not exhaust all free spots
 	if (spots_ < needed_spots) {
@@ -1290,16 +1468,12 @@
 	}
 	// 3. too keep some proportions production sites vs military sites
 	if ((num_prod_constructionsites + productionsites.size()) >
-	    (num_milit_constructionsites + militarysites.size()) * 5) {
-		new_buildings_stop_ = true;
-	}
-	// 4. if we do not have 3 mines at least
-	if (mines_.size() < 3) {
-		new_buildings_stop_ = true;
-	}
-	// BUT if enemy is nearby, we cancel above stop
-	if (new_buildings_stop_ && enemy_last_seen_ + 10 * 60 * 1000 > gametime) {
-		new_buildings_stop_ = false;
+	    (msites_in_constr() + militarysites.size()) * 5) {
+		new_buildings_stop_ = true;
+	}
+	// 4. if we do not have 2 mines at least
+	if (mines_.size() < 2) {
+		new_buildings_stop_ = true;
 	}
 
 	// we must calculate wood policy
@@ -1309,15 +1483,16 @@
 	// it is proportion to the size of economy). Plus some positive 'margin'
 	const int32_t stocked_wood_margin = get_warehoused_stock(wood_index) -
 		productionsites.size() * 2 -
-		num_prod_constructionsites;
-	if (stocked_wood_margin > 80) {
+		num_prod_constructionsites +
+		ai_personality_wood_difference_;
+	if (gametime < 15 * 60 * 1000) {
+		wood_policy_ = WoodPolicy::kAllowRangers;
+	} else if (stocked_wood_margin > 80) {
 		wood_policy_ = WoodPolicy::kDismantleRangers;
 	} else if  (stocked_wood_margin > 25) {
 		wood_policy_ = WoodPolicy::kStopRangers;
-	} else if  (stocked_wood_margin > 10) {
-		wood_policy_ = WoodPolicy::kStartRangers;
 	} else {
-		wood_policy_ = WoodPolicy::kBuildRangers;
+		wood_policy_ = WoodPolicy::kAllowRangers;
 	}
 
 	// we must consider need for mines
@@ -1325,7 +1500,7 @@
 	// we use 'virtual mines', because also mine spots can be changed
 	// to mines when AI decides so
 	const int32_t virtual_mines =
-	   mines_.size() + mineable_fields.size() / 15 - productionsites.size() / 25;
+	   mines_.size() + mineable_fields.size() / 25;
 	resource_necessity_mines_ = 100 * (15 - virtual_mines) / 15;
 	resource_necessity_mines_ = (resource_necessity_mines_ > 100) ? 100 : resource_necessity_mines_;
 	resource_necessity_mines_ = (resource_necessity_mines_ < 20) ? 10 : resource_necessity_mines_;
@@ -1349,27 +1524,6 @@
 		}
 	}
 
-	// this controls a speed and willingness to expand the teritorry
-	const int32_t vacant_plus_in_construction_minus_prod =
-	   vacant_mil_positions_ + 2 * num_milit_constructionsites - productionsites.size() / 7;
-	if (vacant_plus_in_construction_minus_prod > 20) {
-		expansion_mode = MilitaryStrategy::kNoNewMilitary;
-	} else if (vacant_plus_in_construction_minus_prod > 13) {
-		expansion_mode = MilitaryStrategy::kDefenseOnly;
-	} else if (vacant_plus_in_construction_minus_prod > 6) {
-		expansion_mode = MilitaryStrategy::kResourcesOrDefense;
-	} else {
-		// this is intended for initial phase of game when the player still has enough soldiers
-		// but we still want to force it to follow resources instead for plain expansion
-		if (virtual_mines <= 2 && (unstationed_milit_buildings_ + num_milit_constructionsites) > 2) {
-			expansion_mode = MilitaryStrategy::kResourcesOrDefense;
-		} else if (unstationed_milit_buildings_ + num_milit_constructionsites >= 1) {
-			expansion_mode = MilitaryStrategy::kExpansion;
-		} else {
-			expansion_mode = MilitaryStrategy::kPushExpansion;
-		}
-	}
-
 	BuildingObserver* best_building = nullptr;
 	int32_t proposed_priority = 0;
 	Coords proposed_coords;
@@ -1393,11 +1547,11 @@
 		}
 
 		// not doing this for non-military buildins
-		if (!(bo.type == BuildingObserver::MILITARYSITE))
+		if (!(bo.type == BuildingObserver::MILITARYSITE || bo.type == BuildingObserver::TRAININGSITE))
 			continue;
 
 		// and neither for small military buildings
-		if (bo.desc->get_size() == BaseImmovable::SMALL)
+		if (bo.type == BuildingObserver::MILITARYSITE  && bo.desc->get_size() == BaseImmovable::SMALL)
 			continue;
 
 		bo.build_material_shortage_ = false;
@@ -1412,11 +1566,80 @@
 		}
 	}
 
-	//Resetting output_needed_ in building observer
+	// Calculating actual needness
 	for (uint32_t j = 0; j < buildings_.size(); ++j) {
 		BuildingObserver& bo = buildings_.at(j);
-		if (bo.type == BuildingObserver::PRODUCTIONSITE || bo.type == BuildingObserver::MINE){
-			bo.output_needed_ = ExtendedBool::kUnset;
+
+		if (!bo.buildable(*player_)) {
+			bo.new_building_ = BuildingNecessity::kNotNeeded;
+		} else if (bo.type == BuildingObserver::PRODUCTIONSITE || bo.type == BuildingObserver::MINE) {
+
+			bo.new_building_ = check_building_necessity(bo, PerfEvaluation::kForConstruction, gametime);
+
+			if (bo.new_building_ == BuildingNecessity::kAllowed) {
+				bo.new_building_overdue_ = 0;
+			}
+
+			// Now verifying that all 'buildable' buildings has positive max_needed_preciousness_
+			// if they have outputs, all other must have zero max_needed_preciousness_
+			if ((bo.new_building_ == BuildingNecessity::kNeeded
+				|| bo.new_building_ == BuildingNecessity::kForced
+				|| bo.new_building_ == BuildingNecessity::kAllowed
+				|| bo.new_building_ == BuildingNecessity::kNeededPending) && !bo.outputs_.empty()) {
+					assert (bo.max_needed_preciousness_ > 0);
+			} else {
+				// For other situations we set max_needed_preciousness_ to zero
+				bo.max_needed_preciousness_ = 0;
+			}
+
+
+			// Here we consider a time how long a building needed
+			// We calculate primary_priority used later in construct_building(),
+			// it is basically max_needed_preciousness_ plus some 'bonus' for due time
+			// Following scenarios are possible:
+			// a) building is needed or forced: primary_priority_ grows with time
+			// b) building is allowed: primary_priority_ = max_needed_preciousness_ (no time consideration)
+			// c) all other cases: primary_priority_ = 0;
+			if (bo.max_needed_preciousness_ > 0) {
+				if (bo.new_building_ == BuildingNecessity::kAllowed) {
+					bo.primary_priority_ = bo.max_needed_preciousness_;
+				} else {
+					bo.primary_priority_ = bo.max_needed_preciousness_ +
+					bo.max_needed_preciousness_ * bo.new_building_overdue_ / 100 +
+					bo.new_building_overdue_ / 20;
+				}
+			} else {
+				bo.primary_priority_ = 0;
+			}
+
+			// Generally we don't start another building if there is some of the same type in construction
+			// Some types of building allow two buildings in construction though, but not more
+			// Below checks are to guarantee that there is no logical error in previous steps, or
+			// inconsistency in AI data
+			if (bo.new_building_ == BuildingNecessity::kNeeded
+				|| bo.new_building_ == BuildingNecessity::kForced
+				|| bo.new_building_ == BuildingNecessity::kAllowed
+				|| bo.new_building_ == BuildingNecessity::kNeededPending) {
+				if (bo.plants_trees_ || bo.need_trees_ || bo.max_needed_preciousness_ >= 10) {
+					if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 1) {
+					throw wexception("AI inconsistency:  %s: total_count %d > 1, unoccupied: %d",
+						bo.name, bo.total_count(), bo.unoccupied_count_);
+					}
+				} else {
+					if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0) {
+					throw wexception("AI inconsistency:  %s: total_count %d > 0, unoccupied: %d",
+						bo.name, bo.total_count(), bo.unoccupied_count_);
+					}
+				}
+			}
+
+		} else if (bo.type == BuildingObserver::MILITARYSITE) {
+			bo.new_building_ = check_building_necessity(bo.desc->get_size(), gametime);
+		} else if  (bo.type == BuildingObserver::TRAININGSITE && bo.build_material_shortage_) {
+			bo.new_building_ = BuildingNecessity::kNotNeeded;
+		} else {
+			bo.new_building_ = BuildingNecessity::kAllowed;
+			bo.primary_priority_ = 0;
 		}
 	}
 
@@ -1448,6 +1671,7 @@
 		assert(player_);
 		int32_t const maxsize = player_->get_buildcaps(bf->coords) & BUILDCAPS_SIZEMASK;
 
+
 		// For every field test all buildings
 		for (uint32_t j = 0; j < buildings_.size(); ++j) {
 			BuildingObserver& bo = buildings_.at(j);
@@ -1456,9 +1680,14 @@
 				continue;
 			}
 
-			if (bo.prohibited_till_ > gametime) {
+			if (bo.new_building_ == BuildingNecessity::kNotNeeded ||
+				bo.new_building_ == BuildingNecessity::kNeededPending) {
 				continue;
-			}
+				}
+
+			assert (bo.new_building_ == BuildingNecessity::kForced ||
+			bo.new_building_ == BuildingNecessity::kNeeded ||
+			bo.new_building_ == BuildingNecessity::kAllowed);
 
 			// if current field is not big enough
 			if (bo.desc->get_size() > maxsize) {
@@ -1486,10 +1715,6 @@
 				continue;
 			}
 
-			if (bo.unoccupied_) {
-				continue;
-			}
-
 			if (!(bo.type == BuildingObserver::MILITARYSITE) && bo.cnt_under_construction_ >= 2) {
 				continue;
 			}
@@ -1498,95 +1723,55 @@
 
 			if (bo.type == BuildingObserver::PRODUCTIONSITE) {
 
-				// exclude spots on border
-				if (bf->near_border_ && !bo.need_trees_ && !bo.need_stones_ && !bo.is_fisher_) {
-					continue;
-				}
-
-				// this just indicates that values must be recalculated - if this building
-				// is to be considered later on in this function
-				if (bo.output_needed_ == ExtendedBool::kUnset) {
-					check_building_necessity(bo);
-				}
-
 				// this can be only a well (as by now)
 				if (bo.mines_water_) {
+
+					if (bo.new_building_ == BuildingNecessity::kForced) {
+						assert (bo.total_count() - bo.unconnected_count_ == 0);
+					}
+
 					if (bf->ground_water_ < 2) {
 						continue;
 					}
 
-					if (bo.cnt_under_construction_ + bo.unoccupied_ > 0) {
+					prio = bo.primary_priority_;
+
+					// keep wells more distant
+					if (bf->producers_nearby_.at(bo.outputs_.at(0)) > 2) {
 						continue;
 					}
 
-					prio = 0;
 					// one well is forced
-					if (bo.total_count() == 0) {
-						prio = 200;
-					}  // boost for first/only well
-					else if (new_buildings_stop_) {
-						continue;
-					}
-
-					bo.cnt_target_ = 1 + productionsites.size() / 50;
-
-					if (bo.stocklevel_time < game().get_gametime() - 30 * 1000) {
-						bo.stocklevel_ = get_stocklevel(bo);
-						bo.stocklevel_time = game().get_gametime();
-					}
-					if (bo.stocklevel_ > 50 + productionsites.size() * 5) {
-						continue;
-					}
+					if (bo.new_building_ == BuildingNecessity::kForced) {
+						prio += 200;
+					}
+
 					prio += bf->ground_water_ - 2;
-					prio = recalc_with_border_range(*bf, prio);
 
 				} else if (bo.need_trees_) {  // LUMBERJACS
 
-					bo.cnt_target_ =
-					   3 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 15;
-
-					if (bo.total_count() == 0) {
-						prio = 500 + bf->trees_nearby_;
-					}
-
-					else if (bo.total_count() == 1) {
-						prio = 400 + bf->trees_nearby_;
-					}
-
-					else if (bf->trees_nearby_ < 2) {
+					prio = bo.primary_priority_;
+
+					prio += -20 + 200 / (bo.total_count() + 1);
+
+					if (bo.new_building_ == BuildingNecessity::kForced) {
+						prio *= 2;
+					} else if (bf->trees_nearby_ < 2 && bf->supporters_nearby_.at(bo.outputs_.at(0) == 0)) {
 						continue;
 					}
 
-					else {
-
-						if (bo.total_count() < bo.cnt_target_) {
-							prio = 75;
-						} else {
-							prio = 0;
-						}
-
-						if (bf->producers_nearby_.at(bo.outputs_.at(0)) > 1) {
-							continue;
-						}
-
-						prio += 2 * bf->trees_nearby_ - 10 -
-						        bf->producers_nearby_.at(bo.outputs_.at(0)) * 5 -
-						        new_buildings_stop_ * 15;
-
-						if (bf->near_border_) {
-							prio = prio / 2;
-						}
-					}
+					// consider cutters and rangers nearby
+					prio -= bf->producers_nearby_.at(bo.outputs_.at(0)) * 20;
+					prio += bf->supporters_nearby_.at(bo.outputs_.at(0)) * 5;
+
+					prio += 2 * bf->trees_nearby_;
 
 				} else if (bo.need_stones_) {
 
 					// quaries are generally to be built everywhere where stones are
 					// no matter the need for stones, as stones are considered an obstacle
 					// to expansion
-					if (bo.cnt_under_construction_ > 0) {
-						continue;
-					}
-					prio = bf->stones_nearby_;
+					prio = 2 * bf->stones_nearby_;
 
 					// value is initialized with 1 but minimal value that can be
 					// calculated is 11
@@ -1594,12 +1779,12 @@
 						continue;
 					}
 
-					if (bo.total_count() - bo.unconnected_ == 0) {
+					if (bo.total_count() - bo.unconnected_count_ == 0) {
 						prio += 150;
 					}
 
 					if (bo.stocklevel_time < game().get_gametime() - 5 * 1000) {
-						bo.stocklevel_ = get_stocklevel_by_hint(static_cast<size_t>(bo.production_hint_));
+						bo.stocklevel_ = get_stocklevel(static_cast<size_t>(bo.production_hint_));
 						bo.stocklevel_time = game().get_gametime();
 					}
 
@@ -1610,119 +1795,93 @@
 					// to prevent to many quaries on one spot
 					prio = prio - 50 * bf->producers_nearby_.at(bo.outputs_.at(0));
 
-					if (bf->near_border_) {
-						prio = prio / 2;
-					}
-
 				} else if (bo.is_hunter_) {
+
 					if (bf->critters_nearby_ < 5) {
 						continue;
 					}
 
-					if (gametime > 5 * 60 * 1000 &&
-					(bo.total_count() - bo.unconnected_  == 0)) {
-						prio += 10;
-					} else if (new_buildings_stop_) {
-						continue;
+					if (bo.new_building_ == BuildingNecessity::kForced) {
+						prio += 20;
 					}
 
+					// Overdue priority here
+					prio += bo.primary_priority_;
+
+					prio += bf->supporters_nearby_.at(bo.outputs_.at(0)) * 5;
+
 					prio +=
 					   (bf->critters_nearby_ * 3) - 8 - 5 * bf->producers_nearby_.at(bo.outputs_.at(0));
 
 				} else if (bo.is_fisher_) {  // fisher
 
-					// ~are fishes needed?
-					if (bo.max_needed_preciousness_ == 0) {
-						continue;
-					}
-
-					if (bo.cnt_under_construction_ + bo.unoccupied_ > 0) {
-						continue;
-					}
-
-					if (bf->water_nearby_ < 2) {
-						continue;
-					}
-
-					// we use preciousness to allow atlanteans to build the fishers huts
-					// atlanteans have preciousness 4, other tribes 3
-					if (bo.max_needed_preciousness_ < 4 && new_buildings_stop_) {
-						continue;
-					}
-
-					if (bo.stocklevel_time < game().get_gametime() - 5 * 1000) {
-						bo.stocklevel_ = get_stocklevel_by_hint(static_cast<size_t>(bo.production_hint_));
-						bo.stocklevel_time = game().get_gametime();
-					}
-
-					if (bo.stocklevel_ > 50) {
-						continue;
-					}
-
-					if (bf->producers_nearby_.at(bo.outputs_.at(0)) >= 1) {
-						continue;
-					}
-
-					prio = bf->fish_nearby_ - new_buildings_stop_ * 15 * bo.total_count();
+					if (bf->water_nearby_ < 2 || bf->fish_nearby_ < 2) {
+						continue;
+					}
+
+					if (bo.new_building_ == BuildingNecessity::kForced) {
+						prio += 20;
+					}
+
+					// Overdue priority here
+					prio += bo.primary_priority_;
+
+					prio -= bf->producers_nearby_.at(bo.outputs_.at(0)) * 20;
+					prio += bf->supporters_nearby_.at(bo.outputs_.at(0)) * 10;
+
+					prio += -5 + bf->fish_nearby_;
 
 				} else if (bo.production_hint_ >= 0) {
-					// first setting targets (needed also for dismantling)
 					if (bo.plants_trees_) {
-						bo.cnt_target_ =
-						   2 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 15;
+						assert (bo.cnt_target_ > 0);
 					} else {
 						bo.cnt_target_ =
-						   1 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 20;
+						   1 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 50;
 					}
 
-					if ((bo.cnt_under_construction_ + bo.unoccupied_) > 1) {
-						continue;
-					}
+					// They have no own primary priority
+					assert(bo.primary_priority_ == 0);
 
 					if (bo.plants_trees_) {  // RANGERS
 
+						assert(bo.new_building_ == BuildingNecessity::kNeeded);
+
 						// if there are too many trees nearby
 						if (bf->trees_nearby_ > 25 && bo.total_count() >= 1) {
 							continue;
 						}
 
 						// for small starting spots - to prevent crowding by rangers and trees
-						if (spots_ < (10 * bo.total_count()) && bo.total_count() > 0) {
+						if (spots_ < (4 * bo.total_count()) && bo.total_count() > 0) {
 							continue;
 						}
 
 						if (bo.total_count() == 0) {
 							prio = 200;
-						}
-						if (bo.total_count() > 2 * bo.cnt_target_) {
-							continue;
-						}
-						// we can go above target if there is shortage of logs on stock
-						else if (bo.total_count() >= bo.cnt_target_) {
-							if (wood_policy_ != WoodPolicy::kBuildRangers) {
-								continue;
-							}
+						} else {
+							prio = 50 / bo.total_count();
 						}
 
-						// considering near trees and producers
-						prio += (30 - bf->trees_nearby_) * 2 +
-						        bf->producers_nearby_.at(bo.production_hint_) * 5 -
-						        new_buildings_stop_ * 15;
+						// considering producers
+						prio += std::min<uint8_t>(bf->producers_nearby_.at(bo.production_hint_), 4) * 5 -
+						        new_buildings_stop_ * 15 -
+						       	bf->space_consumers_nearby_ * 5  -
+						        bf->stones_nearby_ / 3 +
+						        bf->trees_nearby_ / 2 +
+						        std::min<uint8_t>(bf->supporters_nearby_.at(bo.production_hint_), 4) * 3;
 
 					} else {  // FISH BREEDERS and GAME KEEPERS
-						if (new_buildings_stop_ && (bo.total_count() - bo.unconnected_) > 0) {
-							continue;
-						}
 
 						// especially for fish breeders
-						if (bo.need_water_ && bf->water_nearby_ < 2) {
+						if (bo.need_water_ && (bf->water_nearby_ < 6 || bf->fish_nearby_ < 6)) {
 							continue;
 						}
 						if (bo.need_water_) {
-							prio += bf->water_nearby_ / 5;
+							prio += (-6 + bf->water_nearby_) / 3;
+							prio += (-6 + bf->fish_nearby_) / 3;
 						}
 
-						if ((bo.total_count() - bo.unconnected_) > bo.cnt_target_) {
+						if ((bo.total_count() - bo.unconnected_count_) > bo.cnt_target_) {
 							continue;
 						}
 
@@ -1735,16 +1894,17 @@
 							continue;
 						}
 
-						if (bo.total_count() == 0 && gametime > 45 * 1000) {
-							prio += 100 + bf->producers_nearby_.at(bo.production_hint_) * 10;
-						} else if (bf->producers_nearby_.at(bo.production_hint_) == 0) {
-							continue;
-						} else {
-							prio += bf->producers_nearby_.at(bo.production_hint_) * 10;
+						if (bo.total_count() == 0) {
+							prio += 100;
+						} else  if (!bo.need_water_) {
+							prio += 10 / bo.total_count();
 						}
 
+						prio += bf->producers_nearby_.at(bo.production_hint_) * 10;
+						prio -= bf->supporters_nearby_.at(bo.production_hint_) * 20;
+
 						if (bf->enemy_nearby_) {
-							prio -= 10;
+							prio -= 5;
 						}
 					}
 
@@ -1752,64 +1912,41 @@
 					// this will depend on number of mines_ and productionsites
 					if (static_cast<int32_t>((productionsites.size() + mines_.size()) / 30) >
 					       bo.total_count() &&
-					    (bo.cnt_under_construction_ + bo.unoccupied_) == 0 &&
+					    (bo.cnt_under_construction_ + bo.unoccupied_count_) == 0 &&
 					    // but only if current buildings are utilized enough
 					    (bo.total_count() == 0 || bo.current_stats_ > 60)) {
-							prio = 4 + kDefaultPrioBoost;
+							prio = 10;
 						}
 				} else {  // finally normal productionsites
-					if (bo.production_hint_ >= 0) {
-						continue;
-					}
-
-					// generally we allow 1 building in construction, but if
-					// preciousness of missing ware is >=10 and it is farm-like building
-					// we allow 2 in construction
-					if (bo.max_needed_preciousness_ >= 10
-						&& bo.inputs_.empty()
-						&& gametime > 30 * 60 * 1000) {
-						if ((bo.cnt_under_construction_ + bo.unoccupied_) > 1) {
-							continue;
-						}
-					} else {
-						if ((bo.cnt_under_construction_ + bo.unoccupied_) > 0) {
-							continue;
-						}
-					}
-
-					if (bo.forced_after_ < gametime && (bo.total_count() - bo.unconnected_) == 0) {
+					assert (bo.production_hint_ < 0);
+
+					if (bo.new_building_ == BuildingNecessity::kForced) {
 						prio += 150;
-					} else if ((bo.cnt_built_ - bo.unconnected_) == 1 &&
-					           game().get_gametime() > 40 * 60 * 1000 &&
-					           bo.desc->enhancement() != INVALID_INDEX && !mines_.empty()) {
-						prio += 10;
 					} else if (bo.is_shipyard_) {
+						assert (bo.new_building_ == BuildingNecessity::kAllowed);
 						if (!seafaring_economy) {
 							continue;
 						}
-					} else if (bo.output_needed_ == ExtendedBool::kFalse) {
-						continue;
-					} else if ((bo.cnt_built_ - bo.unconnected_) == 0 &&
-					           game().get_gametime() > 40 * 60 * 1000) {
-						prio += kDefaultPrioBoost;
-					} else if ((bo.cnt_built_ - bo.unconnected_) > 1 && bo.current_stats_ > 97) {
-						prio -= kDefaultPrioBoost * (new_buildings_stop_);
-					} else if (new_buildings_stop_) {
-						continue;
+					} else {
+						assert (bo.new_building_ == BuildingNecessity::kNeeded);
 					}
+
+					// Overdue priority here
+					prio += bo.primary_priority_;
+
 					// we check separatelly buildings with no inputs and some inputs
 					if (bo.inputs_.empty()) {
 
-						prio += bo.max_needed_preciousness_ + kDefaultPrioBoost;
-
-						if (bo.space_consumer_) {  // need to consider trees nearby
-							prio += 20 - (bf->trees_nearby_ / 3);
-						}
-
-						// we attempt to cluster space consumers together
-						if (bo.space_consumer_) {  // need to consider trees nearby
-							prio += bf->space_consumers_nearby_ * 10;
-							prio += (bf->space_consumers_nearby_ > 2) ? 2 : bf->space_consumers_nearby_ * 2;
+						if (bo.space_consumer_) {
+							// we dont like trees nearby
+							prio += 1 - bf->trees_nearby_ / 15;
+							// we attempt to cluster space consumers together
+							prio += bf->space_consumers_nearby_ * 2;
+							// and be far from rangers
+							prio += 1 - bf->rangers_nearby_ * 3;
+						} else {
+							// leave some free space between them
+							prio -= bf->producers_nearby_.at(bo.outputs_.at(0)) * 5;
 						}
 
 						if (bo.space_consumer_ && !bf->water_nearby_) {  // not close to water
@@ -1817,33 +1954,16 @@
 						}
 
 						if (bo.space_consumer_ &&
-						    !bf->unowned_mines_pots_nearby_) {  // not close to mountains
+						    !bf->unowned_mines_spots_nearby_) {  // not close to mountains
 							prio += 1;
 						}
-
-						if (!bo.space_consumer_) {
-							prio -= bf->producers_nearby_.at(bo.outputs_.at(0)) * 20;
-						}  // leave some free space between them
 					}
 
 					else if (bo.is_shipyard_) {
 						// for now AI builds only one shipyard
-						if (bf->water_nearby_ > 3 && (bo.total_count() - bo.unconnected_) == 0 &&
+						if (bf->water_nearby_ > 3 && (bo.total_count() - bo.unconnected_count_) == 0 &&
 						    seafaring_economy) {
-							prio += kDefaultPrioBoost + productionsites.size() * 5 + bf->water_nearby_;
-						}
-
-					} else if (!bo.inputs_.empty()) {
-						if ((bo.total_count() - bo.unconnected_ == 0)) {
-							prio += bo.max_needed_preciousness_ + kDefaultPrioBoost;
-						}
-						if ((bo.cnt_built_ - bo.unconnected_) > 0
-							&&
-							is_productionsite_needed(bo.outputs_.size(),
-													bo.current_stats_,
-													PerfEvaluation::kForConstruction)) {
-							prio += bo.max_needed_preciousness_ + kDefaultPrioBoost - 3 +
-							        (bo.current_stats_ - 55) / 8;
+							prio += productionsites.size() * 5 + bf->water_nearby_;
 						}
 					}
 
@@ -1871,19 +1991,14 @@
 					}
 				}
 
-				// consider borders (for medium + big buildings and ones with input)
-				// =>decreasing the score
-				// but only if we have enough free spots to built on
-				// otherwise it will slow down the expansion - small buildings would be preferred
-				if (spots_avail.at(BUILDCAPS_MEDIUM) > 40
-					&&
-					spots_avail.at(BUILDCAPS_BIG) > 20
-					&&
-					(bo.desc->get_size() == 2 ||
-					 bo.desc->get_size() == 3 ||
-					 !bo.inputs_.empty())) {
+				// Consider border with exemption of some huts
+				if (! (bo.need_trees_ || bo.need_water_ || bo.is_fisher_)) {
 						prio = recalc_with_border_range(*bf, prio);
-					}
+				} else if (bf->near_border_
+					&&
+					(bo.need_trees_ || bo.need_water_)) {
+						prio /= 2;
+				}
 
 			}  // production sites done
 			else if (bo.type == BuildingObserver::MILITARYSITE) {
@@ -1896,63 +2011,11 @@
 					continue;
 				}
 
-				prio = 0;
-
-				// calculating some sub-scores, some of them are prohibitive
-				// decreasing score if some critical materials are missing
-				// (relevant for medium and big buildings)
-				int32_t prio_for_mat_shortage = 0;
-				prio_for_mat_shortage -= bo.cnt_under_construction_ * bo.build_material_shortage_;
-				if (bf->enemy_nearby_) {
-					prio_for_mat_shortage *= 50;
-				} else {
-					prio_for_mat_shortage *= 1000;  // = prohibitive
-				}
-
-				// decreasing score if other militarysites constuctions
-				// are nearby
-				int32_t prio_for_in_constr = 0;
-				prio_for_in_constr -= 700 * (((static_cast<int32_t>(num_milit_constructionsites) - 2) < 0) ?
-									  0 :
-									  (num_milit_constructionsites - 2)) /
-						(militarysites.size() + 2);
-				if (!bf->enemy_nearby_) {
-					prio_for_in_constr *= 3;
-				}
-
-				// similarly if unmanned militarysites are nearby
-				int32_t prio_for_unmanned_nearby = 0;
-				prio_for_unmanned_nearby -= bf->military_in_constr_nearby_ + bf->military_unstationed_;
-				if (bf->enemy_nearby_) {
-					prio_for_unmanned_nearby *= 20;
-				} else {
-					prio_for_unmanned_nearby *= 1000;
-				}
-
-				// not continuing if score too low
-				if (prio_for_in_constr + prio_for_mat_shortage + prio_for_unmanned_nearby <= -1000) {
-					continue;
-				}
-
-				// is the building suitable for the situation?
-				if (expansion_mode == MilitaryStrategy::kNoNewMilitary) {
-					continue;
-				}
-
-				if (expansion_mode == MilitaryStrategy::kDefenseOnly && !bf->enemy_nearby_) {
-					continue;
-				}
-
-				if (expansion_mode == MilitaryStrategy::kResourcesOrDefense &&
-				    !(bf->unowned_mines_pots_nearby_ || bf->stones_nearby_ || bf->water_nearby_ ||
-				      (bf->distant_water_ && resource_necessity_water_needed_) || bf->enemy_nearby_)) {
-					continue;
-				}
-
+				// This is another restriction of military building - but general
 				if (bf->enemy_nearby_ && bo.fighting_type_) {
 					;
 				}  // it is ok, go on
-				else if (bf->unowned_mines_pots_nearby_ > 2 &&
+				else if (bf->unowned_mines_spots_nearby_ > 2 &&
 				         (bo.mountain_conqueror_ || bo.expansion_type_)) {
 					;
 				}  // it is ok, go on
@@ -1960,87 +2023,55 @@
 					if (bo.desc->get_size() == 2 && gametime % 2 >= 1) {
 						continue;
 					}
-					if (bo.desc->get_size() == 3 && gametime % 3 >= 1) {
+					if (bo.desc->get_size() == 3 && gametime % 4 >= 1) {
 						continue;
 					};
 				} else {
 					continue;
 				}  // the building is not suitable for situation
 
-
-				// calculating other sub scores
-				// for resources (mines, water, stones)
-				int32_t prio_for_resources = 0;
-				prio_for_resources += 2 * (bf->unowned_mines_pots_nearby_ * resource_necessity_mines_) / 100 +
-						bf->stones_nearby_ + (bf->water_nearby_ * resource_necessity_water_) / 100;
-				// special bonus due to remote water for atlanteans
-				if (resource_necessity_water_needed_) {
-					prio_for_resources += (bf->distant_water_ * resource_necessity_water_) / 100 / 3;
-				}
-				// reducing score if too little unowned land
-				if (bf->unowned_land_nearby_ < 10) {
-					prio_for_resources = prio_for_resources * bf->unowned_land_nearby_ / 10;
-				}
-				if (bf->enemy_nearby_) {  // not important when fighting enemies
-					prio_for_resources /= 5;
-				}
-
-				// for unowned land nearby
-				int32_t prio_for_unowned_land = 0;
-				if (expansion_mode == MilitaryStrategy::kExpansion ||
-				    expansion_mode == MilitaryStrategy::kPushExpansion) {
-					prio_for_unowned_land +=
-					   (bf->unowned_land_nearby_ * resource_necessity_territory_) / 100;
-				}
-
-				// for distance to nearest military sites
-				int32_t prio_for_loneliness = bf->military_loneliness_;
-				if (!bf->enemy_nearby_) {
-					prio_for_loneliness /= 10;
-				}
+				// score here is a compound of various input values
+				// usually resources in vicinity, but when enemy is nearby
+				// additional bonus is added
+				if (bf->enemy_nearby_) {
+					prio += bf->military_loneliness_ / 3;
+					prio += (20 - bf->area_military_capacity_) * 25;
+					prio -= bo.build_material_shortage_  * 50;
+					prio -= (bf->military_in_constr_nearby_ + bf->military_unstationed_) * 50;
+				} else {
+					if (bf->near_border_) {
+						prio += 50;
+						prio -= bo.build_material_shortage_  * 150;
+					} else {
+						prio -= bo.build_material_shortage_ * 500; // prohibitive
+					}
+					prio -= (bf->military_in_constr_nearby_ + bf->military_unstationed_) * 150;
+					prio += (5 - bf->own_military_sites_nearby_()) * 15;
+				}
+				prio += bf->unowned_land_nearby_ * resource_necessity_territory_ / 100;
+				prio += bf->unowned_mines_spots_nearby_ * resource_necessity_mines_ / 100;
+				prio += ((bf->unowned_mines_spots_nearby_ > 0) ? 20 : 0) *
+						resource_necessity_mines_ / 100;
+				prio += bf->stones_nearby_ / 2;
+				prio += bf->water_nearby_;
+				prio += bf->distant_water_ * resource_necessity_water_needed_ / 100;
+				prio += bf->military_loneliness_ / 10;
+				prio += bf->trees_nearby_ / 3;
+				if (bf->portspace_nearby_ == ExtendedBool::kTrue) prio += 25;
 
 				// additional score for bigger buildings
 				int32_t prio_for_size = bo.desc->get_size() - 1;
 				if (bf->enemy_nearby_) {
 					prio_for_size *= 30;
 				} else {
-					prio_for_size *= 15;
-				}
-
-				// additional score if enemy is nearby
-				int32_t prio_for_enemy = 0;
-				if (bf->enemy_nearby_) {
-					prio_for_enemy += 50;
-				}
-
-				// a boost to prevent an expansion halt
-				int32_t local_boost = 0;
-				if (expansion_mode == MilitaryStrategy::kPushExpansion) {
-					local_boost = 200;
-				}
-
-				// summing
-				prio += prio_for_mat_shortage + prio_for_in_constr + prio_for_unmanned_nearby +
-				        prio_for_resources + prio_for_unowned_land + prio_for_loneliness +
-				        prio_for_size + local_boost + prio_for_enemy;
-
-				// special bonus if a portspace is close
-				if (bf->portspace_nearby_ == ExtendedBool::kTrue) {
-					if (num_ports == 0) {
-						prio += 25;
-					} else {
-						prio += 5;
-					}
-				}
-
-				// penalty if we build lesser than possible building
-				if (bo.desc->get_size() < maxsize) {
-					prio = prio - 5;
-				}
-
-				// just generally prevent too many buildings
-				prio -= 40;
-
+					prio_for_size *= 5;
+				}
+				prio += prio_for_size;
+
+				// if place+building is not good enough
+				if (prio <= target_military_score_) {
+					continue;
+				}
 			} else if (bo.type == BuildingObserver::WAREHOUSE) {
 
 				// exclude spots on border
@@ -2074,7 +2105,7 @@
 				// But we still can built a port if it is first one
 				if (bo.is_port_ && bo.total_count() == 0 && productionsites.size() > 5 &&
 				    !bf->enemy_nearby_ && bf->is_portspace_ && seafaring_economy) {
-					prio += kDefaultPrioBoost + productionsites.size();
+					prio += productionsites.size();
 					warehouse_needed = true;
 				}
 
@@ -2103,15 +2134,11 @@
 				// but limit to 30
 				const uint16_t max_distance_considered = 30;
 				nearest_distance = std::min(nearest_distance, max_distance_considered);
-				prio += nearest_distance - 10;
+				prio += nearest_distance - 30;
 
 				// dont be close to enemies
-				if (bf->enemy_nearby_){
-					if (bo.is_port_) {
-						prio -= 10;
-					} else {
-						prio -= 40;
-					}
+				if (bf->enemy_nearby_) {
+					prio -= 40;
 				}
 
 				// being too close to a border is not good either
@@ -2122,6 +2149,8 @@
 
 			} else if (bo.type == BuildingObserver::TRAININGSITE) {
 
+				assert(!bo.build_material_shortage_);
+
 				// exclude spots on border
 				if (bf->near_border_) {
 					continue;
@@ -2158,7 +2187,7 @@
 					continue;
 				}
 
-				prio = 4 + kDefaultPrioBoost;
+				prio = 10;
 
 				// take care about borders and enemies
 				if (bf->enemy_nearby_) {
@@ -2166,7 +2195,7 @@
 				}
 
 				if (bf->unowned_land_nearby_) {
-					prio /= 2;
+					prio -= bf->unowned_land_nearby_ / 10;
 				}
 			}
 
@@ -2189,8 +2218,20 @@
 
 			// Prefer road side fields
 			prio += bf->preferred_ ? 5 : 0;
+
 			// don't waste good land for small huts
-			prio -= (maxsize - bo.desc->get_size()) * 20;
+			const bool space_stress =
+				(spots_avail.at(BUILDCAPS_MEDIUM) < 5
+				||
+				spots_avail.at(BUILDCAPS_BIG) < 5);
+
+			if (space_stress && bo.type == BuildingObserver::MILITARYSITE) {
+				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 3;
+			} else if (space_stress) {
+				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 10;
+			} else {
+				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 3;
+			}
 
 			// prefer vicinity of ports (with exemption of warehouses)
 			if (bf->port_nearby_ && bo.type == BuildingObserver::MILITARYSITE) {
@@ -2217,11 +2258,7 @@
 			for (uint32_t i = 0; i < buildings_.size() && productionsites.size() > 8; ++i) {
 				BuildingObserver& bo = buildings_.at(i);
 
-				if (!bo.buildable(*player_) || bo.type != BuildingObserver::MINE) {
-					continue;
-				}
-
-				if (bo.prohibited_till_ > gametime) {
+				if (bo.type != BuildingObserver::MINE) {
 					continue;
 				}
 
@@ -2229,27 +2266,13 @@
 					continue;
 				}
 
-				// Don't build another building of this type, if there is already
-				// one that is unoccupied_ at the moment
-				// or under construction
-				if ((bo.cnt_under_construction_ + bo.unoccupied_) > 0) {
-					continue;
-				}
-
-				if (bo.output_needed_ == ExtendedBool::kUnset) {
-					check_building_necessity(bo);
-				}
-
-				if (bo.output_needed_ == ExtendedBool::kFalse
-					&&
-				 	(bo.total_count() - bo.unconnected_) > 0) {
+				assert(bo.new_building_ != BuildingNecessity::kAllowed);
+
+				// skip if a mine is not required
+				if (!(bo.new_building_ == BuildingNecessity::kNeeded ||
+					bo.new_building_ == BuildingNecessity::kForced)) {
 						continue;
-				}
-
-				// if current one(s) are performing badly
-				if ((bo.total_count() - bo.unconnected_) >= 1 && bo.current_stats_ < 50) {
-					continue;
-				}
+					}
 
 				// this is penalty if there are existing mines too close
 				// it is treated as multiplicator for count of near mines
@@ -2265,10 +2288,7 @@
 				uint32_t bonus_score = 0;
 				if ((mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished) ==
 				    0) {
-					bonus_score = 15;
-				} else if ((mines_per_type[bo.mines_].in_construction +
-				            mines_per_type[bo.mines_].finished) == 1) {
-					bonus_score = 5;
+					bonus_score = 2 * bo.primary_priority_;
 				}
 
 				// iterating over fields
@@ -2308,7 +2328,7 @@
 					prio += bonus_score;
 
 					// applying max needed
-					prio += bo.max_needed_preciousness_ * 3;
+					prio += bo.primary_priority_;
 
 					// prefer mines in the middle of mine fields of the
 					// same type, so we add a small bonus here
@@ -2336,6 +2356,8 @@
 					// Prefer road side fields
 					prio += mf->preferred_ ? 1 : 0;
 
+					prio += bo.primary_priority_;
+
 					if (prio > proposed_priority) {
 						best_building = &bo;
 						proposed_priority = prio;
@@ -2353,12 +2375,21 @@
 		return false;
 	}
 
+	if (best_building->type == BuildingObserver::MILITARYSITE) {
+		target_military_score_ = proposed_priority;
+		player_->set_ai_data(target_military_score_, kTargetMilit);
+	}
+
+
 	// send the command to construct a new building
 	game().send_player_build(player_number(), proposed_coords, best_building->id);
 	BlockedField blocked(
 	   game().map().get_fcoords(proposed_coords), game().get_gametime() + 120000);  // two minutes
 	blocked_fields.push_back(blocked);
 
+	// resetting new_building_overdue_
+	best_building->new_building_overdue_ = 0;
+
 	// we block also nearby fields
 	// if farms and so on, for quite a long time
 	// if military sites only for short time for AI can update information on near buildable fields
@@ -2583,27 +2614,6 @@
 	return false;
 }
 
-// is productionsite needed
-// used for building new buildings or dismantle of old, intended for ones
-// that have inputs
-bool DefaultAI::is_productionsite_needed(int32_t outputs,
-										int32_t performance,
-										PerfEvaluation purpose) {
-	int32_t expected_performance = 0;
-	if (outputs > 0) {
-		expected_performance = 10 + 70 / outputs;
-	} else {
-		expected_performance = 80;
-	}
-	if (purpose == PerfEvaluation::kForDismantle) {
-		expected_performance /= 2;
-	}
-	if (performance > expected_performance) {
-		return true;
-	}
-	return false;
-}
-
 // trying to connect the flag to another one, be it from own economy
 // or other economy
 bool DefaultAI::create_shortcut_road(const Flag& flag,
@@ -2989,8 +2999,10 @@
 
 	const BuildingIndex enhancement = site.site->descr().enhancement();
 	if (connected_to_wh && enhancement != INVALID_INDEX &&
-	    ((site.bo->cnt_built_ - site.bo->unoccupied_) > 1 ||
-	    site.bo->upgrade_substitutes_)) {
+		(site.bo->cnt_built_ - site.bo->unoccupied_count_ > 1 ||
+		((site.bo->upgrade_substitutes_ || site.bo->upgrade_extends_) &&
+	    gametime > 45 * 60 * 1000 &&
+	    gametime > site.built_time_ + 20 * 60 * 1000))) {
 
 		BuildingIndex enbld = INVALID_INDEX;  // to get rid of this
 
@@ -3003,13 +3015,13 @@
 			BuildingObserver* bestbld = nullptr;
 
 			if (gametime - en_bo.construction_decision_time_ >= kBuildingMinInterval &&
-			    (en_bo.cnt_under_construction_ + en_bo.unoccupied_) == 0) {
+			    (en_bo.cnt_under_construction_ + en_bo.unoccupied_count_) == 0) {
 
 				// don't upgrade without workers
 				if (site.site->has_workers(enhancement, game())) {
 
 					// forcing first upgrade
-					if (en_bo.cnt_built_ == 0) {
+					if (en_bo.total_count() == 0) {
 						enbld = enhancement;
 						bestbld = &en_bo;
 					}
@@ -3051,6 +3063,16 @@
 	// Lumberjack / Woodcutter handling
 	if (site.bo->need_trees_) {
 
+		const uint32_t remaining_trees =
+		   map.find_immovables(Area<FCoords>(map.get_fcoords(site.site->get_position()), radius),
+		                       nullptr,
+		                       FindImmovableAttribute(MapObjectDescr::get_attribute_id("tree")));
+
+		// generally, trees_around_cutters_ = remaining_trees + 9 * trees_around_cutters_
+		// but keep in mind that trees_around_cutters_ is multiplied by 10
+		trees_around_cutters_ = (remaining_trees * 10 + 9 * trees_around_cutters_) / 10;
+		player_->set_ai_data(trees_around_cutters_, kTreesAround);
+
 		// Do not destruct the last few lumberjacks
 		if (site.bo->cnt_built_ <= site.bo->cnt_target_) {
 			return false;
@@ -3060,10 +3082,7 @@
 			return false;
 		}
 
-		const uint32_t remaining_trees =
-		   map.find_immovables(Area<FCoords>(map.get_fcoords(site.site->get_position()), radius),
-		                       nullptr,
-		                       FindImmovableAttribute(MapObjectDescr::get_attribute_id("tree")));
+
 
 		// do not dismantle if there are some trees remaining
 		if (remaining_trees > 5) {
@@ -3182,14 +3201,14 @@
 	    site.bo->space_consumer_ && !site.bo->plants_trees_) {
 
 		// if we have more buildings then target
-		if ((site.bo->cnt_built_ - site.bo->unconnected_) > site.bo->cnt_target_) {
+		if ((site.bo->cnt_built_ - site.bo->unconnected_count_) > site.bo->cnt_target_) {
 			if (site.bo->stocklevel_time < game().get_gametime() - 5 * 1000) {
 				site.bo->stocklevel_ = get_stocklevel(*site.bo);
 				site.bo->stocklevel_time = game().get_gametime();
 			}
 
 			if (site.site->get_statistics_percent() < 30 &&
-			    site.bo->stocklevel_ > 100) {  // production stats == 0%
+			    site.bo->stocklevel_ > 100) {
 				site.bo->last_dismantle_time_ = game().get_gametime();
 				flags_to_be_removed.push_back(site.site->base_flag().get_position());
 				if (connected_to_wh) {
@@ -3218,15 +3237,17 @@
 
 	// buildings with inputs_, checking if we can a dismantle some due to low performance
 	if (!site.bo->inputs_.empty() &&
-		(site.bo->cnt_built_ - site.bo->unoccupied_) >= 3 &&
+		(site.bo->cnt_built_ - site.bo->unoccupied_count_) >= 3 &&
 	    site.site->can_start_working() &&
-	    !is_productionsite_needed(site.bo->outputs_.size(),
-	    							site.site->get_statistics_percent(),
-	    							PerfEvaluation::kForDismantle) &&
-	    site.bo->current_stats_ < 30 &&              // overall statistics
+	    check_building_necessity(*site.bo, PerfEvaluation::kForDismantle, gametime)
+	    	== BuildingNecessity::kNotNeeded &&
+	    gametime - site.bo->last_dismantle_time_ > 5 * 60 * 1000 &&
+
+	    site.bo->current_stats_ > site.site->get_statistics_percent() &&              // underperformer
 	    (game().get_gametime() - site.unoccupied_till_) > 10 * 60 * 1000) {
 
 		site.bo->last_dismantle_time_ = game().get_gametime();
+
 		flags_to_be_removed.push_back(site.site->base_flag().get_position());
 		if (connected_to_wh) {
 			game().send_player_dismantle(*site.site);
@@ -3238,7 +3259,6 @@
 
 	// remaining buildings without inputs and not supporting ones (fishers only left probably and
 	// hunters)
-
 	if (site.bo->inputs_.empty() && site.bo->production_hint_ < 0 &&
 	    site.site->can_start_working() && !site.bo->space_consumer_ &&
 	    site.site->get_statistics_percent() < 10 &&
@@ -3258,6 +3278,11 @@
 	// stop/start them based on stock avaiable
 	if (site.bo->production_hint_ >= 0) {
 
+		if (!site.bo->plants_trees_) {
+			// other supporting sites, like fish breeders, gamekeepers are not dismantled at all
+			return false;
+		}
+
 		// dismantling the rangers hut, but only if we have them above a target
 		if (wood_policy_ == WoodPolicy::kDismantleRangers && site.bo->cnt_built_ > site.bo->cnt_target_) {
 
@@ -3294,8 +3319,7 @@
 				game().send_player_start_stop_building(*site.site);
 			}
 		// if not enough trees nearby, we can start them if required
-		} else if ((wood_policy_ == WoodPolicy::kStartRangers ||
-		 	wood_policy_ == WoodPolicy::kBuildRangers)
+		} else if ((wood_policy_ == WoodPolicy::kAllowRangers)
 		 	&&
 		 	site.site->is_stopped()) {
 				game().send_player_start_stop_building(*site.site);
@@ -3325,7 +3349,6 @@
 	player_ = game().get_player(player_number());
 	uint16_t ports_count = 0;
 	uint16_t shipyards_count = 0;
-	uint16_t working_shipyards_count = 0;
 	uint16_t expeditions_in_prep = 0;
 	uint16_t expeditions_in_progress = 0;
 	bool idle_shipyard_stocked = false;
@@ -3346,9 +3369,7 @@
 	for (const ProductionSiteObserver& ps_obs : productionsites) {
 		if (ps_obs.bo->is_shipyard_) {
 			shipyards_count += 1;
-			if (!ps_obs.site->is_stopped()) {
-				working_shipyards_count += 1;
-			}
+
 			// counting stocks
 			uint8_t stocked_wares = 0;
 			std::vector<WaresQueue*> const warequeues = ps_obs.site->warequeues();
@@ -3531,61 +3552,97 @@
 		return true;
 	}
 
-	// doing nothing when failed count is too low
-	if (site.no_resources_count < 4) {
+	// to avoid problems with uint underflow, we discourage considerations below
+	if (gametime < 10 * 60 * 1000) {
 		return false;
 	}
 
-	// dismantling when the failed count is too high
-	if (site.no_resources_count > 12) {
-		flags_to_be_removed.push_back(site.site->base_flag().get_position());
-		if (connected_to_wh) {
-			game().send_player_dismantle(*site.site);
-		} else {
-			game().send_player_bulldoze(*site.site);
-		}
-		site.bo->construction_decision_time_ = gametime;
-		return true;
-	}
-
-	// is output needed (compare stocked materials vs target values)
-	check_building_necessity(*site.bo);
-
-	// if we have enough of mined materials on stock - do not upgrade (yet)
-	if (site.bo->output_needed_ == ExtendedBool::kFalse) {
+	// if mine is working, doing nothing
+	if (site.no_resources_since_ > gametime - 5 * 60 * 1000) {
 		return false;
 	}
 
 	// Check whether building is enhanceable. If yes consider an upgrade.
 	const BuildingIndex enhancement = site.site->descr().enhancement();
-
-	// if no enhancement is possible
-	if (enhancement == INVALID_INDEX) {
-		// will be destroyed when no_resource_count will overflow
+	bool has_upgrade = false;
+	if (enhancement != INVALID_INDEX) {
+		if (player_->is_building_type_allowed(enhancement)) {
+			has_upgrade = true;
+		}
+	}
+
+	// every type of mine has minimal number of mines that are to be preserved
+	// (we will not dismantle even if there are no mineable resources left for this level of mine
+	// and output is not needed)
+	bool forcing_upgrade = false;
+	const uint16_t minimal_mines_count = (site.bo->built_mat_producer_) ? 2 : 1;
+	if (has_upgrade &&
+		mines_per_type[site.bo->mines_].total_count() <= minimal_mines_count) {
+		forcing_upgrade = true;
+	}
+
+
+	// dismantling a mine
+	if (!has_upgrade) { // if no upgrade, now
+		flags_to_be_removed.push_back(site.site->base_flag().get_position());
+		if (connected_to_wh) {
+			game().send_player_dismantle(*site.site);
+		} else {
+			game().send_player_bulldoze(*site.site);
+		}
+		site.bo->construction_decision_time_ = gametime;
+		return true;
+	// if having an upgrade, after half hour
+	} else if (site.no_resources_since_ < gametime - 30 * 60 * 1000 && !forcing_upgrade) {
+		flags_to_be_removed.push_back(site.site->base_flag().get_position());
+		if (connected_to_wh) {
+			game().send_player_dismantle(*site.site);
+		} else {
+			game().send_player_bulldoze(*site.site);
+		}
+		site.bo->construction_decision_time_ = gametime;
+		return true;
+	}
+
+	// if we are here, a mine is upgradeable
+
+	// if we don't need the output, and we have other buildings of the same type, the function returns
+	// and building will be dismantled later.
+	check_building_necessity(*site.bo, PerfEvaluation::kForDismantle, gametime);
+	if (site.bo->max_needed_preciousness_ == 0 && !forcing_upgrade) {
 		return false;
 	}
 
+	// again similarly, no upgrading if not connected, other parts of AI will dismantle it,
+	// or connect to a warehouse
 	if (!connected_to_wh) {
-		// no enhancement possible
+		return false;
+	}
+
+	// don't upgrade now if other mines of the same type are right now in construction
+	if (mines_per_type[site.bo->mines_].in_construction > 0) {
 		return false;
 	}
 
 	bool changed = false;
-	if (player_->is_building_type_allowed(enhancement)) {
-		// first exclude possibility there are enhancements in construction or unoccupied_
-		const BuildingDescr& bld = *tribe_->get_building_descr(enhancement);
-		BuildingObserver& en_bo = get_building_observer(bld.name().c_str());
-
-		// if it is too soon for enhancement and making sure there are no unoccupied mines
-		if (gametime - en_bo.construction_decision_time_ >= kBuildingMinInterval &&
-		    en_bo.unoccupied_ + en_bo.cnt_under_construction_ == 0) {
-
-			// now verify that there are enough workers
-			if (site.site->has_workers(enhancement, game())) {  // enhancing
-				game().send_player_enhance_building(*site.site, enhancement);
-				en_bo.construction_decision_time_ = gametime;
-				changed = true;
-			}
+
+	// first exclude possibility there are enhancements in construction or unoccupied_count_
+	const BuildingDescr& bld = *tribe_->get_building_descr(enhancement);
+	BuildingObserver& en_bo = get_building_observer(bld.name().c_str());
+
+	// if it is too soon for enhancement
+	if (gametime - en_bo.construction_decision_time_ >= kBuildingMinInterval) {
+		// now verify that there are enough workers
+		if (site.site->has_workers(enhancement, game())) {  // enhancing
+			game().send_player_enhance_building(*site.site, enhancement);
+			if (site.bo->max_needed_preciousness_ == 0) {
+				assert (mines_per_type[site.bo->mines_].total_count() <= minimal_mines_count);
+			}
+			if (mines_per_type[site.bo->mines_].total_count() > minimal_mines_count) {
+				assert(site.bo->max_needed_preciousness_ > 0);
+			}
+			en_bo.construction_decision_time_ = gametime;
+			changed = true;
 		}
 	}
 
@@ -3608,12 +3665,18 @@
 	return count;
 }
 
-// goes over all outputs of a building and compare stocked material with
-// target values. The result is yes/no and some scores
-void DefaultAI::check_building_necessity(BuildingObserver& bo) {
-	// iterate over outputs of building, counts warehoused stock
-	// and deciding if enough
-	bo.max_preciousness = 0;
+// this receives an building observer and have to decide if new/one of
+// current buildings of this type is needed
+// This is core of construct_building() function
+// This is run once when construct_building() is run, or when considering
+// dismantle
+BuildingNecessity DefaultAI::check_building_necessity(BuildingObserver& bo,
+										const PerfEvaluation purpose,
+										const uint32_t gametime) {
+
+	// First we iterate over outputs of building, count warehoused stock
+	// and deciding if we have enough on stock (in warehouses)
+	bo.max_preciousness_ = 0;
 	bo.max_needed_preciousness_ = 0;
 
 	for (uint32_t m = 0; m < bo.outputs_.size(); ++m) {
@@ -3624,6 +3687,9 @@
 		target = std::max<uint16_t>(target, 1);
 
 		uint16_t preciousness = wares.at(bo.outputs_.at(m)).preciousness_;
+		if (preciousness < 1) { // it seems there are wares with 0 preciousness
+			preciousness = 1; // (no entry in conf files?). But we need positive value here
+		}
 
 		if (get_warehoused_stock(wt) < target) {
 			if (bo.max_needed_preciousness_ < preciousness) {
@@ -3631,16 +3697,253 @@
 			}
 		}
 
-		if (bo.max_preciousness < preciousness) {
-			bo.max_preciousness = preciousness;
+		if (bo.max_preciousness_ < preciousness) {
+			bo.max_preciousness_ = preciousness;
 		}
 	}
 
-	// here we decide if the building is needed
+	if (!bo.outputs_.empty()) {
+		assert (bo.max_preciousness_ > 0);
+	}
+
+	// positive max_needed_preciousness_ says a building type is needed
+	// here we increase of reset the counter
+	// the counter is added to score when considering new building
 	if (bo.max_needed_preciousness_ > 0) {
-		bo.output_needed_ = ExtendedBool::kTrue;
-	} else {
-		bo.output_needed_ = ExtendedBool::kFalse;
+		bo.new_building_overdue_ += 1;
+	} else {
+		bo.new_building_overdue_ = 0;
+	}
+
+	// This flag is to be used when buildig is forced. AI will not build another building when
+	// a substitution exists. F.e. mines or pairs like tavern-inn
+	// To skip unnecessary calculation, we calculate this only if we have 0 count of the buildings
+	bool has_substitution_building = false;
+	if (bo.total_count() == 0 && bo.upgrade_substitutes_ && bo.type == BuildingObserver::PRODUCTIONSITE) {
+		const BuildingIndex enhancement = bo.desc->enhancement();
+		BuildingObserver& en_bo
+			= get_building_observer(tribe_->get_building_descr(enhancement)->name().c_str());
+		if (en_bo.total_count() > 0) {
+			has_substitution_building = true;
+		}
+	}
+	if (bo.total_count() == 0 && bo.type == BuildingObserver::MINE) {
+		if (mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished > 0) {
+			has_substitution_building = true;
+		}
+	}
+
+	// This function is going to say if a building is needed. But there is a 'new_buildings_stop_'
+	// flag that should be obeyed, but sometimes can be ignored.
+	// So we can have two types of needed: kNeeded and KNeededPending
+	// below we define which one will be returned if building is 'needed'
+	BuildingNecessity needed_type = BuildingNecessity::kNeeded;
+	if (new_buildings_stop_) {
+		needed_type = BuildingNecessity::kNeededPending;
+		if (gametime < 15 * 60 * 1000) {
+			; // no exemption here within first 15 minutes
+		} else if (gametime < 25 * 60 * 1000) { // exemption after 15 minutes - 1 building allowed
+
+			if (bo.type == BuildingObserver::MINE) {
+				if (mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished == 0) {
+					needed_type = BuildingNecessity::kNeeded;
+				}
+			}
+			if (bo.type == BuildingObserver::PRODUCTIONSITE) {
+				if (bo.built_mat_producer_ || bo.max_needed_preciousness_ >= 10) {
+					if (bo.total_count() == 0) {
+						needed_type = BuildingNecessity::kNeeded;
+					}
+				}
+			}
+		} else { // exemption after 25 minutes - 2 buildings allowed
+			if (bo.type == BuildingObserver::MINE) {
+				if (mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished <= 1) {
+					needed_type = BuildingNecessity::kNeeded;
+				}
+			}
+			if (bo.type == BuildingObserver::PRODUCTIONSITE) {
+				if (bo.built_mat_producer_ || bo.max_needed_preciousness_ >= 10) {
+					if (bo.total_count() <= 1) {
+						needed_type = BuildingNecessity::kNeeded;
+					}
+				}
+			}
+		}
+	}
+
+	// And finally the 'core' of this function
+	// First deal with construction of new sites
+	if (purpose == PerfEvaluation::kForConstruction) {
+		if (bo.forced_after_ < gametime && bo.total_count() == 0 && !has_substitution_building) {
+			bo.max_needed_preciousness_ = bo.max_preciousness_;
+			return BuildingNecessity::kForced;
+		} else if (bo.prohibited_till_ > gametime) {
+			return BuildingNecessity::kNotNeeded;
+		} else if (bo.is_hunter_ || bo.is_fisher_) {
+
+			if (bo.max_needed_preciousness_ == 0) {
+				return BuildingNecessity::kNotNeeded;
+			} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0) {
+				return BuildingNecessity::kNotNeeded;
+			} else if (bo.total_count() > 0 && new_buildings_stop_) {
+				return BuildingNecessity::kNotNeeded;
+			} else {
+				return BuildingNecessity::kNeeded;
+			}
+		} else if (bo.need_trees_) {
+			if (bo.total_count() > 1 && (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0)) {
+				return BuildingNecessity::kNotNeeded;
+			}
+			bo.cnt_target_ =
+					   3 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 20;
+
+			// for case the wood is not needed yet, to avoid inconsistency later on
+			bo.max_needed_preciousness_ = bo.max_preciousness_;
+
+			if (bo.total_count() < bo.cnt_target_) {
+				return BuildingNecessity::kNeeded;
+			} else {
+				return BuildingNecessity::kAllowed;
+			}
+		} else if (bo.plants_trees_) {
+
+			bo.cnt_target_ =
+				   2 +
+				   static_cast<int32_t>(mines_.size() + productionsites.size()) / 40;
+			if (wood_policy_ != WoodPolicy::kAllowRangers) {
+				return BuildingNecessity::kNotNeeded;
+			}
+			// 150 corresponds to 15 trees
+			if (trees_around_cutters_ < 150) {
+				bo.cnt_target_ *= 4;
+			}
+			if (bo.total_count() > 1 && (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0)) {
+				return BuildingNecessity::kNotNeeded;
+			} else if (bo.total_count() > bo.cnt_target_) {
+				return BuildingNecessity::kNotNeeded;
+			}
+			return BuildingNecessity::kNeeded;
+		} else if (bo.need_stones_ && bo.cnt_under_construction_ + bo.unoccupied_count_ == 0) {
+			bo.max_needed_preciousness_ = bo.max_preciousness_; // even when stones are not needed
+			return BuildingNecessity::kAllowed;
+		} else if (bo.production_hint_ >= 0 && bo.cnt_under_construction_ + bo.unoccupied_count_ == 0) {
+			return BuildingNecessity::kAllowed;
+		} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0 && bo.max_needed_preciousness_ < 10) {
+			return BuildingNecessity::kNotNeeded;
+		} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0 && gametime < 30 * 60 * 1000) {
+			return BuildingNecessity::kNotNeeded;
+		} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 1) {
+			return BuildingNecessity::kNotNeeded; // for preciousness>=10 and after 30 min
+		} else if (bo.type == BuildingObserver::MINE) {
+			if ((mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished) == 0) {
+				// unless a mine is prohibited, we want to have at least one of the kind
+				bo.max_needed_preciousness_ = bo.max_preciousness_;
+				return BuildingNecessity::kNeeded;
+			} else if (((mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished)
+				==
+				1) && bo.built_mat_producer_) {
+					bo.max_needed_preciousness_ = bo.max_preciousness_;
+					return BuildingNecessity::kNeeded;
+			}
+			if (bo.max_needed_preciousness_ == 0) {
+				return BuildingNecessity::kNotNeeded;
+			}
+			if (bo.total_count() - bo.unconnected_count_ >= 1 || bo.current_stats_ < 20) {
+				return BuildingNecessity::kNotNeeded;
+			}
+			return needed_type;
+		} if (bo.max_needed_preciousness_ > 0) {
+			if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0) {
+				assert (bo.cnt_under_construction_ + bo.unoccupied_count_ == 1);
+				assert (bo.max_needed_preciousness_ >= 10 || bo.built_mat_producer_);
+				assert (gametime >= 25 * 60 * 1000);
+			}
+
+			// First 'if' is special support for hardwood producers (to have 2 of them)
+			if (bo.built_mat_producer_ && bo.total_count() <= 1 && bo.current_stats_ > 10) {
+				return BuildingNecessity::kNeeded;
+			} else if (bo.inputs_.empty()) {
+				return needed_type;
+			} else if (bo.total_count() == 0) {
+				return needed_type;
+			} else if (bo.current_stats_ > 10 + 70 / bo.outputs_.size()) {
+				return needed_type;
+			} else {
+				return BuildingNecessity::kNotNeeded;
+			}
+		} else if (bo.is_shipyard_) {
+			return BuildingNecessity::kAllowed;
+		} else  if (bo.max_needed_preciousness_ == 0) {
+			return BuildingNecessity::kNotNeeded;
+		} else {
+			return BuildingNecessity::kNotNeeded;
+		}
+	} else if (purpose == PerfEvaluation::kForDismantle) { // now for dismantling
+		// never dismantle last building (a care should be taken elsewhere)
+		assert (bo.total_count() > 0);
+		if (bo.total_count() == 1) {
+			return BuildingNecessity::kNeeded;
+		} else if (bo.max_preciousness_ >= 10 && bo.total_count() == 2) {
+			return BuildingNecessity::kNeeded;
+		} else if (bo.current_stats_ > (10 + 70 / bo.outputs_.size()) / 2) {
+			return BuildingNecessity::kNeeded;
+		} else {
+			return BuildingNecessity::kNotNeeded;
+		}
+	} else {
+		// impossible but still
+		assert(false);
+	}
+}
+
+// Now we can prohibit some militarysites, based on size, the goal is not to
+// exhaust AI resources on the beginning of the game
+// We count bigger buildings, medium ones get 1 points, big ones 2 points
+// and we force some proportion to the number of military sites
+// sidenote: function can return kNotNeeded, but it means 'not allowed'
+BuildingNecessity DefaultAI::check_building_necessity(const uint8_t size,
+										const uint32_t gametime) {
+
+	assert (militarysites.size() ==  msites_built());
+	// logically size of militarysite must in between 1 and 3 (including)
+	assert (size >= BaseImmovable::SMALL && size <= BaseImmovable::BIG);
+
+	if (size == BaseImmovable::SMALL) { // this function is intended for medium and bigger sites
+		return BuildingNecessity::kAllowed;
+	}
+
+	uint32_t const big_buildings_score
+		= msites_per_size[2].in_construction
+		+ msites_per_size[2].finished
+		+ msites_per_size[3].in_construction * 2
+		+ msites_per_size[3].finished * 2;
+
+	const uint32_t msites_total = msites_built() + msites_in_constr();
+
+	// this is final proportion of big_buildings_score / msites_total
+	// two exeptions:
+	// if enemy nearby - can be higher
+	// for early game - must be lower
+	uint32_t limit = (msites_built() + msites_in_constr()) * 2 / 3;
+
+	// exemption first
+	if (militarysites.size() > 3 && vacant_mil_positions_ == 0 && msites_in_constr() == 0) {
+		return BuildingNecessity::kAllowed; // it seems the expansion is stuck so we allow big buildings
+	} else if (gametime > enemy_last_seen_ &&
+		gametime < enemy_last_seen_ + 30 * 60 * 1000 &&
+		mines_.size() > 2) { // if enemies were nearby in last 30 minutes
+			// we allow more big buidings
+			limit *= 2;
+	} else if (msites_total < ai_personality_early_militarysites) {
+		// for the beginning of the game (first 30 military sites)
+		limit = limit * msites_total / ai_personality_early_militarysites;
+	}
+
+	if (big_buildings_score + size - 1  > limit) {
+		return BuildingNecessity::kNotNeeded;
+	} else {
+		return BuildingNecessity::kAllowed;
 	}
 }
 
@@ -3838,17 +4141,6 @@
 
 	// just to be sure the value is reset
 	taskDue[ScheduleTasks::kCheckMilitarysites] = gametime + 4 * 1000;  // 4 seconds is really fine
-	// even if there are no finished & attended military sites, probably there are ones just in
-	// construction
-	unstationed_milit_buildings_ = 0;
-
-	for (std::list<MilitarySiteObserver>::iterator it = militarysites.begin();
-	     it != militarysites.end();
-	     ++it) {
-		if (it->site->stationed_soldiers().size() == 0) {
-			unstationed_milit_buildings_ += 1;
-		}
-	}
 
 	// Only useable, if defaultAI owns at least one militarysite
 	if (militarysites.empty()) {
@@ -3899,7 +4191,7 @@
 				score += (bf.area_military_capacity_ > 6);
 				score += (bf.area_military_capacity_ > 22);
 				score += (bf.area_military_presence_ > 4);
-				score += (bf.military_loneliness_ < 180);
+				score += (bf.military_loneliness_ < (180 + ai_personality_military_loneliness_));
 				score += (bf.military_stationed_ > 2);
 				score -= size_penalty;
 				score += ((bf.unowned_land_nearby_ + allyOwnedFields) < 10);
@@ -3965,7 +4257,7 @@
 /**
  * This function takes care about the unowned and opposing territory and
  * recalculates the priority for non-military buildings
- * The goal is to minimize losses when teritory is lost
+ * The goal is to minimize losses when territory is lost
  *
  * \arg bf   = BuildableField to be checked
  * \arg prio = priority until now.
@@ -3979,85 +4271,26 @@
 		return prio;
 	}
 
-	// in unowned teritory, decreasing to 2/3
-	if (bf.unowned_land_nearby_ > 15) {
-		prio *= 2;
-		prio /= 3;
-	}
-
-	// to preserve positive score
-	if (prio == 0) {
-		prio = 1;
-	}
-
-	// Further decrease the score if enemy nearby
+	if (bf.enemy_nearby_ || bf.near_border_) {
+		prio /= 2;
+	}
+
+	// if unowned territory nearby
+	prio -= bf.unowned_land_nearby_ / 4;
+
+	// further decrease the score if enemy nearby
 	if (bf.enemy_nearby_) {
-		prio /= 2;
-	}
-
-	return prio;
-}
-
-/**
- * calculates how much a productionsite of type \arg bo is needed inside it's
- * economy. \arg prio is initial value for this calculation
- *
- * \returns the calculated priority
- */
-int32_t DefaultAI::calculate_need_for_ps(BuildingObserver& bo, int32_t prio) {
-	// some randomness to avoid that defaultAI is building always
-	// the same (always == another game but same map with
-	// defaultAI on same coords)
-	prio += time(nullptr) % 3 - 1;
-
-	// check if current economy can supply enough material for
-	// production.
-	for (uint32_t k = 0; k < bo.inputs_.size(); ++k) {
-		prio += 2 * wares.at(bo.inputs_.at(k)).producers_;
-		prio -= wares.at(bo.inputs_.at(k)).consumers_;
-	}
-
-	if (bo.inputs_.empty()) {
-		prio += 4;
-	}
-
-	int32_t output_prio = 0;
-
-	for (uint32_t k = 0; k < bo.outputs_.size(); ++k) {
-		WareObserver& wo = wares.at(bo.outputs_.at(k));
-
-		if (wo.consumers_ > 0) {
-			output_prio += wo.preciousness_;
-			output_prio += wo.consumers_ * 2;
-			output_prio -= wo.producers_ * 2;
-
-			if (bo.total_count() == 0) {
-				output_prio += 10;  // add a big bonus
-			}
-		}
-	}
-
-	if (bo.outputs_.size() > 1) {
-		output_prio =
-		   static_cast<int32_t>(ceil(output_prio / sqrt(static_cast<double>(bo.outputs_.size()))));
-	}
-
-	prio += 2 * output_prio;
-
-	// If building consumes some wares, multiply with current statistics of all
-	// other buildings of this type to avoid constructing buildings where already
-	// some are running on low resources.
-	// Else at least add a part of the stats t the calculation.
-	if (!bo.inputs_.empty()) {
-		prio *= bo.current_stats_;
-		prio /= 100;
-	} else {
-		prio = ((prio * bo.current_stats_) / 100) + (prio / 2);
-	}
-
-	return prio;
-}
-
+		prio -= 10;
+	}
+
+	// and if close (up to 2 fields away) from border
+	if (bf.near_border_) {
+		prio -= 10;
+	}
+
+	return prio;
+}
+// for buildable field, it considers effect of building of type bo on position coords
 void DefaultAI::consider_productionsite_influence(BuildableField& field,
                                                   Coords coords,
                                                   const BuildingObserver& bo) {
@@ -4073,6 +4306,14 @@
 	for (size_t i = 0; i < bo.outputs_.size(); ++i) {
 		++field.producers_nearby_.at(bo.outputs_.at(i));
 	}
+
+	if (bo.production_hint_ >= 0) {
+		++field.supporters_nearby_.at(bo.production_hint_);
+	}
+
+	if (bo.plants_trees_ >= 0) {
+		++field.rangers_nearby_;
+	}
 }
 
 /// \returns the economy observer containing \arg economy
@@ -4163,10 +4404,14 @@
 // this is called when a mine reports "out of resources"
 void DefaultAI::out_of_resources_site(const ProductionSite& site) {
 
+	const uint32_t gametime = game().get_gametime();
+
 	// we must identify which mine matches the productionsite a note reffers to
 	for (std::list<ProductionSiteObserver>::iterator i = mines_.begin(); i != mines_.end(); ++i)
 		if (i->site == &site) {
-			i->no_resources_count += 1;
+			if (i->no_resources_since_ > gametime) {
+				i->no_resources_since_ = gametime;
+			}
 			break;
 		}
 }
@@ -4190,9 +4435,9 @@
 	player_number());
 }
 
-// walk and search for teritorry controlled by other player
+// walk and search for territory controlled by other player
 // usually scanning radius is enough but sometimes we must walk to
-// verify that an enemy teritory is really accessible by land
+// verify that an enemy territory is really accessible by land
 bool DefaultAI::other_player_accessible(const uint32_t max_distance,
                                         int32_t* tested_fields,
                                         uint16_t* mineable_fields_count,
@@ -4227,9 +4472,9 @@
 			continue;
 		}
 
-		// sometimes we search for any owned teritory (f.e. when considering
+		// sometimes we search for any owned territory (f.e. when considering
 		// a port location), but when testing (starting from) own military building
-		// we must ignore own teritory, of course
+		// we must ignore own territory, of course
 		if (f->get_owned_by() > 0) {
 
 			// if field is owned by anybody
@@ -4385,8 +4630,9 @@
 		}
 
 		// decreasing colony_scan_area_
-		if (colony_scan_area_ > 15 && gametime % 10 == 0) {
+		if (colony_scan_area_ > 10 && gametime % 10 == 0) {
 			colony_scan_area_ -= 1;
+			player_->set_ai_data(colony_scan_area_, kColonyScan);
 		}
 	}
 
@@ -4452,12 +4698,11 @@
 		BuildingObserver& target_bo =
 		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
 		++target_bo.cnt_under_construction_;
-		++num_constructionsites_;
 		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
 			++num_prod_constructionsites;
 		}
 		if (target_bo.type == BuildingObserver::MILITARYSITE) {
-			++num_milit_constructionsites;
+			msites_per_size[target_bo.desc->get_size()].in_construction += 1;
 		}
 		if (target_bo.type == BuildingObserver::MINE) {
 			mines_per_type[target_bo.mines_].in_construction += 1;
@@ -4480,10 +4725,12 @@
 			productionsites.push_back(ProductionSiteObserver());
 			productionsites.back().site = &dynamic_cast<ProductionSite&>(b);
 			productionsites.back().bo = &bo;
+			productionsites.back().bo->new_building_overdue_ = 0;
 			productionsites.back().built_time_ = game().get_gametime();
 			productionsites.back().unoccupied_till_ = game().get_gametime();
 			productionsites.back().stats_zero_ = 0;
-			productionsites.back().no_resources_count = 0;
+			productionsites.back().no_resources_since_ =  std::numeric_limits<uint32_t>::max();
+			productionsites.back().bo->unoccupied_count_ += 1;
 			if (bo.is_shipyard_) {
 				marineTaskQueue_.push_back(kStopShipyard);
 				marineTaskQueue_.push_back(kReprioritize);
@@ -4499,6 +4746,8 @@
 			mines_.back().site = &dynamic_cast<ProductionSite&>(b);
 			mines_.back().bo = &bo;
 			mines_.back().built_time_ = game().get_gametime();
+			mines_.back().no_resources_since_ =  std::numeric_limits<uint32_t>::max();
+			mines_.back().bo->unoccupied_count_ += 1;
 
 			for (uint32_t i = 0; i < bo.outputs_.size(); ++i)
 				++wares.at(bo.outputs_.at(i)).producers_;
@@ -4514,6 +4763,8 @@
 			militarysites.back().bo = &bo;
 			militarysites.back().checks = bo.desc->get_size();
 			militarysites.back().enemies_nearby_ = true;
+			msites_per_size[bo.desc->get_size()].finished += 1;
+			vacant_mil_positions_ += 2; // at least some indication that there are vacant positions
 
 		} else if (bo.type == BuildingObserver::TRAININGSITE) {
 			ts_without_trainers_ += 1;
@@ -4526,6 +4777,7 @@
 			if (bo.trainingsite_type_ == TrainingSiteType::kAdvanced) {
 				ts_advanced_count_ += 1;
 			}
+			vacant_mil_positions_ += 8; // at least some indication that there are vacant positions
 
 		} else if (bo.type == BuildingObserver::WAREHOUSE) {
 			++numof_warehouses_;
@@ -4538,7 +4790,7 @@
 				// unblock nearby fields, might be used for other buildings...
 				Map& map = game().map();
 				MapRegion<Area<FCoords>> mr(
-				   map, Area<FCoords>(map.get_fcoords(warehousesites.back().site->get_position()), 4));
+				   map, Area<FCoords>(map.get_fcoords(warehousesites.back().site->get_position()), 3));
 				do {
 					const int32_t hash = coords_hash(map.get_fcoords(*(mr.location().field)));
 					if (port_reserved_coords.count(hash) > 0)
@@ -4558,12 +4810,11 @@
 		BuildingObserver& target_bo =
 		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
 		--target_bo.cnt_under_construction_;
-		--num_constructionsites_;
 		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
 			--num_prod_constructionsites;
 		}
 		if (target_bo.type == BuildingObserver::MILITARYSITE) {
-			--num_milit_constructionsites;
+			msites_per_size[target_bo.desc->get_size()].in_construction -= 1;
 		}
 		if (target_bo.type == BuildingObserver::MINE) {
 			mines_per_type[target_bo.mines_].in_construction -= 1;
@@ -4580,6 +4831,18 @@
 	} else {
 		--bo.cnt_built_;
 
+		// we are not able to reliably identify if lost building is counted in
+		// unconnected or unoccupied count, but we must adjust the value to
+		// avoid inconsistency
+		const uint32_t cnt_built = bo.cnt_built_;
+		if (bo.unconnected_count_ > cnt_built) {
+			bo.unconnected_count_ = cnt_built;
+		}
+		if (bo.unoccupied_count_ > cnt_built) {
+			bo.unoccupied_count_ = cnt_built;
+		}
+
+
 		if (bo.type == BuildingObserver::PRODUCTIONSITE) {
 
 			for (std::list<ProductionSiteObserver>::iterator i = productionsites.begin();
@@ -4597,6 +4860,7 @@
 			for (uint32_t i = 0; i < bo.inputs_.size(); ++i) {
 				--wares.at(bo.inputs_.at(i)).consumers_;
 			}
+
 		} else if (bo.type == BuildingObserver::MINE) {
 			for (std::list<ProductionSiteObserver>::iterator i = mines_.begin(); i != mines_.end();
 			     ++i) {
@@ -4617,6 +4881,7 @@
 			mines_per_type[bo.mines_].finished -= 1;
 
 		} else if (bo.type == BuildingObserver::MILITARYSITE) {
+			msites_per_size[bo.desc->get_size()].finished -= 1;
 
 			for (std::list<MilitarySiteObserver>::iterator i = militarysites.begin();
 			     i != militarysites.end();
@@ -4787,6 +5052,21 @@
 		treshold_ratio = 120;
 	}
 
+	// let's say a 'campaign' is a series of attacks,
+	// if there is more then 3 minutes without attack after last
+	// attack, then a campaign is over.
+	// To start new campaign (=attack again), our strenth must exceed
+	// target values (calculated above) by some treshold =
+	// ai_personality_attack_margin_
+	// Once a new campaign started we will fight until
+	// we get below above treshold or there will be 3
+	// minutes gap since last attack
+	// note - AI is not aware of duration of attacks
+	// everywhere we consider time when an attack is ordered.
+	if (last_attack_time_ < gametime - kCampaignDuration) {
+		treshold_ratio += ai_personality_attack_margin_;
+	}
+
 	uint32_t my_power = 0;
 	try {
 		my_power = genstats.at(pn - 1).miltary_strength.back();
@@ -5098,7 +5378,11 @@
 	}
 
 	game().send_player_enemyflagaction(*flag, player_number(), attackers);
+
+	last_attack_time_ = gametime;
+	player_->set_ai_data(last_attack_time_, kLastAttack);
 	last_attacked_player_ = flag->owner().player_number();
+	player_->set_ai_data(static_cast<int16_t>(last_attacked_player_), kAttacker);
 
 	return true;
 }
@@ -5160,6 +5444,40 @@
 	return DueTask;
 }
 
+// following two functions count mines of the same type (same output,
+// all levels)
+uint32_t DefaultAI::mines_in_constr() const {
+	uint32_t count = 0;
+	for (const std::pair<const int, MineTypesObserver> m : mines_per_type) {
+		count += m.second.in_construction;
+	}
+	return count;
+}
+uint32_t DefaultAI::mines_built() const{
+	uint32_t count = 0;
+	for (const std::pair<const int, MineTypesObserver> m : mines_per_type) {
+		count += m.second.finished;
+	}
+	return count;
+}
+
+// following two functions count militarysites of the same size
+uint32_t DefaultAI::msites_in_constr() const {
+	uint32_t count = 0;
+	for (const std::pair<const int, MilitarySiteSizeObserver> m : msites_per_size) {
+		count += m.second.in_construction;
+	}
+	return count;
+}
+uint32_t DefaultAI::msites_built() const{
+	uint32_t count = 0;
+	for (const std::pair<const int, MilitarySiteSizeObserver> m : msites_per_size) {
+		count += m.second.finished;
+	}
+	return count;
+}
+
+
 // This prints some basic statistics during a game to the command line -
 // missing materials and counts of different types of buildings.
 // The main purpose of this is when a game creator needs to finetune a map
@@ -5216,3 +5534,22 @@
 	    num_ports,
 	    summary.c_str());
 }
+
+template<typename T>
+	void DefaultAI::check_range(T value, T bottom_range, T upper_range, const char* value_name) {
+	if (value < bottom_range || value > upper_range) {
+		log(" %d: unexpected value for %s: %d\n",
+		player_number(),
+		value_name,
+		value);
+	}
+}
+
+template<typename T> void DefaultAI::check_range(T value, T upper_range, const char* value_name) {
+	if (value > upper_range) {
+		log(" %d: unexpected value for %s: %d\n",
+		player_number(),
+		value_name,
+		value);
+	}
+}

=== modified file 'src/ai/defaultai.h'
--- src/ai/defaultai.h	2015-09-04 06:16:58 +0000
+++ src/ai/defaultai.h	2015-10-24 18:56:46 +0000
@@ -82,7 +82,7 @@
 	};
 
 	enum class WalkSearch : uint8_t {kAnyPlayer, kOtherPlayers, kEnemy};
-	enum class WoodPolicy : uint8_t {kDismantleRangers, kStopRangers, kStartRangers, kBuildRangers};
+	enum class WoodPolicy : uint8_t {kDismantleRangers, kStopRangers, kAllowRangers};
 	enum class NewShip : uint8_t {kBuilt, kFoundOnLoad};
 	enum class PerfEvaluation : uint8_t {kForConstruction, kForDismantle};
 	enum class ScheduleTasks : uint8_t {
@@ -105,13 +105,6 @@
 		kCountMilitaryVacant,
 		kCheckEnemySites
 	};
-	enum class MilitaryStrategy : uint8_t {
-		kNoNewMilitary,
-		kDefenseOnly,
-		kResourcesOrDefense,
-		kExpansion,
-		kPushExpansion
-	};
 	enum class Tribes : uint8_t {
 		kNone,
 		kBarbarians,
@@ -119,6 +112,7 @@
 		kEmpire
 	};
 
+
 	/// Implementation for Aggressive
 	struct AggressiveImpl : public ComputerPlayer::Implementation {
 		AggressiveImpl() {
@@ -169,7 +163,12 @@
 
 	void update_productionsite_stats(uint32_t);
 
-	void check_building_necessity(BuildingObserver& bo);
+	// for productionsites
+	Widelands::BuildingNecessity check_building_necessity
+		(BuildingObserver& bo, PerfEvaluation purpose, uint32_t);
+	// for militarysites (overloading the function)
+	Widelands::BuildingNecessity check_building_necessity
+		(uint8_t, uint32_t);
 
 	ScheduleTasks get_oldest_task(uint32_t);
 
@@ -225,7 +224,6 @@
 	                             const WalkSearch type);
 
 	int32_t recalc_with_border_range(const BuildableField&, int32_t);
-	int32_t calculate_need_for_ps(BuildingObserver&, int32_t);
 
 	void
 	consider_productionsite_influence(BuildableField&, Widelands::Coords, const BuildingObserver&);
@@ -243,16 +241,16 @@
 	void expedition_management(ShipObserver&);
 	void out_of_resources_site(const Widelands::ProductionSite&);
 	void soldier_trained(const Widelands::TrainingSite&);
-	bool is_productionsite_needed(int32_t outputs,
-										int32_t performance,
-										PerfEvaluation purpose);
 
 	bool check_supply(const BuildingObserver&);
 
-	// bool consider_attack(int32_t);
-
 	void print_land_stats();
 
+	//checks whether first value is in range, or lesser then...
+	template<typename T> void check_range(const T, const  T, const  T, const char *);
+	template<typename T> void check_range(const T, const  T, const char *);
+
+
 private:
 	// Variables of default AI
 	uint8_t type_;
@@ -264,15 +262,18 @@
 	Widelands::TribeDescr const* tribe_;
 
 	std::vector<BuildingObserver> buildings_;
-	uint32_t num_constructionsites_;
-	uint32_t num_milit_constructionsites;
 	uint32_t num_prod_constructionsites;
 	uint32_t num_ports;
 
-	uint16_t last_attacked_player_;
+	int16_t last_attacked_player_;
+	uint32_t last_attack_time_;
 	// check ms in this interval - will auto-adjust
 	uint32_t enemysites_check_delay_;
 
+	// helping scores for building new military sites
+	int32_t target_military_score_;
+	int32_t least_military_score_;
+
 	WoodPolicy wood_policy_;
 
 	std::list<Widelands::FCoords> unusable_fields;
@@ -294,6 +295,13 @@
 	std::map<uint32_t, EnemySiteObserver> enemy_sites;
 	// it will map mined material to observer
 	std::map<int32_t, MineTypesObserver> mines_per_type;
+	// returns count of mines of the same type (output)
+	uint32_t mines_in_constr() const;
+	uint32_t mines_built() const;
+	std::map<int32_t, MilitarySiteSizeObserver> msites_per_size;
+	// returns count of militarysites
+	uint32_t msites_in_constr() const;
+	uint32_t msites_built() const;
 
 	std::vector<WareObserver> wares;
 
@@ -315,8 +323,9 @@
 	int32_t resource_necessity_water_;
 	bool resource_necessity_water_needed_;  // unless atlanteans
 
-	uint16_t unstationed_milit_buildings_;  // counts empty military buildings (ones where no soldier
-	                                        // is belogning to)
+	// average count of trees around cutters
+	uint32_t trees_around_cutters_;
+
 	uint16_t military_last_dismantle_;
 	uint32_t military_last_build_;  // sometimes expansions just stops, this is time of last military
 	                                // building build
@@ -337,12 +346,15 @@
 	// the purpose is to print out a warning that the game is pacing too fast
 	int32_t scheduler_delay_counter_;
 
+	int16_t ai_personality_military_loneliness_;
+	uint32_t ai_personality_attack_margin_;
+	int32_t ai_personality_wood_difference_;
+	uint32_t ai_productionsites_ratio_;
+	uint32_t ai_personality_early_militarysites;
+
 	// this is a bunch of patterns that have to identify weapons and armors for input queues of trainingsites
 	std::vector<std::string> const armors_and_weapons =
 		{"ax", "lance", "armor", "helm", "lance", "trident", "tabard", "shield", "mask"};
-	// some buildings can be upgraded even when they are only one
-	// now only microbrewery get this special treatment
-	const char* preferred_upgrade[1] = {"micro-brewery"};
 
 	enum {kReprioritize, kStopShipyard, kStapShipyard};
 

=== modified file 'src/game_io/game_player_info_packet.cc'
--- src/game_io/game_player_info_packet.cc	2014-10-12 07:35:42 +0000
+++ src/game_io/game_player_info_packet.cc	2015-10-24 18:56:46 +0000
@@ -30,7 +30,7 @@
 
 namespace Widelands {
 
-constexpr uint16_t kCurrentPacketVersion = 16;
+constexpr uint16_t kCurrentPacketVersion = 17;
 
 void GamePlayerInfoPacket::read
 	(FileSystem & fs, Game & game, MapObjectLoader *) {
@@ -68,6 +68,11 @@
 					player.m_msites_defeated     = fr.unsigned_32();
 					player.m_civil_blds_lost     = fr.unsigned_32();
 					player.m_civil_blds_defeated = fr.unsigned_32();
+					for (int32_t ai_pos = 0; ai_pos < kAIDataSize; ++ai_pos) {
+						player.m_ai_data_int32[ai_pos] = fr.signed_32();
+						player.m_ai_data_uint32[ai_pos] = fr.unsigned_32();
+						player.m_ai_data_int16[ai_pos] = fr.unsigned_16();
+					}
 				}
 			}
 			game.read_statistics(fr);
@@ -115,6 +120,11 @@
 		fw.unsigned_32(plr->msites_defeated    ());
 		fw.unsigned_32(plr->civil_blds_lost    ());
 		fw.unsigned_32(plr->civil_blds_defeated());
+		for (int32_t ai_pos = 0; ai_pos < kAIDataSize; ++ai_pos) {
+			fw.signed_32(plr->m_ai_data_int32[ai_pos]);
+			fw.unsigned_32(plr->m_ai_data_uint32[ai_pos]);
+			fw.unsigned_16(plr->m_ai_data_int16[ai_pos]);
+		}
 	} else
 		fw.unsigned_8(0); //  Player is NOT in game.
 

=== modified file 'src/logic/player.cc'
--- src/logic/player.cc	2015-10-04 18:30:05 +0000
+++ src/logic/player.cc	2015-10-24 18:56:46 +0000
@@ -166,7 +166,11 @@
 	m_current_consumed_statistics(tribe_descr.get_nrwares    ()),
 	m_ware_productions  (tribe_descr.get_nrwares    ()),
 	m_ware_consumptions  (tribe_descr.get_nrwares    ()),
-	m_ware_stocks  (tribe_descr.get_nrwares          ())
+	m_ware_stocks  (tribe_descr.get_nrwares          ()),
+	m_ai_data_int32          (),
+	m_ai_data_uint32         (),
+	m_ai_data_int16          ()
+
 {
 	set_name(name);
 
@@ -1283,17 +1287,48 @@
 			 building_position.x, building_position.y);
 	}
 }
+/**
+ * Functions used by AI to save/read AI data stored in Player class.
+ */
 
-void Player::set_ai(const std::string & ai)
-{
+void Player::set_ai(const std::string & ai) {
 	m_ai = ai;
 }
 
-const std::string & Player::get_ai() const
-{
+const std::string & Player::get_ai() const {
 	return m_ai;
 }
 
+void Player::set_ai_data(int32_t value, uint32_t position) {
+	assert(position < kAIDataSize);
+	m_ai_data_int32[position] = value;
+}
+
+void Player::set_ai_data(uint32_t value, uint32_t position) {
+	assert(position < kAIDataSize);
+	m_ai_data_uint32[position] = value;
+}
+
+void Player::set_ai_data(int16_t value, uint32_t position) {
+	assert(position < kAIDataSize);
+	m_ai_data_int16[position] = value;
+}
+
+void Player::get_ai_data(int32_t * value, uint32_t position) {
+	assert(position < kAIDataSize);
+	*value = m_ai_data_int32[position];
+}
+
+void Player::get_ai_data(uint32_t * value, uint32_t position) {
+	assert(position < kAIDataSize);
+	*value = m_ai_data_uint32[position];
+}
+
+void Player::get_ai_data(int16_t * value, uint32_t position) {
+	assert(position < kAIDataSize);
+	*value = m_ai_data_int16[position];
+}
+
 /**
  * Read statistics data from a file.
  *

=== modified file 'src/logic/player.h'
--- src/logic/player.h	2015-04-11 21:03:05 +0000
+++ src/logic/player.h	2015-10-24 18:56:46 +0000
@@ -33,6 +33,11 @@
 #include "logic/warehouse.h"
 #include "logic/widelands.h"
 
+// there are three arrays to be used by AI
+// their size is defined here
+// (all are of the same size)
+constexpr int kAIDataSize = 6;
+
 class Node;
 namespace Widelands {
 
@@ -517,6 +522,14 @@
 		m_further_initializations .push_back(init);
 	}
 
+	// set of functions to be used by AI to save and read own data within this class
+	void set_ai_data(int32_t value, uint32_t position);
+	void set_ai_data(uint32_t value, uint32_t position);
+	void set_ai_data(int16_t value, uint32_t position);
+	void get_ai_data(int32_t * value, uint32_t position);
+	void get_ai_data(uint32_t * value, uint32_t position);
+	void get_ai_data(int16_t * value, uint32_t position);
+
 private:
 	BuildingStatsVector* get_mutable_building_statistics(const BuildingIndex& i);
 	void update_building_statistics(Building &, NoteImmovable::Ownership ownership);
@@ -586,6 +599,15 @@
 	 */
 	std::vector< std::vector<uint32_t> > m_ware_stocks;
 
+
+	/**
+	 * AI internal data. These will be ignored by human player
+	 * AI is managing the content of these arrays
+	 */
+	int32_t m_ai_data_int32 [kAIDataSize];
+	uint32_t m_ai_data_uint32 [kAIDataSize];
+	int16_t m_ai_data_int16 [kAIDataSize];
+
 	PlayerBuildingStats m_building_stats;
 
 	DISALLOW_COPY_AND_ASSIGN(Player);

=== modified file 'tribes/atlanteans/blackroot_farm/conf'
--- tribes/atlanteans/blackroot_farm/conf	2015-07-31 07:26:49 +0000
+++ tribes/atlanteans/blackroot_farm/conf	2015-10-24 18:56:46 +0000
@@ -3,6 +3,7 @@
 
 [aihints]
 prohibited_till=600
+forced_after=800
 space_consumer=true
 
 [buildcost]

=== modified file 'tribes/atlanteans/farm/conf'
--- tribes/atlanteans/farm/conf	2015-06-10 07:00:10 +0000
+++ tribes/atlanteans/farm/conf	2015-10-24 18:56:46 +0000
@@ -3,9 +3,9 @@
 
 [aihints]
 space_consumer=true
-forced_after=180 # farm needs spidercloth to be build and spidercloth needs
+forced_after=400 # farm needs spidercloth to be build and spidercloth needs
               # corn for production -> farm should be build ASAP!
-prohibited_till=120
+prohibited_till=200
 
 [buildcost]
 log=3

=== modified file 'tribes/atlanteans/fish_breeders_house/conf'
--- tribes/atlanteans/fish_breeders_house/conf	2015-05-25 18:36:46 +0000
+++ tribes/atlanteans/fish_breeders_house/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,8 @@
 [aihints]
 needs_water=true
 renews_map_resource=fish
-prohibited_till=300
+prohibited_till=700
+forced_after=900
 
 [buildcost]
 log=1

=== modified file 'tribes/atlanteans/foresters_house/conf'
--- tribes/atlanteans/foresters_house/conf	2014-08-02 19:55:23 +0000
+++ tribes/atlanteans/foresters_house/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,7 @@
 [aihints]
 space_consumer=true
 renews_map_resource=log
-prohibited_till=50
+prohibited_till=240
 
 [buildcost]
 log=1

=== modified file 'tribes/atlanteans/hunters_house/conf'
--- tribes/atlanteans/hunters_house/conf	2015-07-26 10:59:28 +0000
+++ tribes/atlanteans/hunters_house/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,7 @@
 output=meat
 
 [aihints]
-prohibited_till=60
+prohibited_till=400
 
 [buildcost]
 log=1

=== modified file 'tribes/atlanteans/labyrinth/conf'
--- tribes/atlanteans/labyrinth/conf	2015-03-26 06:59:37 +0000
+++ tribes/atlanteans/labyrinth/conf	2015-10-24 18:56:46 +0000
@@ -100,3 +100,4 @@
 
 [aihints]
 trainingsite_type=basic
+prohibited_till=900

=== modified file 'tribes/atlanteans/planks/conf'
--- tribes/atlanteans/planks/conf	2014-07-28 14:04:36 +0000
+++ tribes/atlanteans/planks/conf	2015-10-24 18:56:46 +0000
@@ -1,7 +1,7 @@
 help=_Planks are an important building material of the Atlanteans. They are produced out of logs by the sawmill. The weapon smithy and the shipyard also use planks to produce the different tridents and mighty ships.
 
 default_target_quantity=40
-preciousness=7
+preciousness=10
 
 [idle]
 pics=idle.png

=== modified file 'tribes/atlanteans/quarry/conf'
--- tribes/atlanteans/quarry/conf	2015-07-26 10:59:28 +0000
+++ tribes/atlanteans/quarry/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,8 @@
 output=stone
 
 [aihints]
-forced_after=60
+prohibited_till=240
+forced_after=240
 stoneproducer=true
 
 [buildcost]

=== modified file 'tribes/atlanteans/sawmill/conf'
--- tribes/atlanteans/sawmill/conf	2015-05-25 18:36:46 +0000
+++ tribes/atlanteans/sawmill/conf	2015-10-24 18:56:46 +0000
@@ -2,8 +2,8 @@
 output=planks
 
 [aihints]
-forced_after=120
-prohibited_till=60
+forced_after=250
+prohibited_till=250
 
 [buildcost]
 log=2

=== modified file 'tribes/atlanteans/smokery/conf'
--- tribes/atlanteans/smokery/conf	2015-05-25 18:36:46 +0000
+++ tribes/atlanteans/smokery/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,7 @@
 output=smoked_fish
 
 [aihints]
-forced_after=900
+forced_after=800
 prohibited_till=180
 
 [buildcost]

=== modified file 'tribes/atlanteans/spiderfarm/conf'
--- tribes/atlanteans/spiderfarm/conf	2015-05-25 18:36:46 +0000
+++ tribes/atlanteans/spiderfarm/conf	2015-10-24 18:56:46 +0000
@@ -37,5 +37,5 @@
 hotspot=87 75
 
 [aihints]
-forced_after=150
-prohibited_till=60
+forced_after=450
+prohibited_till=350

=== modified file 'tribes/atlanteans/toolsmithy/conf'
--- tribes/atlanteans/toolsmithy/conf	2014-08-02 19:55:23 +0000
+++ tribes/atlanteans/toolsmithy/conf	2015-10-24 18:56:46 +0000
@@ -13,7 +13,7 @@
 output=shovel
 
 [aihints]
-forced_after=900
+forced_after=500
 prohibited_till=450
 
 [buildcost]

=== modified file 'tribes/atlanteans/weaving-mill/conf'
--- tribes/atlanteans/weaving-mill/conf	2015-05-25 18:36:46 +0000
+++ tribes/atlanteans/weaving-mill/conf	2015-10-24 18:56:46 +0000
@@ -4,8 +4,8 @@
 output=golden_tabard
 
 [aihints]
-forced_after=150
-prohibited_till=60
+forced_after=600
+prohibited_till=450
 
 [buildcost]
 log=3

=== modified file 'tribes/atlanteans/well/conf'
--- tribes/atlanteans/well/conf	2015-07-26 10:59:28 +0000
+++ tribes/atlanteans/well/conf	2015-10-24 18:56:46 +0000
@@ -3,8 +3,8 @@
 
 [aihints]
 mines_water=true
-forced_after=600
-prohibited_till=300
+forced_after=800
+prohibited_till=450
 
 [buildcost]
 log=2

=== modified file 'tribes/atlanteans/woodcutters_house/conf'
--- tribes/atlanteans/woodcutters_house/conf	2015-07-26 10:59:28 +0000
+++ tribes/atlanteans/woodcutters_house/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,8 @@
 
 [aihints]
 logproducer=true
-forced_after=0
+forced_after=210
+prohibited_till=210
 
 [buildcost]
 log=2

=== modified file 'tribes/barbarians/bakery/conf'
--- tribes/barbarians/bakery/conf	2014-08-02 19:55:23 +0000
+++ tribes/barbarians/bakery/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,7 @@
 output=pittabread
 
 [aihints]
-prohibited_till=600
+prohibited_till=800
 
 [buildcost]
 log=2

=== modified file 'tribes/barbarians/farm/conf'
--- tribes/barbarians/farm/conf	2015-06-28 17:41:39 +0000
+++ tribes/barbarians/farm/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,7 @@
 
 [aihints]
 space_consumer=true
-forced_after=900
+forced_after=600
 
 [buildcost]
 log=4

=== modified file 'tribes/barbarians/hardener/conf'
--- tribes/barbarians/hardener/conf	2015-02-24 19:41:30 +0000
+++ tribes/barbarians/hardener/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,8 @@
 output=blackwood
 
 [aihints]
-forced_after=0
+forced_after=250
+prohibited_till=250
 
 [buildcost]
 log=3

=== modified file 'tribes/barbarians/hunters_hut/conf'
--- tribes/barbarians/hunters_hut/conf	2015-07-26 10:59:28 +0000
+++ tribes/barbarians/hunters_hut/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,7 @@
 output=meat
 
 [aihints]
-prohibited_till=300
+prohibited_till=500
 
 [buildcost]
 log=4

=== modified file 'tribes/barbarians/lime_kiln/conf'
--- tribes/barbarians/lime_kiln/conf	2014-07-27 19:32:24 +0000
+++ tribes/barbarians/lime_kiln/conf	2015-10-24 18:56:46 +0000
@@ -1,6 +1,9 @@
 size=medium
 output=grout
 
+[aihints]
+forced_after=600
+
 [buildcost]
 log=4
 raw_stone=2

=== modified file 'tribes/barbarians/lumberjacks_hut/conf'
--- tribes/barbarians/lumberjacks_hut/conf	2015-07-26 10:59:28 +0000
+++ tribes/barbarians/lumberjacks_hut/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,8 @@
 output=log
 
 [aihints]
-forced_after=0
+forced_after=180
+prohibited_till=180
 logproducer=true
 
 [buildcost]

=== modified file 'tribes/barbarians/metalworks/conf'
--- tribes/barbarians/metalworks/conf	2014-08-02 19:55:23 +0000
+++ tribes/barbarians/metalworks/conf	2015-10-24 18:56:46 +0000
@@ -12,8 +12,8 @@
 enhancement=axfactory
 
 [aihints]
-forced_after=300
-prohibited_till=120
+forced_after=400
+prohibited_till=400
 
 [buildcost]
 log=1

=== modified file 'tribes/barbarians/quarry/conf'
--- tribes/barbarians/quarry/conf	2015-07-26 10:59:28 +0000
+++ tribes/barbarians/quarry/conf	2015-10-24 18:56:46 +0000
@@ -2,8 +2,8 @@
 output=raw_stone
 
 [aihints]
-forced_after=0
 stoneproducer=true
+prohibited_till=240
 
 [buildcost]
 log=4

=== modified file 'tribes/barbarians/rangers_hut/conf'
--- tribes/barbarians/rangers_hut/conf	2015-02-13 18:07:55 +0000
+++ tribes/barbarians/rangers_hut/conf	2015-10-24 18:56:46 +0000
@@ -3,6 +3,7 @@
 [aihints]
 renews_map_resource=log
 space_consumer=true
+prohibited_till=200
 
 [buildcost]
 log=4

=== modified file 'tribes/barbarians/reed_yard/conf'
--- tribes/barbarians/reed_yard/conf	2015-06-09 08:45:20 +0000
+++ tribes/barbarians/reed_yard/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,8 @@
 
 [aihints]
 space_consumer=true
-forced_after=0
+forced_after=250
+prohibited_till=250
 
 [buildcost]
 log=5

=== modified file 'tribes/barbarians/smelting_works/conf'
--- tribes/barbarians/smelting_works/conf	2014-08-02 19:55:23 +0000
+++ tribes/barbarians/smelting_works/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,7 @@
 output=gold
 
 [aihints]
-prohibited_till=300
+prohibited_till=400
 
 [buildcost]
 log=3

=== modified file 'tribes/barbarians/trainingcamp/conf'
--- tribes/barbarians/trainingcamp/conf	2015-03-26 06:59:37 +0000
+++ tribes/barbarians/trainingcamp/conf	2015-10-24 18:56:46 +0000
@@ -37,6 +37,7 @@
 
 [aihints]
 trainingsite_type=advanced
+prohibited_till=500
 
 [soldier hp]
 min_level=0

=== modified file 'tribes/barbarians/well/conf'
--- tribes/barbarians/well/conf	2015-07-26 10:59:28 +0000
+++ tribes/barbarians/well/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,8 @@
 
 [aihints]
 mines_water=true
-prohibited_till=600
+prohibited_till=800
+forced_after=800
 
 [buildcost]
 log=4

=== modified file 'tribes/empire/armorsmithy/conf'
--- tribes/empire/armorsmithy/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/armorsmithy/conf	2015-10-24 18:56:46 +0000
@@ -5,7 +5,8 @@
 output=plate_armor
 
 [aihints]
-prohibited_till=900
+prohibited_till=700
+forced_after=900
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/bakery/conf'
--- tribes/empire/bakery/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/bakery/conf	2015-10-24 18:56:46 +0000
@@ -3,6 +3,7 @@
 
 [aihints]
 prohibited_till=600
+forced_after=700
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/bread/conf'
--- tribes/empire/bread/conf	2015-05-17 11:01:13 +0000
+++ tribes/empire/bread/conf	2015-10-24 18:56:46 +0000
@@ -1,7 +1,7 @@
 help=_The bakers of the Empire make really tasty bread out of flour and water. It is used in taverns and inns to prepare rations and meals. Bread is also consumed at the training sites (arena, colosseum, training camp).
 
 default_target_quantity=20
-preciousness=5
+preciousness=7
 
 [idle]
 pics=idle.png

=== modified file 'tribes/empire/flour/conf'
--- tribes/empire/flour/conf	2014-07-15 20:04:19 +0000
+++ tribes/empire/flour/conf	2015-10-24 18:56:46 +0000
@@ -1,7 +1,7 @@
 help=_Flour is produced by the mill out of wheat and is needed in the bakery to produce the tasty Empire bread.
 
 default_target_quantity=20
-preciousness=5
+preciousness=9
 
 [idle]
 pics=flour_idle.png

=== modified file 'tribes/empire/foresters_house/conf'
--- tribes/empire/foresters_house/conf	2014-07-29 09:27:08 +0000
+++ tribes/empire/foresters_house/conf	2015-10-24 18:56:46 +0000
@@ -3,6 +3,7 @@
 [aihints]
 space_consumer=true
 renews_map_resource=log
+prohibited_till=200
 
 [buildcost]
 log=1

=== modified file 'tribes/empire/lumberjacks_house/conf'
--- tribes/empire/lumberjacks_house/conf	2015-07-26 10:59:28 +0000
+++ tribes/empire/lumberjacks_house/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,8 @@
 output=log
 
 [aihints]
-forced_after=0
+forced_after=180
+prohibited_till=180
 logproducer=true
 
 [buildcost]

=== modified file 'tribes/empire/piggery/conf'
--- tribes/empire/piggery/conf	2015-03-18 20:46:03 +0000
+++ tribes/empire/piggery/conf	2015-10-24 18:56:46 +0000
@@ -2,7 +2,7 @@
 output=meat
 
 [aihints]
-forced_after=9000
+forced_after=1800
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/quarry/conf'
--- tribes/empire/quarry/conf	2015-07-26 10:59:28 +0000
+++ tribes/empire/quarry/conf	2015-10-24 18:56:46 +0000
@@ -3,8 +3,9 @@
 output=marble
 
 [aihints]
-forced_after=0
 stoneproducer=true
+forced_after=240
+prohibited_till=240
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/sawmill/conf'
--- tribes/empire/sawmill/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/sawmill/conf	2015-10-24 18:56:46 +0000
@@ -2,8 +2,8 @@
 output=wood
 
 [aihints]
-forced_after=60
-prohibited_till=60
+forced_after=250
+prohibited_till=250
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/stonemasons_house/conf'
--- tribes/empire/stonemasons_house/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/stonemasons_house/conf	2015-10-24 18:56:46 +0000
@@ -2,8 +2,8 @@
 output=marblecolumn
 
 [aihints]
-forced_after=300
-prohibited_till=120
+forced_after=400
+prohibited_till=400
 
 [buildcost]
 log=1

=== modified file 'tribes/empire/toolsmithy/conf'
--- tribes/empire/toolsmithy/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/toolsmithy/conf	2015-10-24 18:56:46 +0000
@@ -13,8 +13,8 @@
 output=saw
 
 [aihints]
-forced_after=1200
-prohibited_till=120
+forced_after=400
+prohibited_till=400
 
 [buildcost]
 log=1

=== modified file 'tribes/empire/vineyard/conf'
--- tribes/empire/vineyard/conf	2015-07-31 07:26:49 +0000
+++ tribes/empire/vineyard/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,7 @@
 
 [aihints]
 space_consumer=true
-forced_after=120
+forced_after=300
 
 [buildcost]
 wood=2

=== modified file 'tribes/empire/well/conf'
--- tribes/empire/well/conf	2015-07-26 10:59:28 +0000
+++ tribes/empire/well/conf	2015-10-24 18:56:46 +0000
@@ -3,7 +3,8 @@
 
 [aihints]
 mines_water=true
-prohibited_till=60
+prohibited_till=800
+forced_after=800
 
 [buildcost]
 log=2

=== modified file 'tribes/empire/winery/conf'
--- tribes/empire/winery/conf	2014-08-02 19:55:23 +0000
+++ tribes/empire/winery/conf	2015-10-24 18:56:46 +0000
@@ -2,8 +2,8 @@
 output=wine
 
 [aihints]
-forced_after=900
-prohibited_till=60
+forced_after=600
+prohibited_till=600
 
 [buildcost]
 wood=1

=== modified file 'tribes/empire/wood/conf'
--- tribes/empire/wood/conf	2014-07-28 14:04:36 +0000
+++ tribes/empire/wood/conf	2015-10-24 18:56:46 +0000
@@ -1,7 +1,7 @@
 help=_Wood is a basic building material of the Empire. It is also used by the weapon smithy.
 
 default_target_quantity=40
-preciousness=7
+preciousness=10
 
 [idle]
 pics=idle.png