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

[TiborB]

Another bunch of changes to AI, partially code cleaning and partially functional improvements, areas affected
- blocked fields management
- player strength processing
- attacking reworked a bit
- road management modified
- other nits

[GunChleoc (gunchleoc)]

I have fixed up some data types and added some NOCOMs.

review: Needs Fixing

[TiborB (tiborb95)]

OK, I will rework it, but not until next week. BTW, you are really right with your comments...

[GunChleoc (gunchleoc)]

I could take care of splitting the ai_hintsh/.cc, since I'm waiting for a bunch of reviews anyway :)

[TiborB (tiborb95)]

For me it does not make a significant difference, it is not much of work. But if you fixed it all, you could merge it before I am back. It is up to you...

[GunChleoc (gunchleoc)]

All done. Please double-check my code changes and wait for Travis before merging.

review: Approve

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 732. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/110188250.
Appveyor build 579. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_small_tweaks-579.

[TiborB (tiborb95)]

OK, it seems it works as before, I checked a code a bit, and I trust you that you had not changed the functionality of my code..

@bunnybot merge

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

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

 M src/ai/ai_help_structs.cc
 M src/ai/ai_help_structs.h
 M src/ai/defaultai.cc
 M src/ai/defaultai.h
 M src/logic/widelands_geometry.cc
 M src/logic/widelands_geometry.h
Text conflict in src/ai/ai_help_structs.h
Text conflict in src/ai/defaultai.cc
2 conflicts encountered.

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr pull --overwrite' failed. Output:

ssh_exchange_identification: Connection closed by remote host
ConnectionReset reading response for 'BzrDir.open_2.1', retrying
ssh_exchange_identification: Connection closed by remote host
bzr: ERROR: Connection closed: Unexpected end of message. Please check connectivity and permissions, and report a bug if problems persist.
Using saved parent location: bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/ai_small_tweaks/

[bunnybot (widelandsofficial)]

Bunnybot encountered an error while working on this merge proposal:

Running 'bzr pull --overwrite' failed. Output:

ssh_exchange_identification: Connection closed by remote host
ConnectionReset reading response for 'BzrDir.open_2.1', retrying
ssh_exchange_identification: Connection closed by remote host
bzr: ERROR: Connection closed: Unexpected end of message. Please check connectivity and permissions, and report a bug if problems persist.
Using saved parent location: bzr+ssh://bazaar.launchpad.net/~widelands-dev/widelands/ai_small_tweaks/

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 732. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/110188250.
Appveyor build 579. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_small_tweaks-579.

[GunChleoc (gunchleoc)]

@bunnybot merge

=== modified file 'src/ai/ai_help_structs.cc'
--- src/ai/ai_help_structs.cc	2014-09-30 20:31:43 +0000
+++ src/ai/ai_help_structs.cc	2016-02-22 08:51:02 +0000
@@ -24,19 +24,13 @@
 
 namespace Widelands {
 
-// FindNodeWithFlagOrRoad
-bool FindNodeWithFlagOrRoad::accept(const Map&, FCoords fc) const {
-	if (upcast(PlayerImmovable const, pimm, fc.field->get_immovable()))
-		return (dynamic_cast<Flag const*>(pimm) ||
-		        (dynamic_cast<Road const*>(pimm) && (fc.field->nodecaps() & BUILDCAPS_FLAG)));
-	return false;
-}
-
 // CheckStepRoadAI
+CheckStepRoadAI::CheckStepRoadAI(Player* const pl, uint8_t const mc, bool const oe)
+	: player(pl), movecaps(mc), open_end(oe) {}
 
 bool CheckStepRoadAI::allowed(
    Map& map, FCoords start, FCoords end, int32_t, CheckStep::StepId const id) const {
-	uint8_t endcaps = player_->get_buildcaps(end);
+	uint8_t endcaps = player->get_buildcaps(end);
 
 	// we should not cross fields with road or flags (or any other immovable)
 	if ((map.get_immovable(start)) && !(id == CheckStep::stepFirst)) {
@@ -44,13 +38,13 @@
 	}
 
 	// Calculate cost and passability
-	if (!(endcaps & movecaps_))
+	if (!(endcaps & movecaps))
 		return false;
 
 	// Check for blocking immovables
 	if (BaseImmovable const* const imm = map.get_immovable(end))
 		if (imm->get_size() >= BaseImmovable::SMALL) {
-			if (id != CheckStep::stepLast && !open_end_)
+			if (id != CheckStep::stepLast && !open_end)
 				return false;
 
 			if (dynamic_cast<Flag const*>(imm))
@@ -66,8 +60,8 @@
 bool CheckStepRoadAI::reachable_dest(Map& map, FCoords const dest) const {
 	NodeCaps const caps = dest.field->nodecaps();
 
-	if (!(caps & movecaps_)) {
-		if (!((movecaps_ & MOVECAPS_SWIM) && (caps & MOVECAPS_WALK)))
+	if (!(caps & movecaps)) {
+		if (!((movecaps & MOVECAPS_SWIM) && (caps & MOVECAPS_WALK)))
 			return false;
 
 		if (!map.can_reach_by_water(dest))
@@ -76,4 +70,300 @@
 
 	return true;
 }
-}
+
+// We are looking for fields we can walk on
+// and owned by hostile player.
+FindNodeEnemy::FindNodeEnemy(Player* p, Game& g) : player(p), game(g) {}
+
+bool FindNodeEnemy::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & MOVECAPS_WALK) && fc.field->get_owned_by() != 0 &&
+			 player->is_hostile(*game.get_player(fc.field->get_owned_by()));
+}
+
+// We are looking for buildings owned by hostile player
+// (sometimes there is a enemy's teritorry without buildings, and
+// this confuses the AI)
+FindNodeEnemiesBuilding::FindNodeEnemiesBuilding(Player* p, Game& g) : player(p), game(g) {}
+
+bool FindNodeEnemiesBuilding::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->get_immovable()) && fc.field->get_owned_by() != 0 &&
+			 player->is_hostile(*game.get_player(fc.field->get_owned_by()));
+}
+
+// When looking for unowned terrain to acquire, we are actually
+// only interested in fields we can walk on.
+// Fields should either be completely unowned or owned by an opposing player
+FindNodeUnowned::FindNodeUnowned(Player* p, Game& g, bool oe) : player(p), game(g), only_enemies(oe) {}
+
+bool FindNodeUnowned::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & MOVECAPS_WALK) &&
+			 ((fc.field->get_owned_by() == 0) ||
+			  player->is_hostile(*game.get_player(fc.field->get_owned_by()))) &&
+			 (!only_enemies || (fc.field->get_owned_by() != 0));
+}
+
+// Sometimes we need to know how many nodes our allies owns
+FindNodeAllyOwned::FindNodeAllyOwned(Player* p, Game& g, PlayerNumber n) :
+	player(p), game(g), player_number(n) {}
+
+bool FindNodeAllyOwned::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & MOVECAPS_WALK) && (fc.field->get_owned_by() != 0) &&
+			 (fc.field->get_owned_by() != player_number) &&
+			 !player->is_hostile(*game.get_player(fc.field->get_owned_by()));
+}
+
+// When looking for unowned terrain to acquire, we must
+// pay speciall attention to fields where mines can be built.
+// Fields should be completely unowned
+FindNodeUnownedMineable::FindNodeUnownedMineable(Player* p, Game& g) : player(p), game(g) {}
+
+bool FindNodeUnownedMineable::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_owned_by() == 0);
+}
+
+// Unowned but walkable fields nearby
+FindNodeUnownedWalkable::FindNodeUnownedWalkable(Player* p, Game& g) : player(p), game(g) {}
+
+bool FindNodeUnownedWalkable::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & MOVECAPS_WALK) && (fc.field->get_owned_by() == 0);
+}
+
+// Looking only for mines-capable fields nearby
+// of specific type
+FindNodeMineable::FindNodeMineable(Game& g, int32_t r) : game(g), res(r) {}
+
+bool FindNodeMineable::accept(const Map&, const FCoords& fc) const {
+
+	return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_resources() == res);
+}
+
+
+// Fishers and fishbreeders must be built near water
+FindNodeWater::FindNodeWater(const World& world) : world_(world) {}
+
+bool FindNodeWater::accept(const Map& /* map */, const FCoords& coord) const {
+	return (world_.terrain_descr(coord.field->terrain_d()).get_is() &
+			  TerrainDescription::Is::kWater) ||
+			 (world_.terrain_descr(coord.field->terrain_r()).get_is() &
+			  TerrainDescription::Is::kWater);
+}
+
+// FindNodeWithFlagOrRoad
+bool FindNodeWithFlagOrRoad::accept(const Map&, FCoords fc) const {
+	if (upcast(PlayerImmovable const, pimm, fc.field->get_immovable()))
+		return (dynamic_cast<Flag const*>(pimm) ||
+				  (dynamic_cast<Road const*>(pimm) && (fc.field->nodecaps() & BUILDCAPS_FLAG)));
+	return false;
+}
+
+NearFlag::NearFlag(const Flag& f, int32_t const c, int32_t const d) : flag(&f), cost(c), distance(d) {}
+
+BuildableField::BuildableField(const Widelands::FCoords& fc)
+	: coords(fc),
+	  field_info_expiration(20000),
+	  preferred(false),
+	  enemy_nearby(0),
+	  unowned_land_nearby(0),
+	  near_border(false),
+	  unowned_mines_spots_nearby(0),
+	  trees_nearby(0),
+	  // explanation of starting values
+	  // this is done to save some work for AI (CPU utilization)
+	  // base rules are:
+	  // count of rocks can only decrease, so  amount of rocks
+	  // is recalculated only when previous count is positive
+	  // count of water fields are stable, so if the current count is
+	  // non-negative, water is not recaldulated
+	  rocks_nearby(1),
+	  water_nearby(-1),
+	  distant_water(0),
+	  fish_nearby(-1),
+	  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),
+	  area_military_presence(0),
+	  military_stationed(0),
+	  military_unstationed(0),
+	  is_portspace(false),
+	  port_nearby(false),
+	  portspace_nearby(Widelands::ExtendedBool::kUnset),
+	  max_buildcap_nearby(0),
+	  last_resources_check_time(0) {
+}
+
+int32_t BuildableField::own_military_sites_nearby_() {
+	return military_stationed + military_unstationed;
+}
+
+MineableField::MineableField(const Widelands::FCoords& fc)
+	: coords(fc),
+	  field_info_expiration(20000),
+	  preferred(false),
+	  mines_nearby(0),
+	  same_mine_fields_nearby(0) {
+}
+
+EconomyObserver::EconomyObserver(Widelands::Economy& e) : economy(e) {
+	dismantle_grace_time = std::numeric_limits<int32_t>::max();
+}
+
+int32_t BuildingObserver::total_count() const {
+	return cnt_built + cnt_under_construction;
+}
+
+Widelands::AiModeBuildings BuildingObserver::aimode_limit_status() {
+	if (total_count() > cnt_limit_by_aimode) {
+		return Widelands::AiModeBuildings::kLimitExceeded;
+	} else if (total_count() == cnt_limit_by_aimode) {
+		return Widelands::AiModeBuildings::kOnLimit;
+	} else {
+		return Widelands::AiModeBuildings::kAnotherAllowed;
+	}
+}
+bool BuildingObserver::buildable(Widelands::Player& p) {
+	return is_buildable && p.is_building_type_allowed(id);
+}
+
+
+// Computer player does not get notification messages about enemy militarysites
+// and warehouses, so following is collected based on observation
+// It is conventient to have some information preserved, like nearby minefields,
+// when it was attacked, whether it is warehouse and so on
+// Also AI test more such targets when considering attack and calculated score is
+// is stored in the observer
+EnemySiteObserver::EnemySiteObserver()
+	: is_warehouse(false),
+	  attack_soldiers_strength(0),
+	  defenders_strength(0),
+	  stationed_soldiers(0),
+	  last_time_attackable(std::numeric_limits<uint32_t>::max()),
+	  last_tested(0),
+	  score(0),
+	  mines_nearby(Widelands::ExtendedBool::kUnset),
+	  no_attack_counter(0) {}
+
+
+// as all mines have 3 levels, AI does not know total count of mines per mined material
+// so this observer will be used for this
+MineTypesObserver::MineTypesObserver() : in_construction(0), finished(0) {}
+
+uint16_t MineTypesObserver::total_count() const {
+	return in_construction + finished;
+}
+
+// this is used to count militarysites by their size
+MilitarySiteSizeObserver::MilitarySiteSizeObserver() : in_construction(0), finished(0) {}
+
+// this represents a scheduler task
+SchedulerTask::SchedulerTask
+	(const uint32_t time, const Widelands::SchedulerTaskId t, const uint8_t p, const char* d):
+	due_time(time), id(t), priority(p), descr(d) {}
+
+bool SchedulerTask::operator<(SchedulerTask other) const {
+	return priority > other.priority;
+}
+
+
+// List of blocked fields with block time, with some accompanying functions
+void BlockedFields::add(Widelands::Coords coords, uint32_t till) {
+	const uint32_t hash = coords.hash();
+	if (blocked_fields_.count(hash) == 0) {
+		blocked_fields_.insert(std::pair<uint32_t, uint32_t>(hash, till));
+	} else if (blocked_fields_[hash] < till) {
+		blocked_fields_[hash] = till;
+	}
+	// The third possibility is that a field has been already blocked for longer time than 'till'
+}
+
+uint32_t BlockedFields::count() {
+	return blocked_fields_.size();
+}
+
+void BlockedFields::remove_expired(uint32_t gametime) {
+	std::vector<uint32_t> fields_to_remove;
+	for (auto field: blocked_fields_) {
+		if (field.second < gametime) {
+			fields_to_remove.push_back(field.first);
+		}
+	}
+	while (!fields_to_remove.empty()) {
+		blocked_fields_.erase(fields_to_remove.back());
+		fields_to_remove.pop_back();
+	}
+}
+
+bool BlockedFields::is_blocked(Coords coords) {
+	return (blocked_fields_.count(coords.hash()) != 0);
+}
+
+// This is an struct that stores strength of players, info on teams and provides some outputs from these data
+PlayersStrengths::PlayerStat::PlayerStat() {}
+PlayersStrengths::PlayerStat::PlayerStat(Widelands::TeamNumber tc, uint32_t pp) :
+	team_number(tc), players_power(pp) {}
+
+// Inserting/updating data
+void PlayersStrengths::add(Widelands::PlayerNumber pn, Widelands::TeamNumber tn, uint32_t pp) {
+	if (all_stats.count(pn) == 0) {
+		all_stats.insert(std::pair<Widelands::PlayerNumber, PlayerStat>(pn, PlayerStat(tn, pp)));
+	} else {
+		all_stats[pn].players_power = pp;
+	}
+}
+
+void PlayersStrengths::recalculate_team_power() {
+	team_powers.clear();
+	for (auto& item: all_stats) {
+		if (item.second.team_number > 0) { // is a member of a team
+			if (team_powers.count(item.second.team_number) > 0) {
+				team_powers[item.second.team_number] += item.second.players_power;
+			} else {
+				team_powers[item.second.team_number] = item.second.players_power;
+			}
+		}
+	}
+}
+
+// This is strength of player plus third of strength of other members of his team
+uint32_t PlayersStrengths::get_modified_player_power(Widelands::PlayerNumber pn) {
+	uint32_t result = 0;
+	Widelands::TeamNumber team = 0;
+	if (all_stats.count(pn) > 0) {
+		result = all_stats[pn].players_power;
+		team = all_stats[pn].team_number;
+	};
+	if (team > 0 && team_powers.count(team) > 0) {
+		result = result + (team_powers[team] - result) / 3;
+	};
+	return result;
+}
+
+bool PlayersStrengths::players_in_same_team(Widelands::PlayerNumber pl1, Widelands::PlayerNumber pl2) {
+	if (all_stats.count(pl1) > 0 && all_stats.count(pl2) > 0 && pl1 != pl2) {
+		// team number 0 = no team
+		return all_stats[pl1].team_number > 0 && all_stats[pl1].team_number == all_stats[pl2].team_number;
+	} else {
+		return false;
+	}
+}
+
+bool PlayersStrengths::strong_enough(Widelands::PlayerNumber pl) {
+	if (all_stats.count(pl) == 0) {
+		return false;
+	}
+	uint32_t my_strength = all_stats[pl].players_power;
+	uint32_t strongest_opponent_strength = 0;
+	for (auto item : all_stats) {
+		if (!players_in_same_team(item.first, pl) && pl != item.first) {
+			if (get_modified_player_power(item.first) > strongest_opponent_strength) {
+				strongest_opponent_strength = get_modified_player_power(item.first);
+			}
+		}
+	}
+	return my_strength > strongest_opponent_strength + 50;
+}
+
+} // namespace WIdelands

=== modified file 'src/ai/ai_help_structs.h'
--- src/ai/ai_help_structs.h	2016-02-18 08:42:46 +0000
+++ src/ai/ai_help_structs.h	2016-02-22 08:51:02 +0000
@@ -43,10 +43,13 @@
 class MilitarySite;
 
 enum class ExtendedBool : uint8_t {kUnset, kTrue, kFalse};
+
 enum class BuildingNecessity : uint8_t
 	{kForced, kNeeded, kNotNeeded, kUnset, kNotBuildable, kAllowed, kNeededPending, kForbidden};
+
 enum class AiModeBuildings : uint8_t
 	{kAnotherAllowed, kOnLimit, kLimitExceeded};
+
 enum class SchedulerTaskId : uint8_t {
 		kBbuildableFieldsCheck,
 		kMineableFieldsCheck,
@@ -69,35 +72,25 @@
 	};
 
 struct CheckStepRoadAI {
-	CheckStepRoadAI(Player* const pl, uint8_t const mc, bool const oe)
-	   : player_(pl), movecaps_(mc), open_end_(oe) {
-	}
-
-	void set_openend(bool const oe) {
-		open_end_ = oe;
-	}
+	CheckStepRoadAI(Player* const pl, uint8_t const mc, bool const oe);
 
 	bool allowed(Map&, FCoords start, FCoords end, int32_t dir, CheckStep::StepId) const;
 	bool reachable_dest(Map&, FCoords dest) const;
 
-	Player* player_;
-	uint8_t movecaps_;
-	bool open_end_;
+	Player* player;
+	uint8_t movecaps;
+	bool open_end;
 };
 
 // We are looking for fields we can walk on
 // and owned by hostile player.
 struct FindNodeEnemy {
-	bool accept(const Map&, const FCoords& fc) const {
-		return (fc.field->nodecaps() & MOVECAPS_WALK) && fc.field->get_owned_by() != 0 &&
-		       player->is_hostile(*game.get_player(fc.field->get_owned_by()));
-	}
+	FindNodeEnemy(Player* p, Game& g);
+
+	bool accept(const Map&, const FCoords& fc) const;
 
 	Player* player;
 	Game& game;
-
-	FindNodeEnemy(Player* p, Game& g) : player(p), game(g) {
-	}
 };
 
 // We are looking for buildings owned by hostile player
@@ -105,95 +98,76 @@
 // this confuses the AI)
 
 struct FindNodeEnemiesBuilding {
-	bool accept(const Map&, const FCoords& fc) const {
-		return (fc.field->get_immovable()) && fc.field->get_owned_by() != 0 &&
-		       player->is_hostile(*game.get_player(fc.field->get_owned_by()));
-	}
+	FindNodeEnemiesBuilding(Player* p, Game& g);
+
+	bool accept(const Map&, const FCoords& fc) const;
 
 	Player* player;
 	Game& game;
-
-	FindNodeEnemiesBuilding(Player* p, Game& g) : player(p), game(g) {
-	}
 };
 
 // When looking for unowned terrain to acquire, we are actually
 // only interested in fields we can walk on.
 // Fields should either be completely unowned or owned by an opposing player_
 struct FindNodeUnowned {
-	bool accept(const Map&, const FCoords& fc) const {
-		return (fc.field->nodecaps() & MOVECAPS_WALK) &&
-		       ((fc.field->get_owned_by() == 0) ||
-		        player_->is_hostile(*game.get_player(fc.field->get_owned_by()))) &&
-		       (!only_enemies_ || (fc.field->get_owned_by() != 0));
-	}
-
-	Player* player_;
+	FindNodeUnowned(Player* p, Game& g, bool oe = false);
+
+	bool accept(const Map&, const FCoords& fc) const;
+
+	Player* player;
 	Game& game;
-	bool only_enemies_;
-
-	FindNodeUnowned(Player* p, Game& g, bool oe = false) : player_(p), game(g), only_enemies_(oe) {
-	}
+	bool only_enemies;
 };
 
 // Sometimes we need to know how many nodes our allies owns
 struct FindNodeAllyOwned {
-	bool accept(const Map&, const FCoords& fc) const {
-		return (fc.field->nodecaps() & MOVECAPS_WALK) && (fc.field->get_owned_by() != 0) &&
-		       (fc.field->get_owned_by() != pn) &&
-		       !player_->is_hostile(*game.get_player(fc.field->get_owned_by()));
-	}
-
-	Player* player_;
+	FindNodeAllyOwned(Player* p, Game& g, PlayerNumber n);
+
+	bool accept(const Map&, const FCoords& fc) const;
+
+	Player* player;
 	Game& game;
-	PlayerNumber pn;
-
-	FindNodeAllyOwned(Player* p, Game& g, PlayerNumber n) : player_(p), game(g), pn(n) {
-	}
+	PlayerNumber player_number;
 };
 
 // When looking for unowned terrain to acquire, we must
 // pay speciall attention to fields where mines can be built.
 // Fields should be completely unowned
 struct FindNodeUnownedMineable {
-	bool accept(const Map&, const FCoords& fc) const {
-
-		return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_owned_by() == 0);
-	}
-
-	Player* player_;
-	Game& game;
-
-	FindNodeUnownedMineable(Player* p, Game& g) : player_(p), game(g) {
-	}
+	FindNodeUnownedMineable(Player* p, Game& g);
+
+	bool accept(const Map&, const FCoords& fc) const;
+
+	Player* player;
+	Game& game;
+};
+
+// Unowned but walkable fields nearby
+struct FindNodeUnownedWalkable {
+	FindNodeUnownedWalkable(Player* p, Game& g);
+
+	bool accept(const Map&, const FCoords& fc) const;
+
+	Player* player;
+	Game& game;
 };
 
 // Looking only for mines-capable fields nearby
 // of specific type
 struct FindNodeMineable {
-	bool accept(const Map&, const FCoords& fc) const {
+	FindNodeMineable(Game& g, int32_t r);
 
-		return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_resources() == res);
-	}
+	bool accept(const Map&, const FCoords& fc) const;
 
 	Game& game;
 	int32_t res;
-
-	FindNodeMineable(Game& g, int32_t r) : game(g), res(r) {
-	}
 };
 
 // Fishers and fishbreeders must be built near water
 struct FindNodeWater {
-	FindNodeWater(const World& world) : world_(world) {
-	}
+	FindNodeWater(const World& world);
 
-	bool accept(const Map& /* map */, const FCoords& coord) const {
-		return (world_.terrain_descr(coord.field->terrain_d()).get_is() &
-		        TerrainDescription::Is::kWater) ||
-		       (world_.terrain_descr(coord.field->terrain_r()).get_is() &
-		        TerrainDescription::Is::kWater);
-	}
+	bool accept(const Map& /* map */, const FCoords& coord) const;
 
 private:
 	const World& world_;
@@ -204,283 +178,216 @@
 };
 
 struct NearFlag {
-	Flag const* flag;
-	int32_t cost_;
-	int32_t distance_;
+	// ordering nearflags by biggest reduction
+	struct CompareShortening {
+		bool operator()(const NearFlag& a, const NearFlag& b) const {
+			return (a.cost - a.distance) > (b.cost - b.distance);
+		}
+	};
 
-	NearFlag(const Flag& f, int32_t const c, int32_t const d) : flag(&f), cost_(c), distance_(d) {
-	}
+	NearFlag(const Flag& f, int32_t const c, int32_t const d);
 
 	bool operator<(const NearFlag& f) const {
-		return cost_ > f.cost_;
+		return cost > f.cost;
 	}
 
-	bool operator == (Flag const* const f) const {
+	bool operator==(Flag const* const f) const {
 		return flag == f;
 	}
-};
-
-struct CompareDistance {
-	bool operator()(const NearFlag& a, const NearFlag& b) const {
-		return a.distance_ < b.distance_;
-	}
-};
-
-// ordering nearflags by biggest reduction
-struct CompareShortening {
-	bool operator()(const NearFlag& a, const NearFlag& b) const {
-		return (a.cost_ - a.distance_) > (b.cost_ - b.distance_);
-	}
-};
+
+	Flag const* flag;
+	int32_t cost;
+	int32_t distance;
+};
+
+
 
 struct WalkableSpot {
 	Coords coords;
-	bool has_flag_;
+	bool has_flag;
 
-	int32_t cost_;
+	int32_t cost;
 	void* eco;
 
-	int16_t from_;
+	int16_t from;
 	int16_t neighbours[6];
 };
-}
-
-struct BlockedField {
-	Widelands::FCoords coords;
-	uint32_t blocked_until_;
-
-	BlockedField(Widelands::FCoords c, int32_t until) : coords(c), blocked_until_(until) {
-	}
-};
+
 
 struct BuildableField {
+	BuildableField(const Widelands::FCoords& fc);
+
+	int32_t own_military_sites_nearby_();
+
 	Widelands::FCoords coords;
 
-	uint32_t field_info_expiration_;
-
-	bool preferred_;
-	bool enemy_nearby_;
-
-	uint8_t unowned_land_nearby_;
+	uint32_t field_info_expiration;
+
+	bool preferred;
+	bool enemy_nearby;
+
+	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_spots_nearby_;
-	uint8_t trees_nearby_;
-	uint8_t rocks_nearby_;
-	int16_t water_nearby_;
-	int16_t distant_water_;
-	int8_t fish_nearby_;
-	int8_t critters_nearby_;
-	int8_t ground_water_;  // used by wells
-	uint8_t space_consumers_nearby_;
-	uint8_t rangers_nearby_;
+	bool near_border;
+	uint8_t unowned_mines_spots_nearby;
+	uint8_t trees_nearby;
+	uint8_t rocks_nearby;
+	int16_t water_nearby;
+	int16_t distant_water;
+	int8_t fish_nearby;
+	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_;
+	int16_t area_military_capacity;
 	// distance to near buldings:
-	int16_t military_loneliness_;
+	int16_t military_loneliness;
 	// count of military buildings in construction
 	// when making decision on new mulitary buildings it considers also
 	// unowned fields and mines, but this information is not quite correct as there
 	// are construction sites that will change this once they are built
-	int16_t military_in_constr_nearby_;
+	int16_t military_in_constr_nearby;
 	// actual count of soldiers in nearby buldings
-	int16_t area_military_presence_;
-	// stationed (manned) military buildings nearby
-	int16_t military_stationed_;
-	// stationed (manned) military buildings nearby
-	int16_t military_unstationed_;
-	bool is_portspace_;
-	bool port_nearby_;  // to increase priority if a port is nearby,
+	int16_t area_military_presence;
+	// stationed (manned) military buildings nearby
+	int16_t military_stationed;
+	// stationed (manned) military buildings nearby
+	int16_t military_unstationed;
+	bool is_portspace;
+	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_;
+	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_;
+	uint32_t last_resources_check_time;
 
-	std::vector<uint8_t> consumers_nearby_;
-	std::vector<uint8_t> producers_nearby_;
+	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),
-	     field_info_expiration_(20000),
-	     preferred_(false),
-	     enemy_nearby_(0),
-	     unowned_land_nearby_(0),
-	     near_border_(false),
-	     unowned_mines_spots_nearby_(0),
-	     trees_nearby_(0),
-	     // explanation of starting values
-	     // this is done to save some work for AI (CPU utilization)
-	     // base rules are:
-		  // count of rocks can only decrease, so  amount of rocks
-	     // is recalculated only when previous count is positive
-	     // count of water fields are stable, so if the current count is
-	     // non-negative, water is not recaldulated
-	     rocks_nearby_(1),
-	     water_nearby_(-1),
-	     distant_water_(0),
-	     fish_nearby_(-1),
-	     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),
-	     area_military_presence_(0),
-	     military_stationed_(0),
-	     military_unstationed_(0),
-	     is_portspace_(false),
-	     port_nearby_(false),
-	     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_;
-	}
+	std::vector<uint8_t> supporters_nearby;
 };
 
 struct MineableField {
+	MineableField(const Widelands::FCoords& fc);
+
 	Widelands::FCoords coords;
-
-	uint32_t field_info_expiration_;
-
-	bool preferred_;
-
-	int32_t mines_nearby_;
+	uint32_t field_info_expiration;
+	bool preferred;
+	int32_t mines_nearby;
 	// this is to provide that a mine is not built on the edge of mine area
-	int32_t same_mine_fields_nearby_;
-
-	MineableField(const Widelands::FCoords& fc)
-	   : coords(fc),
-	     field_info_expiration_(20000),
-	     preferred_(false),
-	     mines_nearby_(0),
-	     same_mine_fields_nearby_(0) {
-	}
+	int32_t same_mine_fields_nearby;
 };
 
 struct EconomyObserver {
+	EconomyObserver(Widelands::Economy& e);
+
 	Widelands::Economy& economy;
 	std::list<Widelands::Flag const*> flags;
-	int32_t dismantle_grace_time_;
-
-	EconomyObserver(Widelands::Economy& e) : economy(e) {
-		dismantle_grace_time_ = std::numeric_limits<int32_t>::max();
-	}
+	int32_t dismantle_grace_time;
 };
 
 struct BuildingObserver {
+
+	enum class Type {
+		kBoring,
+		kConstructionsite,
+		kProductionsite,
+		kMilitarysite,
+		kWarehouse,
+		kTrainingsite,
+		kMine
+	};
+
+	int32_t total_count() const;
+	Widelands::AiModeBuildings aimode_limit_status();
+	bool buildable(Widelands::Player& p);
+
 	char const* name;
 	Widelands::DescriptionIndex id;
 	Widelands::BuildingDescr const* desc;
 
-	enum {
-		BORING,
-		CONSTRUCTIONSITE,
-		PRODUCTIONSITE,
-		MILITARYSITE,
-		WAREHOUSE,
-		TRAININGSITE,
-		MINE
-	} type;
-
-	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_rocks_;  // quarry = true
-	bool mines_water_;  // wells
-	bool need_water_;   // fisher, fish_breeder = true
-	bool is_hunter_;    // need to identify hunters
-	bool is_fisher_;    // need to identify fishers
-	bool is_port_;
-	bool is_shipyard_;
-	bool space_consumer_;       // farm, vineyard... = true
-	bool expansion_type_;       // military building used that can be used to control area
-	bool fighting_type_;        // military building built near enemies
-	bool mountain_conqueror_;   // military building built near mountains
-	uint32_t prohibited_till_;  // do not build before (ms)
-	uint32_t forced_after_;     // do not wait until ware is needed
-	TrainingSiteType trainingsite_type_;
-
-	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
-	uint32_t current_stats_;
-
-	std::vector<int16_t> inputs_;
-	std::vector<int16_t> outputs_;
-	std::vector<Widelands::DescriptionIndex> critical_built_mat_;
-
-	bool built_mat_producer_;
+	Type type;
+
+	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_rocks;  // quarry = true
+	bool mines_water;  // wells
+	bool need_water;   // fisher, fish_breeder = true
+	bool is_hunter;    // need to identify hunters
+	bool is_fisher;    // need to identify fishers
+	bool is_port;
+	bool is_shipyard;
+	bool space_consumer;       // farm, vineyard... = true
+	bool expansion_type;       // military building used that can be used to control area
+	bool fighting_type;        // military building built near enemies
+	bool mountain_conqueror;   // military building built near mountains
+	uint32_t prohibited_till;  // do not build before (ms)
+	uint32_t forced_after;     // do not wait until ware is needed
+	TrainingSiteType trainingsite_type;
+
+	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
+	uint32_t current_stats;
+
+	std::vector<int16_t> inputs;
+	std::vector<int16_t> outputs;
+	std::vector<Widelands::DescriptionIndex> critical_building_material;
+
+	bool produces_building_material;
 
 	// an enhancement to this building:
 	// produces all wares as current building, and perhaps more
-	bool upgrade_substitutes_;
+	bool upgrade_substitutes;
 	// produces some additional wares
-	bool upgrade_extends_;
+	bool upgrade_extends;
 
 	// It seems that fish and meat are subsitutes (for trainingsites), so
 	// when testing if a trainingsite is supplied enough
 	// we count the wares together
-	std::unordered_set<Widelands::DescriptionIndex> substitute_inputs_;
-	int32_t substitutes_count_;
+	std::unordered_set<Widelands::DescriptionIndex> substitute_inputs;
+	int32_t substitutes_count;
 
-	int16_t production_hint_;
+	int16_t production_hint;
 
 	// information needed for decision on new building construction
-	int16_t max_preciousness_;
-	int16_t max_needed_preciousness_;
+	int16_t max_preciousness;
+	int16_t max_needed_preciousness;
 
-	int32_t cnt_built_;
-	int32_t cnt_under_construction_;
-	int32_t cnt_target_;  // number of buildings as target
-	int32_t cnt_limit_by_aimode_; // limit imposed by weak or normal AI mode
+	int32_t cnt_built;
+	int32_t cnt_under_construction;
+	int32_t cnt_target;  // number of buildings as target
+	int32_t cnt_limit_by_aimode; // limit imposed by weak or normal AI mode
 
 	// used to track amount of wares produced by building
-	uint32_t stocklevel_;
+	uint32_t stocklevel;
 	uint32_t stocklevel_time;  // time when stocklevel_ was last time recalculated
-	uint32_t last_dismantle_time_;
-	uint32_t construction_decision_time_;
-
-	uint32_t unoccupied_count_;
-
-	bool build_material_shortage_;
-
-	int32_t total_count() const {
-		return cnt_built_ + cnt_under_construction_;
-	}
-	Widelands::AiModeBuildings aimode_limit_status() {
-		if (total_count() > cnt_limit_by_aimode_) {
-			return Widelands::AiModeBuildings::kLimitExceeded;
-		} else if (total_count() == cnt_limit_by_aimode_) {
-			return Widelands::AiModeBuildings::kOnLimit;
-		} else {
-			return Widelands::AiModeBuildings::kAnotherAllowed;
-		}
-	}
-	bool buildable(Widelands::Player& player_) {
-		return is_buildable_ && player_.is_building_type_allowed(id);
-	}
+	uint32_t last_dismantle_time;
+	uint32_t construction_decision_time;
+	uint32_t last_building_built;
+
+	uint32_t unoccupied_count;
+
+	bool build_material_shortage;
+
+
 };
 
 struct ProductionSiteObserver {
 	Widelands::ProductionSite* site;
-	uint32_t built_time_;
-	uint32_t unoccupied_till_;
-	uint8_t stats_zero_;
-	uint32_t no_resources_since_;
+	uint32_t built_time;
+	uint32_t unoccupied_till;
+	uint8_t stats_zero;
+	uint32_t no_resources_since;
 	BuildingObserver* bo;
 };
 
@@ -490,7 +397,7 @@
 	uint8_t checks;
 	// when considering attack most military sites are inside territory and should be skipped during
 	// evaluation
-	bool enemies_nearby_;
+	bool enemies_nearby;
 };
 
 struct TrainingSiteObserver {
@@ -505,8 +412,8 @@
 
 struct ShipObserver {
 	Widelands::Ship* ship;
-	Widelands::Coords expedition_start_point_;
-	std::unordered_set<uint32_t> visited_spots_;
+	Widelands::Coords expedition_start_point;
+	std::unordered_set<uint32_t> visited_spots;
 
 	// a ship circumvents all islands in the same direction, the value
 	// is assigned only once
@@ -516,9 +423,9 @@
 };
 
 struct WareObserver {
-	uint8_t producers_;
-	uint8_t consumers_;
-	uint8_t preciousness_;
+	uint8_t producers;
+	uint8_t consumers;
+	uint8_t preciousness;
 };
 
 // Computer player does not get notification messages about enemy militarysites
@@ -528,7 +435,9 @@
 // Also AI test more such targets when considering attack and calculated score is
 // is stored in the observer
 struct EnemySiteObserver {
-	bool warehouse_;
+	EnemySiteObserver();
+
+	bool is_warehouse;
 	int32_t attack_soldiers_strength;
 	int32_t defenders_strength;
 	uint8_t stationed_soldiers;
@@ -537,60 +446,78 @@
 	int16_t score;
 	Widelands::ExtendedBool mines_nearby;
 	int16_t no_attack_counter;
-
-	EnemySiteObserver()
-	   : warehouse_(false),
-	     attack_soldiers_strength(0),
-	     defenders_strength(0),
-	     stationed_soldiers(0),
-	     last_time_attackable(std::numeric_limits<uint32_t>::max()),
-	     last_tested(0),
-	     score(0),
-	     mines_nearby(Widelands::ExtendedBool::kUnset),
-	     no_attack_counter(0) {
-	}
 };
 
 // as all mines have 3 levels, AI does not know total count of mines per mined material
 // so this observer will be used for this
 struct MineTypesObserver {
+	MineTypesObserver();
+
+	uint16_t total_count() const;
+
 	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 {
+	MilitarySiteSizeObserver();
+
 	uint16_t in_construction;
 	uint16_t finished;
-
-	MilitarySiteSizeObserver() : in_construction(0), finished(0) {
-	}
 };
 
 // this represents a scheduler task
 struct SchedulerTask {
+	SchedulerTask(const uint32_t time, const Widelands::SchedulerTaskId t, const uint8_t p, const char* d);
+
+	bool operator<(SchedulerTask other) const;
+
 	uint32_t due_time;
 	Widelands::SchedulerTaskId id;
 	// used to sort jobs when AI has to perform more jobs at once
 	uint8_t priority;
 	// used only for debug purposes
 	std::string descr;
-
-	bool operator<(SchedulerTask other) const {
-		return priority > other.priority;
-	}
-
-	SchedulerTask
-		(const uint32_t time, const Widelands::SchedulerTaskId t, const uint8_t p, const char* d):
-		due_time(time), id(t), priority(p), descr(d) {}
-
-};
+};
+
+// List of blocked fields with block time, with some accompanying functions
+struct BlockedFields {
+	void add(Coords coords, uint32_t till);
+	uint32_t count();
+	void remove_expired(uint32_t gametime);
+	bool is_blocked(Coords coords);
+
+private:
+	// <hash of field coordinates, time till blocked>
+	std::map<uint32_t, uint32_t> blocked_fields_;
+};
+
+// This is a struct that stores strength of players, info on teams and provides some outputs from these data
+struct PlayersStrengths {
+	struct PlayerStat {
+		PlayerStat();
+		PlayerStat(Widelands::TeamNumber tc, uint32_t pp);
+
+		Widelands::TeamNumber team_number;
+		uint32_t players_power;
+	};
+
+	// Inserting/updating data
+	void add(Widelands::PlayerNumber pn, Widelands::TeamNumber tn, uint32_t pp);
+	void recalculate_team_power();
+
+	// This is strength of player plus third of strength of other members of his team
+	uint32_t get_modified_player_power(Widelands::PlayerNumber pn);
+	bool players_in_same_team(Widelands::PlayerNumber pl1, Widelands::PlayerNumber pl2);
+	bool strong_enough(Widelands::PlayerNumber pl);
+
+	// This is the core part of this struct
+	std::map<Widelands::PlayerNumber, PlayerStat> all_stats;
+
+	// Number of team, sum of players' strength
+	std::map<Widelands::TeamNumber, uint32_t> team_powers;
+};
+} // namespace Widelands
 
 #endif  // end of include guard: WL_AI_AI_HELP_STRUCTS_H

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2016-02-18 08:42:46 +0000
+++ src/ai/defaultai.cc	2016-02-22 08:51:02 +0000
@@ -75,6 +75,10 @@
 constexpr uint32_t kNever = std::numeric_limits<uint32_t>::max();
 constexpr uint32_t kNoExpedition = 0;
 
+// following two are used for roads management, for creating shortcuts and dismantling dispensable roads
+constexpr int32_t kSpotsTooLittle = 15;
+constexpr int32_t kSpotsEnough = 25;
+
 // this is intended for map developers, by default should be off
 constexpr bool kPrintStats = false;
 
@@ -477,9 +481,9 @@
 
 	wares.resize(game().tribes().nrwares());
 	for (DescriptionIndex i = 0; i < static_cast<DescriptionIndex>(game().tribes().nrwares()); ++i) {
-		wares.at(i).producers_ = 0;
-		wares.at(i).consumers_ = 0;
-		wares.at(i).preciousness_ = game().tribes().get_ware_descr(i)->preciousness(tribe_->name());
+		wares.at(i).producers = 0;
+		wares.at(i).consumers = 0;
+		wares.at(i).preciousness = game().tribes().get_ware_descr(i)->preciousness(tribe_->name());
 	}
 
 	const DescriptionIndex& nr_buildings = game().tribes().nrbuildings();
@@ -499,116 +503,117 @@
 		bo.name = building_name.c_str();
 		bo.id = building_index;
 		bo.desc = &bld;
-		bo.type = BuildingObserver::BORING;
-		bo.cnt_built_ = 0;
-		bo.cnt_under_construction_ = 0;
-		bo.cnt_target_ = 1;  // default for everything
-		bo.cnt_limit_by_aimode_ = std::numeric_limits<int32_t>::max();
-		bo.stocklevel_ = 0;
+		bo.type = BuildingObserver::Type::kBoring;
+		bo.cnt_built = 0;
+		bo.cnt_under_construction = 0;
+		bo.cnt_target = 1;  // default for everything
+		bo.cnt_limit_by_aimode = std::numeric_limits<int32_t>::max();
+		bo.stocklevel = 0;
 		bo.stocklevel_time = 0;
-		bo.last_dismantle_time_ = 0;
+		bo.last_dismantle_time = 0;
 		// this is set to negative number, otherwise the AI would wait 25 sec
 		// after game start not building anything
-		bo.construction_decision_time_ = -60 * 60 * 1000;
-		bo.build_material_shortage_ = false;
-		bo.production_hint_ = kUncalculated;
-		bo.current_stats_ = 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_rocks_ = bh.is_graniteproducer();
-		bo.need_water_ = bh.get_needs_water();
-		bo.mines_water_ = bh.mines_water();
-		bo.recruitment_ = bh.for_recruitment();
-		bo.space_consumer_ = bh.is_space_consumer();
-		bo.expansion_type_ = bh.is_expansion_type();
-		bo.fighting_type_ = bh.is_fighting_type();
-		bo.mountain_conqueror_ = bh.is_mountain_conqueror();
-		bo.prohibited_till_ = bh.get_prohibited_till() * 1000;  // value in conf is in seconds
-		bo.forced_after_ = bh.get_forced_after() * 1000;        // value in conf is in seconds
-		bo.is_port_ = bld.get_isport();
-		bo.trainingsite_type_ = TrainingSiteType::kNoTS;
-		bo.upgrade_substitutes_ = false;
-		bo.upgrade_extends_ = false;
-		bo.built_mat_producer_ = false;
-		bo.max_preciousness_ = 0;
-		bo.max_needed_preciousness_ = 0;
+		bo.construction_decision_time = -60 * 60 * 1000;
+		bo.last_building_built = kNever;
+		bo.build_material_shortage = false;
+		bo.production_hint = kUncalculated;
+		bo.current_stats = 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_rocks = bh.is_graniteproducer();
+		bo.need_water = bh.get_needs_water();
+		bo.mines_water = bh.mines_water();
+		bo.recruitment = bh.for_recruitment();
+		bo.space_consumer = bh.is_space_consumer();
+		bo.expansion_type = bh.is_expansion_type();
+		bo.fighting_type = bh.is_fighting_type();
+		bo.mountain_conqueror = bh.is_mountain_conqueror();
+		bo.prohibited_till = bh.get_prohibited_till() * 1000;  // value in conf is in seconds
+		bo.forced_after = bh.get_forced_after() * 1000;        // value in conf is in seconds
+		bo.is_port = bld.get_isport();
+		bo.trainingsite_type = TrainingSiteType::kNoTS;
+		bo.upgrade_substitutes = false;
+		bo.upgrade_extends = false;
+		bo.produces_building_material = false;
+		bo.max_preciousness = 0;
+		bo.max_needed_preciousness = 0;
 
 		if (bh.renews_map_resource()) {
-			bo.production_hint_ = tribe_->safe_ware_index(bh.get_renews_map_resource());
+			bo.production_hint = tribe_->safe_ware_index(bh.get_renews_map_resource());
 		}
 
 		// I just presume cut wood is named "log" in the game
-		if (tribe_->safe_ware_index("log") == bo.production_hint_) {
-			bo.plants_trees_ = true;
+		if (tribe_->safe_ware_index("log") == bo.production_hint) {
+			bo.plants_trees = true;
 		} else {
-			bo.plants_trees_ = false;
+			bo.plants_trees = false;
 		}
 
 	// Is total count of this building limited by AI mode?
 	if (type_ == DefaultAI::Type::kVeryWeak && bh.get_very_weak_ai_limit() >= 0) {
-		bo.cnt_limit_by_aimode_ = bh.get_very_weak_ai_limit();
+		bo.cnt_limit_by_aimode = bh.get_very_weak_ai_limit();
 		log (" %d: AI 'very weak' mode: applying limit %d building(s) for %s\n",
 		player_number(),
-		bo.cnt_limit_by_aimode_,
+		bo.cnt_limit_by_aimode,
 		bo.name);
 	}
 	if (type_ == DefaultAI::Type::kWeak && bh.get_weak_ai_limit() >= 0) {
-		bo.cnt_limit_by_aimode_ = bh.get_weak_ai_limit();
+		bo.cnt_limit_by_aimode = bh.get_weak_ai_limit();
 		log (" %d: AI 'weak' mode: applying limit %d building(s) for %s\n",
 		player_number(),
-		bo.cnt_limit_by_aimode_,
+		bo.cnt_limit_by_aimode,
 		bo.name);
 	}
 
 		// Read all interesting data from ware producing buildings
 		if (bld.type() == MapObjectType::PRODUCTIONSITE) {
 			const ProductionSiteDescr& prod = dynamic_cast<const ProductionSiteDescr&>(bld);
-			bo.type = bld.get_ismine() ? BuildingObserver::MINE : BuildingObserver::PRODUCTIONSITE;
+			bo.type = bld.get_ismine() ? BuildingObserver::Type::kMine : BuildingObserver::Type::kProductionsite;
 			for (const WareAmount& temp_input : prod.inputs()) {
-				bo.inputs_.push_back(temp_input.first);
+				bo.inputs.push_back(temp_input.first);
 			}
 			for (const DescriptionIndex& temp_output : prod.output_ware_types()) {
-				bo.outputs_.push_back(temp_output);
+				bo.outputs.push_back(temp_output);
 			}
 
-			if (bo.type == BuildingObserver::MINE) {
+			if (bo.type == BuildingObserver::Type::kMine) {
 				// get the resource needed by the mine
 				if (bh.get_mines()) {
-					bo.mines_ = game().world().get_resource(bh.get_mines());
+					bo.mines = game().world().get_resource(bh.get_mines());
 				}
 
-				bo.mines_percent_ = bh.get_mines_percent();
+				bo.mines_percent = bh.get_mines_percent();
 
 				// populating mines_per_type map
-				if (mines_per_type.count(bo.mines_) == 0) {
-					mines_per_type[bo.mines_] = MineTypesObserver();
+				if (mines_per_type.count(bo.mines) == 0) {
+					mines_per_type[bo.mines] = MineTypesObserver();
 				}
 			}
 
 			// here we identify hunters
-			if (bo.outputs_.size() == 1 && tribe_->safe_ware_index("meat") == bo.outputs_.at(0)) {
-				bo.is_hunter_ = true;
+			if (bo.outputs.size() == 1 && tribe_->safe_ware_index("meat") == bo.outputs.at(0)) {
+				bo.is_hunter = true;
 			} else {
-				bo.is_hunter_ = false;
+				bo.is_hunter = false;
 			}
 
 			// and fishers
-			if (bo.outputs_.size() == 1 && tribe_->safe_ware_index("fish") == bo.outputs_.at(0)) {
-				bo.is_fisher_ = true;
+			if (bo.outputs.size() == 1 && tribe_->safe_ware_index("fish") == bo.outputs.at(0)) {
+				bo.is_fisher = true;
 			} else {
-				bo.is_fisher_ = false;
+				bo.is_fisher = false;
 			}
 
-			bo.is_shipyard_ = bh.is_shipyard();
+			bo.is_shipyard = bh.is_shipyard();
 
 			// now we find out if the upgrade of the building is a full substitution
 			// (produces all wares as current one)
 			const DescriptionIndex enhancement = bld.enhancement();
-			if (enhancement != INVALID_INDEX && bo.type == BuildingObserver::PRODUCTIONSITE) {
+			if (enhancement != INVALID_INDEX && bo.type == BuildingObserver::Type::kProductionsite) {
 				std::unordered_set<DescriptionIndex> enh_outputs;
 				const ProductionSiteDescr& enh_prod
 					=
@@ -620,23 +625,23 @@
 				}
 				// now testing outputs of current building
 				// and comparing
-				bo.upgrade_substitutes_ = true;
-				for (DescriptionIndex ware : bo.outputs_) {
+				bo.upgrade_substitutes = true;
+				for (DescriptionIndex ware : bo.outputs) {
 					if (enh_outputs.count(ware) == 0) {
-						bo.upgrade_substitutes_ = false;
+						bo.upgrade_substitutes = false;
 						break;
 					}
 				}
 
 				std::unordered_set<DescriptionIndex> cur_outputs;
 				// collecting wares that are produced in enhanced building
-				for (const DescriptionIndex& ware : bo.outputs_) {
+				for (const DescriptionIndex& ware : bo.outputs) {
 						cur_outputs.insert(ware);
 					}
-				bo.upgrade_extends_ = false;
+				bo.upgrade_extends = false;
 				for (DescriptionIndex ware : enh_outputs) {
 					if (cur_outputs.count(ware) == 0) {
-						bo.upgrade_extends_ = true;
+						bo.upgrade_extends = true;
 						break;
 					}
 				}
@@ -644,23 +649,23 @@
 
 			// now we identify producers of critical build materials
 			// hardwood now
-			for (DescriptionIndex ware : bo.outputs_) {
+			for (DescriptionIndex 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;
+						bo.produces_building_material = true;
 				}
 			}
 		continue;
 		}
 
-		// now for every military building, we fill critical_built_mat_ vector
+		// now for every military building, we fill critical_building_material vector
 		// with critical construction wares
 		// non critical are excluded (see below)
 		if (bld.type() == MapObjectType::MILITARYSITE) {
-			bo.type = BuildingObserver::MILITARYSITE;
+			bo.type = BuildingObserver::Type::kMilitarysite;
 			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 (well, various types of wood)
@@ -669,28 +674,28 @@
 				    tribe_->ware_index("planks") == temp_buildcosts.first)
 					continue;
 
-				bo.critical_built_mat_.push_back(temp_buildcosts.first);
+				bo.critical_building_material.push_back(temp_buildcosts.first);
 			}
 			continue;
 		}
 
 		if (bld.type() == MapObjectType::WAREHOUSE) {
-			bo.type = BuildingObserver::WAREHOUSE;
+			bo.type = BuildingObserver::Type::kWarehouse;
 			continue;
 		}
 
 		if (bld.type() == MapObjectType::TRAININGSITE) {
-			bo.type = BuildingObserver::TRAININGSITE;
+			bo.type = BuildingObserver::Type::kTrainingsite;
 			const TrainingSiteDescr& train = dynamic_cast<const TrainingSiteDescr&>(bld);
 			for (const WareAmount& temp_input : train.inputs()) {
-				bo.inputs_.push_back(temp_input.first);
+				bo.inputs.push_back(temp_input.first);
 
 				// collecting subsitutes
 				if (tribe_->ware_index("meat") == temp_input.first ||
 				    tribe_->ware_index("fish") == temp_input.first ||
 				    tribe_->ware_index("smoked_meat") == temp_input.first ||
 				    tribe_->ware_index("smoked_fish") == temp_input.first) {
-					bo.substitute_inputs_.insert(temp_input.first);
+					bo.substitute_inputs.insert(temp_input.first);
 				}
 
 				for (const std::pair<unsigned char, unsigned char>& temp_buildcosts : train.buildcost()) {
@@ -698,19 +703,19 @@
 					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.critical_building_material.push_back(temp_buildcosts.first);
 					}
 				}
 			}
-			bo.trainingsite_type_ = bh.get_trainingsite_type();
+			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
-			assert(bo.trainingsite_type_ != TrainingSiteType::kNoTS);
+			assert(bo.trainingsite_type != TrainingSiteType::kNoTS);
 			continue;
 		}
 
 		if (bld.type() == MapObjectType::CONSTRUCTIONSITE) {
-			bo.type = BuildingObserver::CONSTRUCTIONSITE;
+			bo.type = BuildingObserver::Type::kConstructionsite;
 			continue;
 		}
 	}
@@ -763,7 +768,7 @@
 	for (const Coords& c : map.get_port_spaces()) {
 		MapRegion<Area<FCoords>> mr(map, Area<FCoords>(map.get_fcoords(c), 3));
 		do {
-			const int32_t hash = coords_hash(map.get_fcoords(*(mr.location().field)));
+			const int32_t hash = map.get_fcoords(*(mr.location().field)).hash();
 			if (port_reserved_coords.count(hash) == 0)
 				port_reserved_coords.insert(hash);
 		} while (mr.advance(map));
@@ -773,7 +778,7 @@
 		map.get_tln(c, &c_nw);
 		MapRegion<Area<FCoords>> mr_nw(map, Area<FCoords>(map.get_fcoords(c_nw), 3));
 		do {
-			const int32_t hash = coords_hash(map.get_fcoords(*(mr_nw.location().field)));
+			const int32_t hash = map.get_fcoords(*(mr_nw.location().field)).hash();
 			if (port_reserved_coords.count(hash) == 0)
 				port_reserved_coords.insert(hash);
 		} while (mr_nw.advance(map));
@@ -827,13 +832,11 @@
 
 	// blocking space consumers vicinity (when reloading a game)
 	for (const ProductionSiteObserver& ps_obs : productionsites) {
-		if (ps_obs.bo->space_consumer_ && !ps_obs.bo->plants_trees_) {
+		if (ps_obs.bo->space_consumer && !ps_obs.bo->plants_trees) {
 			MapRegion<Area<FCoords>> mr(
 			   map, Area<FCoords>(map.get_fcoords(ps_obs.site->get_position()), 4));
 			do {
-				BlockedField blocked2(
-				   map.get_fcoords(*(mr.location().field)), game().get_gametime() + 20 * 60 * 1000);
-				blocked_fields.push_back(blocked2);
+				blocked_fields.add(mr.location(), game().get_gametime() + 20 * 60 * 1000);
 			} while (mr.advance(map));
 		}
 	}
@@ -887,7 +890,7 @@
 
 	// we test 40 fields that were update more than 1 seconds ago
 	while (!buildable_fields.empty() &&
-	       (buildable_fields.front()->field_info_expiration_ - kFieldInfoExpiration + 1000) <=
+			 (buildable_fields.front()->field_info_expiration - kFieldInfoExpiration + 1000) <=
 	          gametime &&
 	       i < 40) {
 		BuildableField& bf = *buildable_fields.front();
@@ -908,7 +911,7 @@
 		}
 
 		update_buildable_field(bf);
-		bf.field_info_expiration_ = gametime + kFieldInfoExpiration;
+		bf.field_info_expiration = gametime + kFieldInfoExpiration;
 		buildable_fields.push_back(&bf);
 		buildable_fields.pop_front();
 
@@ -929,7 +932,7 @@
 	// we test 30 fields that were updated more than 1 seconds ago
 	// to avoid re-test of the same field twice
 	while (!mineable_fields.empty() &&
-	       (mineable_fields.front()->field_info_expiration_ - kMineFieldInfoExpiration + 1000) <=
+			 (mineable_fields.front()->field_info_expiration - kMineFieldInfoExpiration + 1000) <=
 	          gametime &&
 	       i < 30) {
 		MineableField* mf = mineable_fields.front();
@@ -950,7 +953,7 @@
 		}
 
 		update_mineable_field(*mf);
-		mf->field_info_expiration_ = gametime + kMineFieldInfoExpiration;
+		mf->field_info_expiration = gametime + kMineFieldInfoExpiration;
 		mineable_fields.push_back(mf);
 		mineable_fields.pop_front();
 
@@ -1003,22 +1006,22 @@
 	// look if there is any unowned land nearby
 	Map& map = game().map();
 	const uint32_t gametime = game().get_gametime();
-	FindNodeUnowned find_unowned(player_, game());
+	FindNodeUnownedWalkable find_unowned_walkable(player_, game());
 	FindNodeUnownedMineable find_unowned_mines_pots(player_, game());
 	PlayerNumber const pn = player_->player_number();
 	const World& world = game().world();
-	field.unowned_land_nearby_ =
-	   map.find_fields(Area<FCoords>(field.coords, range), nullptr, find_unowned);
+	field.unowned_land_nearby =
+	   map.find_fields(Area<FCoords>(field.coords, range), nullptr, find_unowned_walkable);
 	FindNodeAllyOwned find_ally(player_, game(), player_number());
 	const int32_t AllyOwnedFields =
 	   map.find_fields(Area<FCoords>(field.coords, 3), nullptr, find_ally);
 
-	field.near_border_ = false;
+	field.near_border = false;
 	if (AllyOwnedFields > 0) {
-		field.near_border_ = true;
-	} else if (field.unowned_land_nearby_ > 0) {
-		if (map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_unowned) > 0) {
-			field.near_border_ = true;
+		field.near_border = true;
+	} else if (field.unowned_land_nearby > 0) {
+		if (map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_unowned_walkable) > 0) {
+			field.near_border = true;
 		}
 	}
 
@@ -1026,15 +1029,15 @@
 	// 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) {
+	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;
+			field.last_resources_check_time = gametime;
 	}
 
 	// to save some CPU
 	if (mines_.size() > 8 && !resource_count_now) {
-		field.unowned_mines_spots_nearby_ = 0;
+		field.unowned_mines_spots_nearby = 0;
 	} else {
 		uint32_t close_mines =
 		   map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_unowned_mines_pots);
@@ -1043,26 +1046,26 @@
 		                   nullptr,
 		                   find_unowned_mines_pots);
 		distant_mines = distant_mines - close_mines;
-		field.unowned_mines_spots_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_spots_nearby_ += 15;
+			field.unowned_mines_spots_nearby += 15;
 		}
 	}
 
 	// identifying portspace fields
-	if (!field.is_portspace_) {  // if we know it, no need to do it once more
+	if (!field.is_portspace) {  // if we know it, no need to do it once more
 		if (player_->get_buildcaps(field.coords) & BUILDCAPS_PORT) {
-			field.is_portspace_ = true;
+			field.is_portspace = true;
 		}
 	}
 
 	// testing for near portspaces
-	if (field.portspace_nearby_ == Widelands::ExtendedBool::kUnset) {
-		field.portspace_nearby_ = ExtendedBool::kFalse;
-		MapRegion<Area<FCoords>> mr(map, Area<FCoords>(field.coords, 2));
+	if (field.portspace_nearby == Widelands::ExtendedBool::kUnset) {
+		field.portspace_nearby = ExtendedBool::kFalse;
+		MapRegion<Area<FCoords>> mr(map, Area<FCoords>(field.coords, 4));
 		do {
-			if (port_reserved_coords.count(coords_hash(mr.location())) > 0) {
-				field.portspace_nearby_ = ExtendedBool::kTrue;
+			if (port_reserved_coords.count(mr.location().hash()) > 0) {
+				field.portspace_nearby = ExtendedBool::kTrue;
 				break;
 			}
 		} while (mr.advance(map));
@@ -1075,23 +1078,23 @@
 		nearest_distance = std::min(nearest_distance, actual_distance);
 	}
 	if (nearest_distance < 15) {
-		field.port_nearby_ = true;
+		field.port_nearby = true;
 	} else {
-		field.port_nearby_ = false;
+		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;
+	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;
+			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_);
+	assert ((player_->get_buildcaps(field.coords) & BUILDCAPS_SIZEMASK) <= field.max_buildcap_nearby);
 
 	// collect information about resources in the area
 	std::vector<ImmovableFound> immovables;
@@ -1102,50 +1105,50 @@
 	// (second is used in check_militarysites)
 	if (!military) {
 		int32_t const tree_attr = MapObjectDescr::get_attribute_id("tree");
-		field.preferred_ = false;
-		field.enemy_nearby_ = false;
-		field.area_military_capacity_ = 0;
-		field.military_loneliness_ = 1000;  // instead of floats(v-
-		field.area_military_presence_ = 0;
-		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());
+		field.preferred = false;
+		field.enemy_nearby = false;
+		field.area_military_capacity = 0;
+		field.military_loneliness = 1000;  // instead of floats(v-
+		field.area_military_presence = 0;
+		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;
 
-		if (field.water_nearby_ == kUncalculated) {
+		if (field.water_nearby == kUncalculated) {
 
 			FindNodeWater find_water(game().world());
 			map.find_fields(Area<FCoords>(field.coords, 5), &water_list, find_water);
-			field.water_nearby_ = water_list.size();
+			field.water_nearby = water_list.size();
 
 			if (resource_necessity_water_needed_) {  // for atlanteans
 				map.find_fields(Area<FCoords>(field.coords, 14), &water_list, find_water);
-				field.distant_water_ = water_list.size() - field.water_nearby_;
+				field.distant_water = water_list.size() - field.water_nearby;
 			}
 		}
 
 		// counting fields with fish
-		if (field.water_nearby_ > 0 && (field.fish_nearby_ == kUncalculated || resource_count_now)) {
+		if (field.water_nearby > 0 && (field.fish_nearby == kUncalculated || resource_count_now)) {
 			map.find_fields(Area<FCoords>(field.coords, 6),
 			                &resource_list,
 			                FindNodeResource(world.get_resource("fish")));
-			field.fish_nearby_ = resource_list.size();
+			field.fish_nearby = resource_list.size();
 		}
 
 		// counting fields with critters (game)
 		// not doing this always, this does not change fast
 		if (resource_count_now) {
 			map.find_bobs(Area<FCoords>(field.coords, 6), &critters_list, FindBobCritter());
-			field.critters_nearby_ = critters_list.size();
+			field.critters_nearby = critters_list.size();
 		}
 
 		FCoords fse;
@@ -1154,7 +1157,7 @@
 		if (BaseImmovable const* const imm = fse.field->get_immovable()) {
 			if (dynamic_cast<Flag const*>(imm) ||
 			    (dynamic_cast<Road const*>(imm) && (fse.field->nodecaps() & BUILDCAPS_FLAG))) {
-				field.preferred_ = true;
+				field.preferred = true;
 			}
 		}
 
@@ -1167,7 +1170,7 @@
 				// allied sites should be counted for military influence
 				if (player_immovable->owner().player_number() != pn) {
 					if (player_->is_hostile(player_immovable->owner())) {
-						field.enemy_nearby_ = true;
+						field.enemy_nearby = true;
 					}
 
 					continue;
@@ -1186,26 +1189,26 @@
 			}
 
 			if (immovables.at(i).object->has_attribute(tree_attr)) {
-				++field.trees_nearby_;
+				++field.trees_nearby;
 			}
 		}
 
 		// Rocks are not renewable, we will count them only if previous state is nonzero
-		if (field.rocks_nearby_ > 0 && resource_count_now) {
+		if (field.rocks_nearby > 0 && resource_count_now) {
 
-			field.rocks_nearby_ =
+			field.rocks_nearby =
 				map.find_immovables(Area<FCoords>(map.get_fcoords(field.coords), 6),
 					nullptr,
 						FindImmovableAttribute(MapObjectDescr::get_attribute_id("rocks")));
 
 			// adding 10 if rocks found
-			field.rocks_nearby_ = (field.rocks_nearby_ > 0) ? field.rocks_nearby_ + 10:0;
+			field.rocks_nearby = (field.rocks_nearby > 0) ? field.rocks_nearby + 10:0;
 		}
 
 		// ground water is not renewable and its amount can only fall, we will count them only if
 		// previous state is nonzero
-		if (field.ground_water_ > 0) {
-			field.ground_water_ = field.coords.field->get_resources_amount();
+		if (field.ground_water > 0) {
+			field.ground_water = field.coords.field->get_resources_amount();
 		}
 	}
 
@@ -1214,12 +1217,12 @@
 	// we get immovables with higher radius
 	immovables.clear();
 	map.find_immovables(Area<FCoords>(field.coords, (range < 11) ? 11 : range), &immovables);
-	field.military_stationed_ = 0;
-	field.military_unstationed_ = 0;
-	field.military_in_constr_nearby_ = 0;
-	field.area_military_capacity_ = 0;
-	field.military_loneliness_ = 1000;
-	field.area_military_presence_ = 0;
+	field.military_stationed = 0;
+	field.military_unstationed = 0;
+	field.military_in_constr_nearby = 0;
+	field.area_military_capacity = 0;
+	field.military_loneliness = 1000;
+	field.area_military_presence = 0;
 
 	for (uint32_t i = 0; i < immovables.size(); ++i) {
 
@@ -1233,7 +1236,7 @@
 			// allied sites should be counted for military influence
 			if (player_immovable->owner().player_number() != pn) {
 				if (player_->is_hostile(player_immovable->owner())) {
-					field.enemy_nearby_ = true;
+					field.enemy_nearby = true;
 				}
 				continue;
 			}
@@ -1249,12 +1252,12 @@
 					const int32_t radius = target_ms_d->get_conquers() + 4;
 
 					if (radius > dist) {
-						field.area_military_capacity_ +=
+						field.area_military_capacity +=
 						   target_ms_d->get_max_number_of_soldiers() / 2 + 1;
 						if (field.coords != immovables.at(i).coords) {
-							field.military_loneliness_ *= static_cast<double_t>(dist) / radius;
+							field.military_loneliness *= static_cast<double_t>(dist) / radius;
 						}
-						field.military_in_constr_nearby_ += 1;
+						field.military_in_constr_nearby += 1;
 					}
 				}
 			}
@@ -1265,17 +1268,17 @@
 
 				if (radius > dist) {
 
-					field.area_military_capacity_ += militarysite->max_soldier_capacity();
-					field.area_military_presence_ += militarysite->stationed_soldiers().size();
+					field.area_military_capacity += militarysite->max_soldier_capacity();
+					field.area_military_presence += militarysite->stationed_soldiers().size();
 
 					if (militarysite->stationed_soldiers().empty()) {
-						field.military_unstationed_ += 1;
+						field.military_unstationed += 1;
 					} else {
-						field.military_stationed_ += 1;
+						field.military_stationed += 1;
 					}
 
 					if (field.coords != immovables.at(i).coords) {
-						field.military_loneliness_ *= static_cast<double_t>(dist) / radius;
+						field.military_loneliness *= static_cast<double_t>(dist) / radius;
 					}
 				}
 			}
@@ -1289,15 +1292,15 @@
 	std::vector<ImmovableFound> immovables;
 	Map& map = game().map();
 	map.find_immovables(Area<FCoords>(field.coords, 5), &immovables);
-	field.preferred_ = false;
-	field.mines_nearby_ = 0;
+	field.preferred = false;
+	field.mines_nearby = 0;
 	FCoords fse;
 	map.get_brn(field.coords, &fse);
 
 	if (BaseImmovable const* const imm = fse.field->get_immovable()) {
 		if (dynamic_cast<Flag const*>(imm) ||
 		    (dynamic_cast<Road const*>(imm) && (fse.field->nodecaps() & BUILDCAPS_FLAG))) {
-			field.preferred_ = true;
+			field.preferred = true;
 		}
 	}
 
@@ -1307,15 +1310,15 @@
 				continue;
 			}
 			if (bld->descr().get_ismine()) {
-				if (get_building_observer(bld->descr().name().c_str()).mines_ ==
+				if (get_building_observer(bld->descr().name().c_str()).mines ==
 				    field.coords.field->get_resources()) {
-					++field.mines_nearby_;
+					++field.mines_nearby;
 				}
 			} else if (upcast(ConstructionSite const, cs, bld)) {
 				if (cs->building().get_ismine()) {
-					if (get_building_observer(cs->building().name().c_str()).mines_ ==
+					if (get_building_observer(cs->building().name().c_str()).mines ==
 					    field.coords.field->get_resources()) {
-						++field.mines_nearby_;
+						++field.mines_nearby;
 					}
 				}
 			}
@@ -1323,9 +1326,9 @@
 	}
 
 	// 0 is default, and thus indicates that counting must be done
-	if (field.same_mine_fields_nearby_ == 0) {
+	if (field.same_mine_fields_nearby == 0) {
 		FindNodeMineable find_mines_spots_nearby(game(), field.coords.field->get_resources());
-		field.same_mine_fields_nearby_ =
+		field.same_mine_fields_nearby =
 		   map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_mines_spots_nearby);
 	}
 }
@@ -1336,14 +1339,14 @@
 
 	// Reset statistics for all buildings
 	for (uint32_t i = 0; i < buildings_.size(); ++i) {
-		buildings_.at(i).current_stats_ = 0;
-		buildings_.at(i).unoccupied_count_ = 0;
-		buildings_.at(i).unconnected_count_ = 0;
+		buildings_.at(i).current_stats = 0;
+		buildings_.at(i).unoccupied_count = 0;
+		buildings_.at(i).unconnected_count = 0;
 	}
 
 	// Check all available productionsites
 	for (uint32_t i = 0; i < productionsites.size(); ++i) {
-		assert(productionsites.front().bo->cnt_built_ > 0);
+		assert(productionsites.front().bo->cnt_built > 0);
 		// is connected
 		const bool connected_to_wh =
 		   !productionsites.front().site->get_economy()->warehouses().empty();
@@ -1351,20 +1354,20 @@
 		// unconnected buildings are excluded from statistics review
 		if (connected_to_wh) {
 			// Add statistics value
-			productionsites.front().bo->current_stats_ +=
+			productionsites.front().bo->current_stats +=
 			   productionsites.front().site->get_crude_statistics();
 
 			// counting fishers
-			if (productionsites.front().bo->is_fisher_) {
+			if (productionsites.front().bo->is_fisher) {
 				fishers_count += 1;
 			}
 
 			// Check whether this building is completely occupied
 			if (!productionsites.front().site->can_start_working()) {
-				productionsites.front().bo->unoccupied_count_ += 1;
+				productionsites.front().bo->unoccupied_count += 1;
 			}
 		} else {
-			productionsites.front().bo->unconnected_count_ += 1;
+			productionsites.front().bo->unconnected_count += 1;
 		}
 
 		// Now reorder the buildings
@@ -1385,7 +1388,7 @@
 	// for mines_ also
 	// Check all available mines
 	for (uint32_t i = 0; i < mines_.size(); ++i) {
-		assert(mines_.front().bo->cnt_built_ > 0);
+		assert(mines_.front().bo->cnt_built > 0);
 
 		const bool connected_to_wh =
 		   !mines_.front().site->get_economy()->warehouses().empty();
@@ -1393,13 +1396,13 @@
 		// unconnected mines are excluded from statistics review
 		if (connected_to_wh) {
 			// Add statistics value
-			mines_.front().bo->current_stats_ += mines_.front().site->get_statistics_percent();
+			mines_.front().bo->current_stats += mines_.front().site->get_statistics_percent();
 			// Check whether this building is completely occupied
 			if (!mines_.front().site->can_start_working()) {
-				mines_.front().bo->unoccupied_count_ += 1;
+				mines_.front().bo->unoccupied_count += 1;
 			}
 		} else {
-			mines_.front().bo->unconnected_count_ += 1;
+			mines_.front().bo->unconnected_count += 1;
 		}
 
 		// Now reorder the buildings
@@ -1409,9 +1412,9 @@
 
 	// Scale statistics down
 	for (uint32_t i = 0; i < buildings_.size(); ++i) {
-		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_count_);
+		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_count);
 		}
 	}
 }
@@ -1442,7 +1445,6 @@
 	}
 	// Just used for easy checking whether a mine or something else was built.
 	bool mine = false;
-	bool field_blocked = false;
 	uint32_t consumers_nearby_count = 0;
 	std::vector<int32_t> spots_avail;
 	spots_avail.resize(4);
@@ -1487,12 +1489,12 @@
 	// 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
+	// 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
+	// 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
 
 	// Bools below are helpers to improve readability of code
@@ -1515,7 +1517,7 @@
 		(vacant_mil_positions_ * 3 > static_cast<int32_t>(militarysites.size()));
 	const int32_t kUpperLimit = 325;
 	const int32_t kBottomLimit = 40; // to prevent too dense militarysites
-	// modifying least_military_score_, down if more military sites are needed and vice versa
+	// modifying least_military_score, down if more military sites are needed and vice versa
 	if (too_many_ms_constructionsites || too_many_vacant_mil || needs_boost_economy) {
 		if (persistent_data->least_military_score < kUpperLimit) { //no sense to let it grow too high
 			persistent_data->least_military_score += 20;
@@ -1635,12 +1637,7 @@
 	Coords proposed_coords;
 
 	// Remove outdated fields from blocker list
-	for (std::list<BlockedField>::iterator i = blocked_fields.begin(); i != blocked_fields.end();)
-		if (i->blocked_until_ < gametime) {
-			i = blocked_fields.erase(i);
-		} else {
-			++i;
-		}
+	blocked_fields.remove_expired(gametime);
 
 	// testing big military buildings, whether critical construction
 	// material is available (at least in amount of
@@ -1651,26 +1648,27 @@
 		}
 
 		// not doing this for non-military buildins
-		if (!(bo.type == BuildingObserver::MILITARYSITE || bo.type == BuildingObserver::TRAININGSITE))
+		if (!(bo.type == BuildingObserver::Type::kMilitarysite ||
+				bo.type == BuildingObserver::Type::kTrainingsite))
 			continue;
 
 		// and neither for small military buildings
-		if (bo.type == BuildingObserver::MILITARYSITE  && bo.desc->get_size() == BaseImmovable::SMALL)
+		if (bo.type == BuildingObserver::Type::kMilitarysite  && bo.desc->get_size() == BaseImmovable::SMALL)
 			continue;
 
-		bo.build_material_shortage_ = false;
+		bo.build_material_shortage = false;
 
 		// checking we have enough critical material on stock
-		for (uint32_t m = 0; m < bo.critical_built_mat_.size(); ++m) {
-			DescriptionIndex wt(static_cast<size_t>(bo.critical_built_mat_.at(m)));
+		for (uint32_t m = 0; m < bo.critical_building_material.size(); ++m) {
+			DescriptionIndex wt(static_cast<size_t>(bo.critical_building_material.at(m)));
 			uint32_t treshold = 3;
 			// generally trainingsites are more important
-			if (bo.type == BuildingObserver::TRAININGSITE) {
+			if (bo.type == BuildingObserver::Type::kTrainingsite) {
 				treshold = 2;
 			}
 
 			if (get_warehoused_stock(wt) < treshold) {
-				bo.build_material_shortage_ = true;
+				bo.build_material_shortage = true;
 				break;
 			}
 		}
@@ -1681,90 +1679,91 @@
 		BuildingObserver& bo = buildings_.at(j);
 
 		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;
+			bo.new_building = BuildingNecessity::kNotNeeded;
+		} else if (bo.type == BuildingObserver::Type::kProductionsite ||
+					  bo.type == BuildingObserver::Type::kMine) {
+
+			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()) {
-				if (bo.max_needed_preciousness_ <= 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()) {
+				if (bo.max_needed_preciousness <= 0) {
 					throw wexception("AI: Max presciousness must not be <= 0 for building: %s",
 										  bo.desc->name().c_str());
 				}
-			} else if (bo.new_building_ == BuildingNecessity::kForbidden) {
-				bo.max_needed_preciousness_ = 0;
+			} else if (bo.new_building == BuildingNecessity::kForbidden) {
+				bo.max_needed_preciousness = 0;
 			} else {
-				// For other situations we make sure max_needed_preciousness_ is zero
-				assert (bo.max_needed_preciousness_ == 0);
+				// For other situations we make sure max_needed_preciousness is zero
+				assert (bo.max_needed_preciousness == 0);
 			}
 
-			// Positive max_needed_preciousness_ says a building type is needed
+			// Positive max_needed_preciousness says a building type is needed
 			// here we increase or reset the counter
 			// The counter is added to score when considering new building
-			if (bo.max_needed_preciousness_ > 0) {
-				bo.new_building_overdue_ += 1;
+			if (bo.max_needed_preciousness > 0) {
+				bo.new_building_overdue += 1;
 			} else {
-				bo.new_building_overdue_ = 0;
+				bo.new_building_overdue = 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_;
+			// 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;
+					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;
+				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) {
+			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_);
+						bo.name, bo.total_count(), bo.unoccupied_count);
 					}
 				} else {
-					if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0) {
+					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_);
+						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.new_building_ = check_building_necessity(bo, PerfEvaluation::kForConstruction, gametime);
+		} else if (bo.type == BuildingObserver::Type::kMilitarysite) {
+			bo.new_building = check_building_necessity(bo.desc->get_size(), gametime);
+		} else if  (bo.type == BuildingObserver::Type::kTrainingsite) {
+			bo.new_building = check_building_necessity(bo, PerfEvaluation::kForConstruction, gametime);
 		} else if (bo.aimode_limit_status() != AiModeBuildings::kAnotherAllowed) {
-			bo.new_building_ = BuildingNecessity::kNotNeeded;
+			bo.new_building = BuildingNecessity::kNotNeeded;
 		} else {
-			bo.new_building_ = BuildingNecessity::kAllowed;
-			bo.primary_priority_ = 0;
+			bo.new_building = BuildingNecessity::kAllowed;
+			bo.primary_priority = 0;
 		}
 	}
 
@@ -1774,22 +1773,12 @@
 	     ++i) {
 		BuildableField* const bf = *i;
 
-		if (bf->field_info_expiration_ < gametime) {
+		if (bf->field_info_expiration < gametime) {
 			continue;
 		}
 
 		// Continue if field is blocked at the moment
-		field_blocked = false;
-
-		for (std::list<BlockedField>::iterator j = blocked_fields.begin(); j != blocked_fields.end();
-		     ++j) {
-			if (j->coords == bf->coords) {
-				field_blocked = true;
-			}
-		}
-
-		// continue;
-		if (field_blocked) {
+		if (blocked_fields.is_blocked(bf->coords)) {
 			continue;
 		}
 
@@ -1803,15 +1792,15 @@
 				continue;
 			}
 
-			if (bo.new_building_ == BuildingNecessity::kNotNeeded ||
-				bo.new_building_ == BuildingNecessity::kNeededPending ||
-				bo.new_building_ == BuildingNecessity::kForbidden) {
+			if (bo.new_building == BuildingNecessity::kNotNeeded ||
+				bo.new_building == BuildingNecessity::kNeededPending ||
+				bo.new_building == BuildingNecessity::kForbidden) {
 				continue;
 				}
 
-			assert (bo.new_building_ == BuildingNecessity::kForced ||
-			bo.new_building_ == BuildingNecessity::kNeeded ||
-			bo.new_building_ == BuildingNecessity::kAllowed);
+			assert (bo.new_building == BuildingNecessity::kForced ||
+			bo.new_building == BuildingNecessity::kNeeded ||
+			bo.new_building == BuildingNecessity::kAllowed);
 
 			assert(bo.aimode_limit_status() == AiModeBuildings::kAnotherAllowed);
 
@@ -1821,8 +1810,8 @@
 			}
 
 			// testing for reserved ports
-			if (!bo.is_port_) {
-				if (port_reserved_coords.count(coords_hash(bf->coords)) > 0) {
+			if (!bo.is_port) {
+				if (port_reserved_coords.count(bf->coords.hash()) > 0) {
 					continue;
 				}
 			}
@@ -1831,73 +1820,73 @@
 				continue;
 			}  // add randomnes and ease AI
 
-			if (bo.type == BuildingObserver::MINE) {
+			if (bo.type == BuildingObserver::Type::kMine) {
 				continue;
 			}
 
 			// here we do an exemption for lumberjacks, mainly in early stages of game
 			// sometimes the first one is not built and AI waits too long for second attempt
-			if (gametime - bo.construction_decision_time_ < kBuildingMinInterval && !bo.need_trees_) {
+			if (gametime - bo.construction_decision_time < kBuildingMinInterval && !bo.need_trees) {
 				continue;
 			}
 
-			if (!(bo.type == BuildingObserver::MILITARYSITE) && bo.cnt_under_construction_ >= 2) {
+			if (!(bo.type == BuildingObserver::Type::kMilitarysite) && bo.cnt_under_construction >= 2) {
 				continue;
 			}
 
 			int32_t prio = 0;  // score of a bulding on a field
 
-			if (bo.type == BuildingObserver::PRODUCTIONSITE) {
+			if (bo.type == BuildingObserver::Type::kProductionsite) {
 
 				// this can be only a well (as by now)
-				if (bo.mines_water_) {
+				if (bo.mines_water) {
 
-					if (bo.new_building_ == BuildingNecessity::kForced) {
-						assert (bo.total_count() - bo.unconnected_count_ == 0);
+					if (bo.new_building == BuildingNecessity::kForced) {
+						assert (bo.total_count() - bo.unconnected_count == 0);
 					}
 
-					if (bf->ground_water_ < 2) {
+					if (bf->ground_water < 2) {
 						continue;
 					}
 
-					prio = bo.primary_priority_;
+					prio = bo.primary_priority;
 
 					// keep wells more distant
-					if (bf->producers_nearby_.at(bo.outputs_.at(0)) > 2) {
+					if (bf->producers_nearby.at(bo.outputs.at(0)) > 2) {
 						continue;
 					}
 
 					// one well is forced
-					if (bo.new_building_ == BuildingNecessity::kForced) {
+					if (bo.new_building == BuildingNecessity::kForced) {
 						prio += 200;
 					}
 
-					prio += bf->ground_water_ - 2;
-
-				} else if (bo.need_trees_) {  // LUMBERJACS
-
-					prio = bo.primary_priority_;
+					prio += bf->ground_water - 2;
+
+				} else if (bo.need_trees) {  // LUMBERJACS
+
+					prio = bo.primary_priority;
 
 					prio += -20 + 200 / (bo.total_count() + 1);
 
-					if (bo.new_building_ == BuildingNecessity::kForced) {
+					if (bo.new_building == BuildingNecessity::kForced) {
 						prio *= 2;
-					} else if (bf->trees_nearby_ < 2 && bf->supporters_nearby_.at(bo.outputs_.at(0) == 0)) {
+					} else if (bf->trees_nearby < 2 && bf->supporters_nearby.at(bo.outputs.at(0) == 0)) {
 						continue;
 					}
 
 					// 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_rocks_) {
+					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_rocks) {
 
 					// Quarries are generally to be built everywhere where rocks are
 					// no matter the need for granite, as rocks are considered an obstacle
 					// to expansion
-					prio = 2 * bf->rocks_nearby_;
+					prio = 2 * bf->rocks_nearby;
 
 					// value is initialized with 1 but minimal value that can be
 					// calculated is 11
@@ -1905,75 +1894,75 @@
 						continue;
 					}
 
-					if (bo.total_count() - bo.unconnected_count_ == 0) {
+					if (bo.total_count() - bo.unconnected_count == 0) {
 						prio += 150;
 					}
 
 					if (bo.stocklevel_time < game().get_gametime() - 5 * 1000) {
-						bo.stocklevel_ = get_stocklevel(static_cast<size_t>(bo.production_hint_));
+						bo.stocklevel = get_stocklevel(static_cast<size_t>(bo.production_hint));
 						bo.stocklevel_time = game().get_gametime();
 					}
 
-					if (bo.stocklevel_ == 0) {
+					if (bo.stocklevel == 0) {
 						prio *= 2;
 					}
 
 					// to prevent to many quaries on one spot
-					prio = prio - 50 * bf->producers_nearby_.at(bo.outputs_.at(0));
-
-				} else if (bo.is_hunter_) {
-
-					if (bf->critters_nearby_ < 5) {
+					prio = prio - 50 * bf->producers_nearby.at(bo.outputs.at(0));
+
+				} else if (bo.is_hunter) {
+
+					if (bf->critters_nearby < 5) {
 						continue;
 					}
 
-					if (bo.new_building_ == BuildingNecessity::kForced) {
+					if (bo.new_building == BuildingNecessity::kForced) {
 						prio += 20;
 					}
 
 					// Overdue priority here
-					prio += bo.primary_priority_;
+					prio += bo.primary_priority;
 
-					prio += bf->supporters_nearby_.at(bo.outputs_.at(0)) * 5;
+					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
-
-					if (bf->water_nearby_ < 2 || bf->fish_nearby_ < 2) {
+					   (bf->critters_nearby * 3) - 8 - 5 * bf->producers_nearby.at(bo.outputs.at(0));
+
+				} else if (bo.is_fisher) {  // fisher
+
+					if (bf->water_nearby < 2 || bf->fish_nearby < 2) {
 						continue;
 					}
 
-					if (bo.new_building_ == BuildingNecessity::kForced) {
+					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) {
-					if (bo.plants_trees_) {
-						assert (bo.cnt_target_ > 0);
+					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) {
+					if (bo.plants_trees) {
+						assert (bo.cnt_target > 0);
 					} else {
-						bo.cnt_target_ =
+						bo.cnt_target =
 						   1 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 50;
 					}
 
 					// They have no own primary priority
-					assert(bo.primary_priority_ == 0);
-
-					if (bo.plants_trees_) {  // RANGERS
-
-						assert(bo.new_building_ == BuildingNecessity::kNeeded);
+					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) {
+						if (bf->trees_nearby > 25 && bo.total_count() >= 1) {
 							continue;
 						}
 
@@ -1989,107 +1978,107 @@
 						}
 
 						// considering producers
-						prio += std::min<uint8_t>(bf->producers_nearby_.at(bo.production_hint_), 4) * 5 -
+						prio += std::min<uint8_t>(bf->producers_nearby.at(bo.production_hint), 4) * 5 -
 						        new_buildings_stop_ * 15 -
-						       	bf->space_consumers_nearby_ * 5  -
-								  bf->rocks_nearby_ / 3 +
-						        bf->trees_nearby_ / 2 +
-						        std::min<uint8_t>(bf->supporters_nearby_.at(bo.production_hint_), 4) * 3;
+						       	bf->space_consumers_nearby * 5  -
+								  bf->rocks_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
 
 						// especially for fish breeders
-						if (bo.need_water_ && (bf->water_nearby_ < 6 || bf->fish_nearby_ < 6)) {
+						if (bo.need_water && (bf->water_nearby < 6 || bf->fish_nearby < 6)) {
 							continue;
 						}
-						if (bo.need_water_) {
-							prio += (-6 + bf->water_nearby_) / 3;
-							prio += (-6 + bf->fish_nearby_) / 3;
+						if (bo.need_water) {
+							prio += (-6 + bf->water_nearby) / 3;
+							prio += (-6 + bf->fish_nearby) / 3;
 						}
 
-						if ((bo.total_count() - bo.unconnected_count_) > bo.cnt_target_) {
+						if ((bo.total_count() - bo.unconnected_count) > bo.cnt_target) {
 							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 =
+							   get_stocklevel_by_hint(static_cast<size_t>(bo.production_hint));
 							bo.stocklevel_time = game().get_gametime();
 						}
-						if (bo.stocklevel_ > 50) {
+						if (bo.stocklevel > 50) {
 							continue;
 						}
 
 						if (bo.total_count() == 0) {
 							prio += 100;
-						} else  if (!bo.need_water_) {
+						} 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;
+						prio += bf->producers_nearby.at(bo.production_hint) * 10;
+						prio -= bf->supporters_nearby.at(bo.production_hint) * 20;
 
-						if (bf->enemy_nearby_) {
+						if (bf->enemy_nearby) {
 							prio -= 5;
 						}
 					}
 
-				} else if (bo.recruitment_ && !new_buildings_stop_) {
+				} else if (bo.recruitment && !new_buildings_stop_) {
 					// 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_count_) == 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)) {
+					    (bo.total_count() == 0 || bo.current_stats > 60)) {
 							prio = 10;
 						}
 				} else {  // finally normal productionsites
-					assert (bo.production_hint_ < 0);
+					assert (bo.production_hint < 0);
 
-					if (bo.new_building_ == BuildingNecessity::kForced) {
+					if (bo.new_building == BuildingNecessity::kForced) {
 						prio += 150;
-					} else if (bo.is_shipyard_) {
-						assert (bo.new_building_ == BuildingNecessity::kAllowed);
+					} else if (bo.is_shipyard) {
+						assert (bo.new_building == BuildingNecessity::kAllowed);
 						if (!seafaring_economy) {
 							continue;
 						}
 					} else {
-						assert (bo.new_building_ == BuildingNecessity::kNeeded);
+						assert (bo.new_building == BuildingNecessity::kNeeded);
 					}
 
 					// Overdue priority here
-					prio += bo.primary_priority_;
+					prio += bo.primary_priority;
 
 					// we check separatelly buildings with no inputs and some inputs
-					if (bo.inputs_.empty()) {
+					if (bo.inputs.empty()) {
 
-						if (bo.space_consumer_) {
+						if (bo.space_consumer) {
 							// we dont like trees nearby
-							prio += 1 - bf->trees_nearby_ / 15;
+							prio += 1 - bf->trees_nearby / 15;
 							// we attempt to cluster space consumers together
-							prio += bf->space_consumers_nearby_ * 2;
+							prio += bf->space_consumers_nearby * 2;
 							// and be far from rangers
-							prio += 1 - bf->rangers_nearby_ * 3;
+							prio += 1 - bf->rangers_nearby * 3;
 						} else {
 							// leave some free space between them
-							prio -= bf->producers_nearby_.at(bo.outputs_.at(0)) * 5;
+							prio -= bf->producers_nearby.at(bo.outputs.at(0)) * 5;
 						}
 
-						if (bo.space_consumer_ && !bf->water_nearby_) {  // not close to water
+						if (bo.space_consumer && !bf->water_nearby) {  // not close to water
 							prio += 1;
 						}
 
-						if (bo.space_consumer_ &&
-						    !bf->unowned_mines_spots_nearby_) {  // not close to mountains
+						if (bo.space_consumer &&
+						    !bf->unowned_mines_spots_nearby) {  // not close to mountains
 							prio += 1;
 						}
 					}
 
-					else if (bo.is_shipyard_) {
+					else if (bo.is_shipyard) {
 						// for now AI builds only one shipyard
-						if (bf->water_nearby_ > 3 && (bo.total_count() - bo.unconnected_count_) == 0 &&
+						if (bf->water_nearby > 3 && (bo.total_count() - bo.unconnected_count) == 0 &&
 						    seafaring_economy) {
-							prio += productionsites.size() * 5 + bf->water_nearby_;
+							prio += productionsites.size() * 5 + bf->water_nearby;
 						}
 					}
 
@@ -2109,8 +2098,8 @@
 					//+1 if any consumers_ are nearby
 					consumers_nearby_count = 0;
 
-					for (size_t k = 0; k < bo.outputs_.size(); ++k)
-						consumers_nearby_count += bf->consumers_nearby_.at(bo.outputs_.at(k));
+					for (size_t k = 0; k < bo.outputs.size(); ++k)
+						consumers_nearby_count += bf->consumers_nearby.at(bo.outputs.at(k));
 
 					if (consumers_nearby_count > 0) {
 						prio += 1;
@@ -2118,18 +2107,18 @@
 				}
 
 				// Consider border with exemption of some huts
-				if (! (bo.need_trees_ || bo.need_water_ || bo.is_fisher_)) {
+				if (! (bo.need_trees || bo.need_water || bo.is_fisher)) {
 						prio = recalc_with_border_range(*bf, prio);
-				} else if (bf->near_border_
+				} else if (bf->near_border
 					&&
-					(bo.need_trees_ || bo.need_water_)) {
+					(bo.need_trees || bo.need_water)) {
 						prio /= 2;
 				}
 
 			}  // production sites done
-			else if (bo.type == BuildingObserver::MILITARYSITE) {
+			else if (bo.type == BuildingObserver::Type::kMilitarysite) {
 
-				if (!bf->unowned_land_nearby_) {
+				if (!(bf->unowned_land_nearby || bf->enemy_nearby)) {
 					continue;
 				}
 
@@ -2138,14 +2127,14 @@
 				}
 
 				// 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_spots_nearby_ > 2 &&
-				         (bo.mountain_conqueror_ || bo.expansion_type_)) {
-					;
-				}  // it is ok, go on
-				else if (bo.expansion_type_) {
+				if (bf->enemy_nearby && bo.fighting_type) {
+					;
+				}  // it is ok, go on
+				else if (bf->unowned_mines_spots_nearby > 2 &&
+				         (bo.mountain_conqueror || bo.expansion_type)) {
+					;
+				}  // it is ok, go on
+				else if (bo.expansion_type) {
 					if (bo.desc->get_size() == 2 && gametime % 2 >= 1) {
 						continue;
 					}
@@ -2159,35 +2148,48 @@
 				// 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_) * 10;
-					prio -= bo.build_material_shortage_  * 50;
-					prio -= (bf->military_in_constr_nearby_ + bf->military_unstationed_) * 50;
+				if (bf->enemy_nearby) {
+					prio += bf->military_loneliness / 3;
+					prio += (20 - bf->area_military_capacity) * 10;
+					prio -= bo.build_material_shortage  * 50;
+					prio -= (bf->military_in_constr_nearby + bf->military_unstationed) * 50;
 				} else {
-					if (bf->near_border_) {
+					if (bf->near_border) {
 						prio += 50;
-						prio -= bo.build_material_shortage_  * 150;
+						prio -= bo.build_material_shortage  * 150;
 					} else {
-						prio -= bo.build_material_shortage_ * 500; // prohibitive
+						prio -= bo.build_material_shortage * 500; // prohibitive
 					}
-					prio -= (bf->military_in_constr_nearby_ + bf->military_unstationed_) * 150;
+					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) ? 35 : 0) *
+				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) ? 35 : 0) *
 						resource_necessity_mines_ / 100;
-				prio += bf->rocks_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;
+				prio += bf->rocks_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) {
+					if (num_ports == 0) {
+						prio += 100;
+					} else {
+						prio += 25;
+					}
+				}
+				// sometimes expansion is stalled and this is to help boost it
+				if (msites_in_constr() == 0 && vacant_mil_positions_ <= 2) {
+					prio += 10;
+					if (bf->enemy_nearby) {
+						prio += 20;
+					}
+				}
 
 				// additional score for bigger buildings
 				int32_t prio_for_size = bo.desc->get_size() - 1;
-				if (bf->enemy_nearby_) {
+				if (bf->enemy_nearby) {
 					prio_for_size *= 30;
 				} else {
 					prio_for_size *= 5;
@@ -2198,18 +2200,18 @@
 				if (prio <= persistent_data->target_military_score) {
 					continue;
 				}
-			} else if (bo.type == BuildingObserver::WAREHOUSE) {
+			} else if (bo.type == BuildingObserver::Type::kWarehouse) {
 
 				// exclude spots on border
-				if (bf->near_border_ && !bo.is_port_) {
-					continue;
-				}
-
-				if (!bf->is_portspace_ && bo.is_port_) {
-					continue;
-				}
-
-				if (bo.cnt_under_construction_ > 0) {
+				if (bf->near_border && !bo.is_port) {
+					continue;
+				}
+
+				if (!bf->is_portspace && bo.is_port) {
+					continue;
+				}
+
+				if (bo.cnt_under_construction > 0) {
 					continue;
 				}
 
@@ -2229,8 +2231,8 @@
 				}
 
 				// 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) {
+				if (bo.is_port && bo.total_count() == 0 && productionsites.size() > 5 &&
+				    !bf->enemy_nearby && bf->is_portspace && seafaring_economy) {
 					prio += productionsites.size();
 					warehouse_needed = true;
 				}
@@ -2240,7 +2242,7 @@
 				}
 
 				// we prefer ports to a normal warehouse
-				if (bo.is_port_) {
+				if (bo.is_port) {
 					prio += 15;
 				}
 
@@ -2263,25 +2265,25 @@
 				prio += nearest_distance - 30;
 
 				// dont be close to enemies
-				if (bf->enemy_nearby_) {
+				if (bf->enemy_nearby) {
 					prio -= 40;
 				}
 
 				// being too close to a border is not good either
-				if (bf->unowned_land_nearby_ && !bo.is_port_ && prio > 0) {
+				if (bf->unowned_land_nearby && !bo.is_port && prio > 0) {
 					prio /= 2;
 					prio -= 10;
 				}
 
-			} else if (bo.type == BuildingObserver::TRAININGSITE) {
+			} else if (bo.type == BuildingObserver::Type::kTrainingsite) {
 
 				// Even if a site is forced it has kNeeded necessity now
-				assert(bo.primary_priority_ > 0 && bo.new_building_ == BuildingNecessity::kNeeded);
+				assert(bo.primary_priority > 0 && bo.new_building == BuildingNecessity::kNeeded);
 
-				prio = bo.primary_priority_;
+				prio = bo.primary_priority;
 
 				// for spots close to a border
-				if (bf->near_border_) {
+				if (bf->near_border) {
 					prio -= 5;
 				}
 
@@ -2291,18 +2293,18 @@
 				}
 
 				// take care about borders and enemies
-				if (bf->enemy_nearby_) {
+				if (bf->enemy_nearby) {
 					prio -= 20;
 				}
 
-				if (bf->unowned_land_nearby_) {
+				if (bf->unowned_land_nearby) {
 					prio -= 15;
 				}
 			}
 
 			// think of space consuming buildings nearby like farms or vineyards
-			if (bo.type != BuildingObserver::MILITARYSITE) {
-				prio -= bf->space_consumers_nearby_ * 10;
+			if (bo.type != BuildingObserver::Type::kMilitarysite) {
+				prio -= bf->space_consumers_nearby * 10;
 			}
 
 			// Stop here, if priority is 0 or less.
@@ -2311,14 +2313,14 @@
 			}
 
 			// testing also vicinity
-			if (!bo.is_port_) {
-				if (port_reserved_coords.count(coords_hash(bf->coords)) > 0) {
+			if (!bo.is_port) {
+				if (port_reserved_coords.count(bf->coords.hash()) > 0) {
 					continue;
 				}
 			}
 
 			// Prefer road side fields
-			prio += bf->preferred_ ? 5 : 0;
+			prio += bf->preferred ? 5 : 0;
 
 			// don't waste good land for small huts
 			const bool space_stress =
@@ -2326,20 +2328,20 @@
 				||
 				spots_avail.at(BUILDCAPS_BIG) < 5);
 
-			if (space_stress && bo.type == BuildingObserver::MILITARYSITE) {
-				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 3;
+			if (space_stress && bo.type == BuildingObserver::Type::kMilitarysite) {
+				prio -= (bf->max_buildcap_nearby - bo.desc->get_size()) * 3;
 			} else if (space_stress) {
-				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 10;
+				prio -= (bf->max_buildcap_nearby - bo.desc->get_size()) * 10;
 			} else {
-				prio -= (bf->max_buildcap_nearby_ - bo.desc->get_size()) * 3;
+				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) {
+			if (bf->port_nearby && bo.type == BuildingObserver::Type::kMilitarysite) {
 				prio *= 2;
 			}
 
-			if (bo.type != BuildingObserver::MILITARYSITE && highest_nonmil_prio_ < prio) {
+			if (bo.type != BuildingObserver::Type::kMilitarysite && highest_nonmil_prio_ < prio) {
 				highest_nonmil_prio_ = prio;
 			}
 
@@ -2363,26 +2365,26 @@
 			for (BuildingObserver& bo : buildings_) {
 				if (productionsites.size() <= 8) break;
 
-				if (bo.type != BuildingObserver::MINE) {
-					continue;
-				}
-
-				if (gametime - bo.construction_decision_time_ < kBuildingMinInterval) {
-					continue;
-				}
-
-				assert(bo.new_building_ != BuildingNecessity::kAllowed);
+				if (bo.type != BuildingObserver::Type::kMine) {
+					continue;
+				}
+
+				if (gametime - bo.construction_decision_time < kBuildingMinInterval) {
+					continue;
+				}
+
+				assert(bo.new_building != BuildingNecessity::kAllowed);
 
 				// skip if a mine is not required
-				if (!(bo.new_building_ == BuildingNecessity::kNeeded ||
-					bo.new_building_ == BuildingNecessity::kForced)) {
+				if (!(bo.new_building == BuildingNecessity::kNeeded ||
+					bo.new_building == BuildingNecessity::kForced)) {
 						continue;
 					}
 
 				// this is penalty if there are existing mines too close
 				// it is treated as multiplicator for count of near mines
 				uint32_t nearness_penalty = 0;
-				if ((mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished) ==
+				if ((mines_per_type[bo.mines].in_construction + mines_per_type[bo.mines].finished) ==
 				    0) {
 					nearness_penalty = 0;
 				} else {
@@ -2391,9 +2393,9 @@
 
 				// bonus score to prefer if too few mines
 				uint32_t bonus_score = 0;
-				if ((mines_per_type[bo.mines_].in_construction + mines_per_type[bo.mines_].finished) ==
+				if ((mines_per_type[bo.mines].in_construction + mines_per_type[bo.mines].finished) ==
 				    0) {
-					bonus_score = 2 * bo.primary_priority_;
+					bonus_score = 2 * bo.primary_priority;
 				}
 
 				// iterating over fields
@@ -2403,18 +2405,18 @@
 
 					MineableField* const mf = *j;
 
-					if (mf->field_info_expiration_ <= gametime) {
+					if (mf->field_info_expiration <= gametime) {
 						continue;
 					}
 
-					if (mf->coords.field->get_resources() != bo.mines_) {
+					if (mf->coords.field->get_resources() != bo.mines) {
 						continue;
 					}
 
 					int32_t prio = 0;
 					MapRegion<Area<FCoords>> mr(map, Area<FCoords>(mf->coords, 2));
 					do {
-						if (bo.mines_ == mr.location().field->get_resources()) {
+						if (bo.mines == mr.location().field->get_resources()) {
 							prio += mr.location().field->get_resources_amount();
 						}
 					} while (mr.advance(map));
@@ -2427,41 +2429,30 @@
 					}
 
 					// applying nearnes penalty
-					prio -= mf->mines_nearby_ * nearness_penalty;
+					prio -= mf->mines_nearby * nearness_penalty;
 
 					// applying bonus score
 					prio += bonus_score;
 
 					// applying max needed
-					prio += bo.primary_priority_;
+					prio += bo.primary_priority;
 
 					// prefer mines in the middle of mine fields of the
 					// same type, so we add a small bonus here
 					// depending on count of same mines nearby,
 					// though this does not reflects how many resources
 					// are (left) in nearby mines
-					prio += mf->same_mine_fields_nearby_;
+					prio += mf->same_mine_fields_nearby;
 
 					// Continue if field is blocked at the moment
-					bool blocked = false;
-
-					for (std::list<BlockedField>::iterator k = blocked_fields.begin();
-					     k != blocked_fields.end();
-					     ++k)
-						if ((*j)->coords == k->coords) {
-							blocked = true;
-							break;
-						}
-
-					if (blocked) {
-
+					if (blocked_fields.is_blocked(mf->coords)) {
 						continue;
 					}
 
 					// Prefer road side fields
-					prio += mf->preferred_ ? 1 : 0;
+					prio += mf->preferred ? 1 : 0;
 
-					prio += bo.primary_priority_;
+					prio += bo.primary_priority;
 
 					if (prio > proposed_priority) {
 						best_building = &bo;
@@ -2484,28 +2475,30 @@
 		return false;
 	}
 
-	if (best_building->type == BuildingObserver::MILITARYSITE) {
+	if (best_building->type == BuildingObserver::Type::kMilitarysite) {
 		persistent_data->target_military_score = proposed_priority;
 	}
 
 	// 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);
+	blocked_fields.add(proposed_coords, game().get_gametime() + 2 * 60 * 1000);
 
-	// resetting new_building_overdue_
-	best_building->new_building_overdue_ = 0;
+	// 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
-	if ((best_building->space_consumer_ && !best_building->plants_trees_) ||
-	    best_building->type == BuildingObserver::MILITARYSITE) {
+	if ((best_building->space_consumer && !best_building->plants_trees) ||
+		 best_building->type == BuildingObserver::Type::kMilitarysite) {
 		uint32_t block_time = 0;
 		uint32_t block_area = 0;
-		if (best_building->space_consumer_) {
-			block_time = 45 * 60 * 1000;
+		if (best_building->space_consumer) {
+			if (spots_ > kSpotsEnough) {
+				block_time = 45 * 60 * 1000;
+			} else {
+				block_time = 10 * 60 * 1000;
+			}
 			block_area = 3;
 		} else {  // militray buildings for a very short time
 			block_time = 25 * 1000;
@@ -2514,17 +2507,15 @@
 
 		MapRegion<Area<FCoords>> mr(map, Area<FCoords>(map.get_fcoords(proposed_coords), block_area));
 		do {
-			BlockedField blocked2(
-			   map.get_fcoords(*(mr.location().field)), game().get_gametime() + block_time);
-			blocked_fields.push_back(blocked2);
+			blocked_fields.add(mr.location(), game().get_gametime() + block_time);
 		} while (mr.advance(map));
 	}
 
-	if (!(best_building->type == BuildingObserver::MILITARYSITE)) {
-		best_building->construction_decision_time_ = gametime;
+	if (!(best_building->type == BuildingObserver::Type::kMilitarysite)) {
+		best_building->construction_decision_time = gametime;
 	} else {  // very ugly hack here
 		military_last_build_ = gametime;
-		best_building->construction_decision_time_ = gametime - kBuildingMinInterval / 2;
+		best_building->construction_decision_time = gametime - kBuildingMinInterval / 2;
 	}
 
 	// set the type of update that is needed
@@ -2538,12 +2529,11 @@
 // improves current road system
 bool DefaultAI::improve_roads(uint32_t gametime) {
 
-	// first force a split on roads that are longer than 3 parts
-	// with exemption when there is too few building spots
-	if (spots_ > 20 && !roads.empty()) {
+	if (!roads.empty()) {
 		const Path& path = roads.front()->get_path();
 
-		if (path.get_nsteps() > 3) {
+		// first force a split on roads that are longer than 3 parts
+		if (path.get_nsteps() > 3 && spots_ > kSpotsEnough) {
 			const Map& map = game().map();
 			CoordPath cp(map, path);
 			// try to split after two steps
@@ -2570,13 +2560,15 @@
 
 			// Unable to set a flag - perhaps the road was build stupid
 			game().send_player_bulldoze(*const_cast<Road*>(roads.front()));
+			return true;
 		}
 
 		roads.push_back(roads.front());
 		roads.pop_front();
 
 		// occasionaly we test if the road can be dismounted
-		if (gametime % 5 == 0) {
+		// if there is shortage of spots we do it always
+		if (gametime % 5 == 0 || spots_ < kSpotsTooLittle) {
 			const Road& road = *roads.front();
 			if (dispensable_road_test(*const_cast<Road*>(&road))) {
 				game().send_player_bulldoze(*const_cast<Road*>(&road));
@@ -2622,21 +2614,38 @@
 	bool is_warehouse = false;
 	if (Building* b = flag.get_building()) {
 		BuildingObserver& bo = get_building_observer(b->descr().name().c_str());
-		if (bo.type == BuildingObserver::WAREHOUSE) {
+		if (bo.type == BuildingObserver::Type::kWarehouse) {
 			is_warehouse = true;
 		}
 	}
 
-	// if this is end flag (or sole building) or just randomly
-	if (flag.nr_of_roads() <= 1 || gametime % 10 == 0) {
+	// is connected to a warehouse?
+	const bool needs_warehouse = flag.get_economy()->warehouses().empty();
+
+	// needs to be connected
+	if (flag.nr_of_roads() == 0 || needs_warehouse) {
 		create_shortcut_road(flag, 13, 22, gametime);
 		inhibit_road_building_ = gametime + 800;
+	} else if (flag.nr_of_roads() == 1 || gametime % 10 == 0) {
+		if (spots_ > kSpotsEnough) {
+			// This is the normal situation
+			create_shortcut_road(flag, 13, 22, gametime);
+			inhibit_road_building_ = gametime + 800;
+		} else if (spots_ > kSpotsTooLittle)  {
+			// We are short of spots so shortening must be significant
+			create_shortcut_road(flag, 13, 35, gametime);
+			inhibit_road_building_ = gametime + 800;
+		} else {
+			// We are very short of spots so shortening must be even bigger
+			create_shortcut_road(flag, 13, 50, gametime);
+			inhibit_road_building_ = gametime + 800;
+		}
 		// a warehouse with 3 or less roads
 	} else if (is_warehouse && flag.nr_of_roads() <= 3) {
 		create_shortcut_road(flag, 9, -1, gametime);
 		inhibit_road_building_ = gametime + 400;
 		// and when a flag is full with wares
-	} else if (flag.current_wares() > 5) {
+	} else if (spots_ > kSpotsEnough && flag.current_wares() > 5) {
 		create_shortcut_road(flag, 9, -2, gametime);
 		inhibit_road_building_ = gametime + 400;
 	} else {
@@ -2655,7 +2664,9 @@
 	Flag& roadstartflag = road.get_flag(Road::FlagStart);
 	Flag& roadendflag = road.get_flag(Road::FlagEnd);
 
-	if (roadstartflag.current_wares() > 0 || roadendflag.current_wares() > 0) {
+	// We do not dismantle (even consider it) if the road is busy (some wares on flags), unless there
+	// is shortage of build spots
+	if (spots_ > kSpotsTooLittle && roadstartflag.current_wares() + roadendflag.current_wares() > 0) {
 		return false;
 	}
 
@@ -2664,7 +2675,14 @@
 	std::vector<NearFlag> reachableflags;
 	queue.push(NearFlag(roadstartflag, 0, 0));
 	uint8_t pathcounts = 0;
-	uint8_t checkradius = 8;
+	uint8_t checkradius = 0;
+	if (spots_ > kSpotsEnough) {
+		checkradius = 8;
+	} else if (spots_ > kSpotsTooLittle) {
+		checkradius = 12;
+	} else {
+		checkradius = 16;
+	}
 	Map& map = game().map();
 
 	// algorithm to walk on roads
@@ -2738,8 +2756,8 @@
 	// this should not happen, but if the economy has a warehouse and a dismantle
 	// grace time set, we must 'zero' the dismantle grace time
 	if (!flag.get_economy()->warehouses().empty() &&
-	    eco->dismantle_grace_time_ != std::numeric_limits<int32_t>::max()) {
-		eco->dismantle_grace_time_ = std::numeric_limits<int32_t>::max();
+	    eco->dismantle_grace_time != std::numeric_limits<int32_t>::max()) {
+		eco->dismantle_grace_time = std::numeric_limits<int32_t>::max();
 	}
 
 	// first we deal with situations when this is economy with no warehouses
@@ -2759,13 +2777,13 @@
 		}
 
 		// if we are within grace time, it is OK, just go on
-		if (eco->dismantle_grace_time_ > gametime &&
-		    eco->dismantle_grace_time_ != std::numeric_limits<int32_t>::max()) {
+		if (eco->dismantle_grace_time > gametime &&
+		    eco->dismantle_grace_time != std::numeric_limits<int32_t>::max()) {
 			;
 
 			// if grace time is not set, this is probably first time without a warehouse and we must
 			// set it
-		} else if (eco->dismantle_grace_time_ == std::numeric_limits<int32_t>::max()) {
+		} else if (eco->dismantle_grace_time == std::numeric_limits<int32_t>::max()) {
 
 			// constructionsites
 			if (upcast(ConstructionSite const, constructionsite, flag.get_building())) {
@@ -2773,10 +2791,10 @@
 				   get_building_observer(constructionsite->building().name().c_str());
 				// first very special case - a port (in the phase of constructionsite)
 				// this might be a new colonization port
-				if (bo.is_port_) {
-					eco->dismantle_grace_time_ = gametime + 60 * 60 * 1000;  // one hour should be enough
+				if (bo.is_port) {
+					eco->dismantle_grace_time = gametime + 60 * 60 * 1000;  // one hour should be enough
 				} else {  // other constructionsites, usually new (standalone) constructionsites
-					eco->dismantle_grace_time_ =
+					eco->dismantle_grace_time =
 					   gametime + 30 * 1000 +            // very shot time is enough
 					   (eco->flags.size() * 30 * 1000);  // + 30 seconds for every flag in economy
 				}
@@ -2785,11 +2803,11 @@
 			} else {
 
 				if (occupied_military_) {
-					eco->dismantle_grace_time_ =
+					eco->dismantle_grace_time =
 					   (gametime + 90 * 60 * 1000) + (eco->flags.size() * 20 * 1000);
 
 				} else {  // for other normal buildings
-					eco->dismantle_grace_time_ =
+					eco->dismantle_grace_time =
 					   gametime + (45 * 60 * 1000) + (eco->flags.size() * 20 * 1000);
 				}
 			}
@@ -2850,7 +2868,7 @@
 			}
 
 			// now make sure that this field has not been processed yet
-			const uint32_t hash = coords_hash(reachable_coords);
+			const uint32_t hash = reachable_coords.hash();
 			if (lookuptable.count(hash) == 0) {
 				lookuptable.insert(hash);
 
@@ -2922,7 +2940,7 @@
 				continue;
 			}
 
-			queue.push(NearFlag(*endflag, nf.cost_ + road->get_path().get_nsteps(), dist));
+			queue.push(NearFlag(*endflag, nf.cost + road->get_path().get_nsteps(), dist));
 		}
 	}
 
@@ -2932,16 +2950,16 @@
 	for (std::vector<NearFlag>::iterator nf_walk_it = nearflags_tmp.begin();
 	     nf_walk_it != nearflags_tmp.end();
 	     ++nf_walk_it) {
-		uint32_t const hash_walk = coords_hash(nf_walk_it->flag->get_position());
+		uint32_t const hash_walk = nf_walk_it->flag->get_position().hash();
 		if (lookuptable.count(hash_walk) > 0) {
 			// iterating over nearflags
 			for (std::vector<NearFlag>::iterator nf_it = nearflags.begin(); nf_it != nearflags.end();
 			     ++nf_it) {
-				uint32_t const hash = coords_hash(nf_it->flag->get_position());
+				uint32_t const hash = nf_it->flag->get_position().hash();
 				if (hash == hash_walk) {
 					// decreasing "cost" (of walking via roads)
-					if (nf_it->cost_ > nf_walk_it->cost_) {
-						nf_it->cost_ = nf_walk_it->cost_;
+					if (nf_it->cost > nf_walk_it->cost) {
+						nf_it->cost = nf_walk_it->cost;
 					}
 				}
 			}
@@ -2949,7 +2967,7 @@
 	}
 
 	// ordering nearflags
-	std::sort(nearflags.begin(), nearflags.end(), CompareShortening());
+	std::sort(nearflags.begin(), nearflags.end(), NearFlag::CompareShortening());
 
 	// this is just a random number, will be used later
 	int32_t random_gametime = game().get_gametime();
@@ -2963,7 +2981,7 @@
 		NearFlag& nf = nearflags.at(i);
 
 		// terminating looping if reduction is too low (nearflags are sorted by reduction)
-		if ((nf.cost_ - nf.distance_) < min_reduction) {
+		if ((nf.cost - nf.distance) < min_reduction) {
 			return false;
 		}
 
@@ -2971,8 +2989,8 @@
 		// usually we allow connecting only if both flags are closer then 'checkradius-2'
 		// with exeption the flag belongs to a small economy (typically a new building not connected
 		// yet)
-		if ((nf.cost_ - nf.distance_) >= min_reduction && nf.distance_ >= 2 &&
-		    nf.distance_ < checkradius - 2) {
+		if ((nf.cost - nf.distance) >= min_reduction && nf.distance >= 2 &&
+		    nf.distance < checkradius - 2) {
 
 			// sometimes the shortest road is not the buildable, even if map.findpath claims so
 			// best so we add some randomness
@@ -2988,7 +3006,7 @@
 			   map.findpath(flag.get_position(), nf.flag->get_position(), 0, path, check);
 
 			if (pathcost >= 0) {
-				if (static_cast<int32_t>(nf.cost_ - path.get_nsteps()) > min_reduction) {
+				if (static_cast<int32_t>(nf.cost - path.get_nsteps()) > min_reduction) {
 					game().send_player_build_road(player_number(), path);
 					return true;
 				}
@@ -3000,11 +3018,12 @@
 	// if all possible roads skipped
 	if (last_attempt_) {
 		Building* bld = flag.get_building();
-		// first we block the field for 15 minutes, probably it is not good place to build a
-		// building on
-		BlockedField blocked(
-		   game().map().get_fcoords(bld->get_position()), game().get_gametime() + 15 * 60 * 1000);
-		blocked_fields.push_back(blocked);
+		// first we block the field and vicinity for 15 minutes, probably it is not a good place to build on
+		MapRegion<Area<FCoords>> mr(
+			   game().map(), Area<FCoords>(map.get_fcoords(bld->get_position()), 2));
+		do {
+			blocked_fields.add(mr.location(), game().get_gametime() + 15 * 60 * 1000);
+		} while (mr.advance(map));
 		eco->flags.remove(&flag);
 		game().send_player_bulldoze(*const_cast<Flag*>(&flag));
 		return true;
@@ -3072,7 +3091,7 @@
 
 	// first we werify if site is working yet (can be unoccupied since the start)
 	if (!site.site->can_start_working()) {
-		site.unoccupied_till_ = game().get_gametime();
+		site.unoccupied_till = game().get_gametime();
 	}
 
 	// is it connected to wh at all?
@@ -3080,7 +3099,7 @@
 
 	// do not dismantle or upgrade the same type of building too soon - to give some time to update
 	// statistics
-	if (site.bo->last_dismantle_time_ > game().get_gametime() - 30 * 1000) {
+	if (site.bo->last_dismantle_time > game().get_gametime() - 30 * 1000) {
 		return false;
 	}
 
@@ -3102,16 +3121,16 @@
 	// b) if there are two buildings
 	// statistics percents are decisive
 	// c) yet there are buildings that might be upgraded, even when
-	// there is no second buiding of the kind (flag upgrade_substitutes_)
+	// there is no second buiding of the kind (flag upgrade_substitutes)
 
 	const DescriptionIndex enhancement = site.site->descr().enhancement();
 	if (connected_to_wh && enhancement != INVALID_INDEX &&
 		// if upgrade does not subsitute, we need to have two buildings at least
-		((site.bo->cnt_built_ - site.bo->unoccupied_count_ > 1 && site.bo->upgrade_extends_)
+		((site.bo->cnt_built - site.bo->unoccupied_count > 1 && site.bo->upgrade_extends)
 		||
-		site.bo->upgrade_substitutes_) &&
+		site.bo->upgrade_substitutes) &&
 	    gametime > 45 * 60 * 1000 &&
-	    gametime > site.built_time_ + 20 * 60 * 1000) {
+	    gametime > site.built_time + 20 * 60 * 1000) {
 
 		// Only enhance buildings that are allowed (scenario mode)
 		// do not do decisions too fast
@@ -3121,8 +3140,8 @@
 			BuildingObserver& en_bo = get_building_observer(bld.name().c_str());
 			bool doing_upgrade = false;
 
-			if (gametime - en_bo.construction_decision_time_ >= 10 * 60 * 1000 &&
-			    (en_bo.cnt_under_construction_ + en_bo.unoccupied_count_) == 0) {
+			if (gametime - en_bo.construction_decision_time >= 10 * 60 * 1000 &&
+			    (en_bo.cnt_under_construction + en_bo.unoccupied_count) == 0) {
 
 				// don't upgrade without workers
 				if (site.site->has_workers(enhancement, game())) {
@@ -3134,23 +3153,23 @@
 
 					if (en_bo.total_count() == 1) {
 						//if the upgrade itself can be upgraded futher, we are more willing to upgrade 2nd building
-						if (en_bo.upgrade_extends_ || en_bo.upgrade_substitutes_) {
-							if (en_bo.current_stats_ > 30) {
+						if (en_bo.upgrade_extends || en_bo.upgrade_substitutes) {
+							if (en_bo.current_stats > 30) {
 								doing_upgrade = true;
 							}
-						} else if (en_bo.current_stats_ > 50) {
+						} else if (en_bo.current_stats > 50) {
 							doing_upgrade = true;
 						}
 					}
 
 					if (en_bo.total_count() > 1) {
-						if (en_bo.current_stats_ > 80) {
+						if (en_bo.current_stats > 80) {
 								doing_upgrade = true;
 						}
 					}
 
 					// Dont forget about limitation of number of buildings
-					if (en_bo.cnt_limit_by_aimode_ <= en_bo.total_count() - en_bo.unconnected_count_) {
+					if (en_bo.cnt_limit_by_aimode <= en_bo.total_count() - en_bo.unconnected_count) {
 						doing_upgrade = false;
 					}
 				}
@@ -3160,14 +3179,19 @@
 			// additional: we dont want to lose the old building
 			if (doing_upgrade) {
 				game().send_player_enhance_building(*site.site, enhancement);
-				en_bo.construction_decision_time_ = gametime;
+				en_bo.construction_decision_time = gametime;
 				return true;
 			}
 		}
 	}
 
 	// Lumberjack / Woodcutter handling
-	if (site.bo->need_trees_) {
+	if (site.bo->need_trees) {
+
+		// do not dismantle immediatelly
+		if ((game().get_gametime() - site.built_time) < 4 * 60 * 1000) {
+			return false;
+		}
 
 		const uint32_t remaining_trees =
 		   map.find_immovables(Area<FCoords>(map.get_fcoords(site.site->get_position()), radius),
@@ -3180,7 +3204,7 @@
 			(remaining_trees * 10 + 9 * persistent_data->trees_around_cutters) / 10;
 
 		// Do not destruct the last few lumberjacks
-		if (site.bo->cnt_built_ <= site.bo->cnt_target_) {
+		if (site.bo->cnt_built <= site.bo->cnt_target) {
 			return false;
 		}
 
@@ -3188,25 +3212,23 @@
 			return false;
 		}
 
-
-
 		// do not dismantle if there are some trees remaining
 		if (remaining_trees > 5) {
 			return false;
 		}
 
 		if (site.bo->stocklevel_time < game().get_gametime() - 10 * 1000) {
-			site.bo->stocklevel_ = get_stocklevel(*site.bo);
+			site.bo->stocklevel = get_stocklevel(*site.bo);
 			site.bo->stocklevel_time = game().get_gametime();
 		}
 
 		// if we need wood badly
-		if (remaining_trees > 0 && site.bo->stocklevel_ <= 50) {
+		if (remaining_trees > 0 && site.bo->stocklevel <= 50) {
 			return false;
 		}
 
 		// so finally we dismantle the lumberjac
-		site.bo->last_dismantle_time_ = game().get_gametime();
+		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);
@@ -3218,10 +3240,10 @@
 	}
 
 	// Wells handling
-	if (site.bo->mines_water_) {
-		if (site.unoccupied_till_ + 6 * 60 * 1000 < gametime &&
+	if (site.bo->mines_water) {
+		if (site.unoccupied_till + 6 * 60 * 1000 < gametime &&
 		    site.site->get_statistics_percent() == 0) {
-			site.bo->last_dismantle_time_ = gametime;
+			site.bo->last_dismantle_time = gametime;
 			flags_to_be_removed.push_back(site.site->base_flag().get_position());
 			if (connected_to_wh) {
 				game().send_player_dismantle(*site.site);
@@ -3233,7 +3255,7 @@
 		}
 
 		// do not consider dismantling if we are under target
-		if (site.bo->last_dismantle_time_ + 90 * 1000 > game().get_gametime()) {
+		if (site.bo->last_dismantle_time + 90 * 1000 > game().get_gametime()) {
 			return false;
 		}
 
@@ -3241,11 +3263,11 @@
 		// but first we make sure we do not dismantle a well too soon
 		// after dismantling previous one
 		if (site.bo->stocklevel_time < game().get_gametime() - 5 * 1000) {
-			site.bo->stocklevel_ = get_stocklevel(*site.bo);
+			site.bo->stocklevel = get_stocklevel(*site.bo);
 			site.bo->stocklevel_time = game().get_gametime();
 		}
-		if (site.bo->stocklevel_ > 250 + productionsites.size() * 5) {  // dismantle
-			site.bo->last_dismantle_time_ = game().get_gametime();
+		if (site.bo->stocklevel > 250 + productionsites.size() * 5) {  // dismantle
+			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);
@@ -3259,7 +3281,7 @@
 	}
 
 	// Quarry handling
-	if (site.bo->need_rocks_) {
+	if (site.bo->need_rocks) {
 
 		if (map.find_immovables(
 		       Area<FCoords>(map.get_fcoords(site.site->get_position()), 6),
@@ -3278,10 +3300,10 @@
 			return true;
 		}
 
-		if (site.unoccupied_till_ + 6 * 60 * 1000 < gametime &&
+		if (site.unoccupied_till + 6 * 60 * 1000 < gametime &&
 		    site.site->get_statistics_percent() == 0) {
 			// it is possible that there are rocks but quarry is not able to mine them
-			site.bo->last_dismantle_time_ = game().get_gametime();
+			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);
@@ -3296,26 +3318,26 @@
 	}
 
 	// All other SPACE_CONSUMERS without input and above target_count
-	if (site.bo->inputs_.empty()  // does not consume anything
-	    &&
-	    site.bo->production_hint_ == -1  // not a renewing building (forester...)
-	    &&
-	    site.unoccupied_till_ + 10 * 60 * 1000 < gametime  // > 10 minutes old
+	if (site.bo->inputs.empty()  // does not consume anything
+	    &&
+	    site.bo->production_hint == -1  // not a renewing building (forester...)
+	    &&
+	    site.unoccupied_till + 10 * 60 * 1000 < gametime  // > 10 minutes old
 	    &&
 	    site.site->can_start_working()  // building is occupied
 	    &&
-	    site.bo->space_consumer_ && !site.bo->plants_trees_) {
+	    site.bo->space_consumer && !site.bo->plants_trees) {
 
 		// if we have more buildings then target
-		if ((site.bo->cnt_built_ - site.bo->unconnected_count_) > 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 = get_stocklevel(*site.bo);
 				site.bo->stocklevel_time = game().get_gametime();
 			}
 
 			if (site.site->get_statistics_percent() < 30 &&
-			    site.bo->stocklevel_ > 100) {
-				site.bo->last_dismantle_time_ = game().get_gametime();
+			    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) {
 					game().send_player_dismantle(*site.site);
@@ -3327,7 +3349,7 @@
 		}
 
 		// a building can be dismanteld if it performs too bad, if it is not the last one
-		if (site.site->get_statistics_percent() <= 10 && site.bo->cnt_built_ > 1) {
+		if (site.site->get_statistics_percent() <= 10 && site.bo->cnt_built > 1) {
 
 			flags_to_be_removed.push_back(site.site->base_flag().get_position());
 			if (connected_to_wh) {
@@ -3341,18 +3363,18 @@
 		return false;
 	}
 
-	// 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_count_) >= 3 &&
+	// 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_count) >= 3 &&
 	    site.site->can_start_working() &&
 	    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();
+	    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) {
@@ -3365,12 +3387,12 @@
 
 	// 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_ &&
+	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 &&
-	    ((game().get_gametime() - site.built_time_) > 10 * 60 * 1000)) {
+	    ((game().get_gametime() - site.built_time) > 10 * 60 * 1000)) {
 
-		site.bo->last_dismantle_time_ = game().get_gametime();
+		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);
@@ -3382,17 +3404,17 @@
 
 	// supporting productionsites (rangers)
 	// stop/start them based on stock avaiable
-	if (site.bo->production_hint_ >= 0) {
+	if (site.bo->production_hint >= 0) {
 
-		if (!site.bo->plants_trees_) {
+		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_) {
+		if (wood_policy_ == WoodPolicy::kDismantleRangers && site.bo->cnt_built > site.bo->cnt_target) {
 
-			site.bo->last_dismantle_time_ = game().get_gametime();
+			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);
@@ -3456,7 +3478,7 @@
 
 	// goes over all warehouses (these includes ports)
 	for (const WarehouseSiteObserver& wh_obs : warehousesites) {
-		if (wh_obs.bo->is_port_) {
+		if (wh_obs.bo->is_port) {
 			ports_count += 1;
 			if (Widelands::PortDock* pd = wh_obs.site->get_portdock()) {
 				if (pd->expedition_started()) {
@@ -3468,7 +3490,7 @@
 
 	// goes over productionsites and gets status of shipyards
 	for (const ProductionSiteObserver& ps_obs : productionsites) {
-		if (ps_obs.bo->is_shipyard_) {
+		if (ps_obs.bo->is_shipyard) {
 			shipyards_count += 1;
 
 			// counting stocks
@@ -3514,7 +3536,7 @@
 	if (enough_ships == FleetStatus::kNeedShip) {
 
 		for (const ProductionSiteObserver& ps_obs : productionsites) {
-			if (ps_obs.bo->is_shipyard_ && ps_obs.site->can_start_working() &&
+			if (ps_obs.bo->is_shipyard && ps_obs.site->can_start_working() &&
 			    ps_obs.site->is_stopped()) {
 				// make sure it is fully stocked
 				// counting stocks
@@ -3543,7 +3565,7 @@
 	    expeditions_in_progress == 0) {
 			// we need to find a port
 			for (const WarehouseSiteObserver& wh_obs : warehousesites) {
-				if (wh_obs.bo->is_port_) {
+				if (wh_obs.bo->is_port) {
 					game().send_player_start_or_cancel_expedition(*wh_obs.site);
 					return true;
 				}
@@ -3575,7 +3597,7 @@
 
 					// the function below will take care of variables like
 					// - expedition_ship_
-					// - expedition_start_time_
+					// - expedition_start_time
 					// - expected_colony_scan
 					// - no_more_expeditions_
 					check_ship_in_expedition(*i, gametime);
@@ -3629,7 +3651,7 @@
 			for (std::list<ProductionSiteObserver>::iterator site = productionsites.begin();
 			     site != productionsites.end();
 			     ++site) {
-				if (site->bo->is_shipyard_) {
+				if (site->bo->is_shipyard) {
 					if (!site->site->is_stopped()) {
 						game().send_player_start_stop_building(*site->site);
 					}
@@ -3641,10 +3663,10 @@
 			for (std::list<ProductionSiteObserver>::iterator site = productionsites.begin();
 			     site != productionsites.end();
 			     ++site) {
-				if (site->bo->is_shipyard_) {
-					for (uint32_t k = 0; k < site->bo->inputs_.size(); ++k) {
+				if (site->bo->is_shipyard) {
+					for (uint32_t k = 0; k < site->bo->inputs.size(); ++k) {
 						game().send_player_set_ware_priority(
-						   *site->site, wwWARE, site->bo->inputs_.at(k), HIGH_PRIORITY);
+						   *site->site, wwWARE, site->bo->inputs.at(k), HIGH_PRIORITY);
 					}
 				}
 			}
@@ -3695,7 +3717,7 @@
 			persistent_data->colony_scan_area = expected_colony_scan;
 		}
 
-	// Expedition overdue. Setting no_more_expeditions_=true
+	// Expedition overdue. Setting no_more_expeditions = true
 	// But we do not cancel it, the code for cancellation does not work properly now
 	// TODO(unknown): - expedition code for cancellation needs to be fixed and afterwareds
 	// AI can be changed to cancel overdue expedition
@@ -3728,7 +3750,7 @@
 
 	// first get rid of mines that are missing workers for some time (6 minutes),
 	// released worker (if any) can be usefull elsewhere !
-	if (site.built_time_ + 6 * 60 * 1000 < gametime && !site.site->can_start_working()) {
+	if (site.built_time + 6 * 60 * 1000 < gametime && !site.site->can_start_working()) {
 		flags_to_be_removed.push_back(site.site->base_flag().get_position());
 		if (connected_to_wh) {
 			game().send_player_dismantle(*site.site);
@@ -3744,7 +3766,7 @@
 	}
 
 	// if mine is working, doing nothing
-	if (site.no_resources_since_ > gametime - 5 * 60 * 1000) {
+	if (site.no_resources_since > gametime - 5 * 60 * 1000) {
 		return false;
 	}
 
@@ -3761,9 +3783,9 @@
 	// (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;
+	const uint16_t minimal_mines_count = (site.bo->produces_building_material) ? 2 : 1;
 	if (has_upgrade &&
-		mines_per_type[site.bo->mines_].total_count() <= minimal_mines_count) {
+		mines_per_type[site.bo->mines].total_count() <= minimal_mines_count) {
 		forcing_upgrade = true;
 	}
 
@@ -3776,17 +3798,17 @@
 		} else {
 			game().send_player_bulldoze(*site.site);
 		}
-		site.bo->construction_decision_time_ = gametime;
+		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) {
+	} 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;
+		site.bo->construction_decision_time = gametime;
 		return true;
 	}
 
@@ -3795,7 +3817,7 @@
 	// 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) {
+	if (site.bo->max_needed_preciousness == 0 && !forcing_upgrade) {
 		return false;
 	}
 
@@ -3806,13 +3828,13 @@
 	}
 
 	// 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) {
+	if (mines_per_type[site.bo->mines].in_construction > 0) {
 		return false;
 	}
 
 	bool changed = false;
 
-	// first exclude possibility there are enhancements in construction or unoccupied_count_
+	// 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());
 
@@ -3820,17 +3842,17 @@
 	if (en_bo.aimode_limit_status() == AiModeBuildings::kAnotherAllowed) {
 
 		// if it is too soon for enhancement
-		if (gametime - en_bo.construction_decision_time_ >= kBuildingMinInterval) {
+		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;
+				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;
 			}
 		}
@@ -3871,48 +3893,48 @@
 	}
 
 	// First we deal with training sites, they are separate category
-	if (bo.type == BuildingObserver::TRAININGSITE) {
+	if (bo.type == BuildingObserver::Type::kTrainingsite) {
 
-		bo.primary_priority_ = 0;
+		bo.primary_priority = 0;
 		if (bo.aimode_limit_status() != AiModeBuildings::kAnotherAllowed) {
 			return BuildingNecessity::kNotNeeded;
 		} else if (ts_without_trainers_ || (ts_basic_const_count_ + ts_advanced_const_count_) > 0) {
 			return BuildingNecessity::kNotNeeded;
-		} else if (bo.prohibited_till_ > gametime) {
+		} else if (bo.prohibited_till > gametime) {
 			return BuildingNecessity::kNotNeeded;
-		} else if (bo.build_material_shortage_) {
+		} else if (bo.build_material_shortage) {
 			return BuildingNecessity::kNotNeeded;
 		}
 
 		// It seems we might need it after all
-		bo.primary_priority_ = -30;
+		bo.primary_priority = -30;
 
-		if (bo.forced_after_ < gametime && bo.total_count() == 0) {
-			bo.primary_priority_ += 50;
+		if (bo.forced_after < gametime && bo.total_count() == 0) {
+			bo.primary_priority += 50;
 		}
 
 		//if we are close to enemy (was seen in last 15 minutes)
 		if (enemy_last_seen_ < gametime && enemy_last_seen_ + 15 * 60 * 1000 > gametime) {
-			bo.primary_priority_ += 10;
+			bo.primary_priority += 10;
 		}
 
 		// We build one trainig site per X military sites
 		// with some variations, of course
-		bo.primary_priority_ += static_cast<int32_t>(militarysites.size() + productionsites.size())
+		bo.primary_priority += static_cast<int32_t>(militarysites.size() + productionsites.size())
 			- 50 * (ts_basic_count_ + ts_advanced_count_);
 
 		// We prefer basic trainingsites and sites with lower count
-		if (bo.trainingsite_type_ == TrainingSiteType::kBasic) {
-			bo.primary_priority_ += 1;
+		if (bo.trainingsite_type == TrainingSiteType::kBasic) {
+			bo.primary_priority += 1;
 		}
-		bo.primary_priority_ -= 2 * bo.total_count();
+		bo.primary_priority -= 2 * bo.total_count();
 
 		// Special bonus for very first site of type
 		if (bo.total_count() == 0) {
-			bo.primary_priority_ += 30;
+			bo.primary_priority += 30;
 		}
 
-		if (bo.primary_priority_ > 0) {
+		if (bo.primary_priority > 0) {
 			return BuildingNecessity::kNeeded;
 		} else {
 			return BuildingNecessity::kNotNeeded;
@@ -3922,41 +3944,43 @@
 	// Let deal with productionsites now
 	// 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;
+	bo.max_preciousness = 0;
+	bo.max_needed_preciousness = 0;
 
-	for (uint32_t m = 0; m < bo.outputs_.size(); ++m) {
-		DescriptionIndex wt(static_cast<size_t>(bo.outputs_.at(m)));
+	for (uint32_t m = 0; m < bo.outputs.size(); ++m) {
+		DescriptionIndex wt(static_cast<size_t>(bo.outputs.at(m)));
 
 		uint16_t target = tribe_->get_ware_descr(wt)->default_target_quantity(tribe_->name()) / 3;
 		// at least  1
 		target = std::max<uint16_t>(target, 1);
 
-		uint16_t preciousness = wares.at(bo.outputs_.at(m)).preciousness_;
+		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) {
-				bo.max_needed_preciousness_ = preciousness;
+			if (bo.max_needed_preciousness < preciousness) {
+				bo.max_needed_preciousness = preciousness;
 			}
 		}
 
-		if (bo.max_preciousness_ < preciousness) {
-			bo.max_preciousness_ = preciousness;
+		if (bo.max_preciousness < preciousness) {
+			bo.max_preciousness = preciousness;
 		}
 	}
 
-	if (!bo.outputs_.empty()) {
-		assert (bo.max_preciousness_ > 0);
+	if (!bo.outputs.empty()) {
+		assert (bo.max_preciousness > 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) {
+	if (bo.total_count() == 0 &&
+		 bo.upgrade_substitutes &&
+		 bo.type == BuildingObserver::Type::kProductionsite) {
 		const DescriptionIndex enhancement = bo.desc->enhancement();
 		BuildingObserver& en_bo
 			= get_building_observer(tribe_->get_building_descr(enhancement)->name().c_str());
@@ -3964,8 +3988,8 @@
 			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) {
+	if (bo.total_count() == 0 && bo.type == BuildingObserver::Type::kMine) {
+		if (mines_per_type[bo.mines].in_construction + mines_per_type[bo.mines].finished > 0) {
 			has_substitution_building = true;
 		}
 	}
@@ -3976,18 +4000,18 @@
 	// and after 90th minute we want second building unconditionally
 	bool needs_second_for_upgrade = false;
 	if (gametime > 30 * 60 * 1000 &&
-		bo.cnt_built_ == 1 &&
-		bo.cnt_under_construction_ == 0 &&
-		bo.upgrade_extends_ &&
-		!bo.upgrade_substitutes_ &&
-		bo.type == BuildingObserver::PRODUCTIONSITE) {
+		bo.cnt_built == 1 &&
+		bo.cnt_under_construction == 0 &&
+		bo.upgrade_extends &&
+		!bo.upgrade_substitutes &&
+		bo.type == BuildingObserver::Type::kProductionsite) {
 			const DescriptionIndex enhancement = bo.desc->enhancement();
 			BuildingObserver& en_bo
 				= get_building_observer(tribe_->get_building_descr(enhancement)->name().c_str());
 			if ((gametime > 30 * 60 * 1000 && en_bo.total_count() == 0) ||
 			 	gametime > 90 * 60 * 1000) {
 					// We fake this
-					bo.max_needed_preciousness_ = bo.max_preciousness_;
+					bo.max_needed_preciousness = bo.max_preciousness;
 					needs_second_for_upgrade = true;
 			}
 	}
@@ -4003,26 +4027,26 @@
 			; // 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) {
+			if (bo.type == BuildingObserver::Type::kMine) {
+				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.type == BuildingObserver::Type::kProductionsite) {
+				if (bo.produces_building_material || 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) {
+			if (bo.type == BuildingObserver::Type::kMine) {
+				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.type == BuildingObserver::Type::kProductionsite) {
+				if (bo.produces_building_material || bo.max_needed_preciousness >= 10) {
 					if (bo.total_count() <= 1) {
 						needed_type = BuildingNecessity::kNeeded;
 					}
@@ -4034,115 +4058,126 @@
 	// 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_;
+		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) {
+		} else if (bo.prohibited_till > gametime) {
 			return BuildingNecessity::kForbidden;
-		} else if (bo.is_hunter_ || bo.is_fisher_) {
+		} else if (bo.is_hunter || bo.is_fisher) {
 
-			if (bo.max_needed_preciousness_ == 0) {
+			if (bo.max_needed_preciousness == 0) {
 				return BuildingNecessity::kNotNeeded;
-			} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0) {
+			} else if (bo.cnt_under_construction + bo.unoccupied_count > 0) {
 				return BuildingNecessity::kForbidden;
 			} else if (bo.total_count() > 0 && new_buildings_stop_) {
 				return BuildingNecessity::kForbidden;
 			} else {
 				return BuildingNecessity::kNeeded;
 			}
-		} else if (bo.need_trees_) {
-			if (bo.total_count() > 1 && (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0)) {
+		} else if (bo.need_trees) {
+			if (bo.total_count() > 1 && (bo.cnt_under_construction + bo.unoccupied_count > 0)) {
 				return BuildingNecessity::kForbidden;
 			}
-			bo.cnt_target_ =
+			bo.cnt_target =
 					   3 + static_cast<int32_t>(mines_.size() + productionsites.size()) / 20;
 
-			// adjusting/decreasing based on cnt_limit_by_aimode_
-			bo.cnt_target_ = limit_cnt_target(bo.cnt_target_, bo.cnt_limit_by_aimode_);
+			// adjusting/decreasing based on cnt_limit_by_aimode
+			bo.cnt_target = limit_cnt_target(bo.cnt_target, bo.cnt_limit_by_aimode);
 
 			// for case the wood is not needed yet, to avoid inconsistency later on
-			bo.max_needed_preciousness_ = bo.max_preciousness_;
+			bo.max_needed_preciousness = bo.max_preciousness;
 
-			if (bo.total_count() < bo.cnt_target_) {
+			if (bo.total_count() < bo.cnt_target) {
 				return BuildingNecessity::kNeeded;
 			} else {
 				return BuildingNecessity::kAllowed;
 			}
-		} else if (bo.plants_trees_) {
+		} else if (bo.plants_trees) {
 
-			bo.cnt_target_ =
+			bo.cnt_target =
 				   2 +
 				   static_cast<int32_t>(mines_.size() + productionsites.size()) / 40;
 
-			// adjusting/decreasing based on cnt_limit_by_aimode_
-			bo.cnt_target_ = limit_cnt_target(bo.cnt_target_, bo.cnt_limit_by_aimode_);
+			// adjusting/decreasing based on cnt_limit_by_aimode
+			bo.cnt_target = limit_cnt_target(bo.cnt_target, bo.cnt_limit_by_aimode);
 
 			if (wood_policy_ != WoodPolicy::kAllowRangers) {
 				return BuildingNecessity::kForbidden;
 			}
 			// 150 corresponds to 15 trees
 			if (persistent_data->trees_around_cutters < 150) {
-				bo.cnt_target_ *= 4;
+				bo.cnt_target *= 4;
 			}
-			if (bo.total_count() > 1 && (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0)) {
+			if (bo.total_count() > 1 && (bo.cnt_under_construction + bo.unoccupied_count > 0)) {
 				return BuildingNecessity::kForbidden;
-			} else if (bo.total_count() > bo.cnt_target_) {
+			} else if (bo.total_count() > bo.cnt_target) {
 				return BuildingNecessity::kForbidden;
 			}
 			return BuildingNecessity::kNeeded;
-		} else if (bo.need_rocks_ && bo.cnt_under_construction_ + bo.unoccupied_count_ == 0) {
-			bo.max_needed_preciousness_ = bo.max_preciousness_; // even when rocks 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::kForbidden;
-		} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 0 && gametime < 30 * 60 * 1000) {
-			return BuildingNecessity::kForbidden;
-		} else if (bo.cnt_under_construction_ + bo.unoccupied_count_ > 1) {
+		} else if (bo.need_rocks && bo.cnt_under_construction + bo.unoccupied_count == 0) {
+			bo.max_needed_preciousness = bo.max_preciousness; // even when rocks 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::kForbidden;
+		} else if (bo.cnt_under_construction + bo.unoccupied_count > 0 && gametime < 30 * 60 * 1000) {
+			return BuildingNecessity::kForbidden;
+		} else if (bo.cnt_under_construction + bo.unoccupied_count > 1) {
 			return BuildingNecessity::kForbidden; // 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) {
+		} else if (bo.type == BuildingObserver::Type::kMine) {
+			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_;
+				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)
+			} 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_;
+				1) && bo.produces_building_material) {
+					bo.max_needed_preciousness = bo.max_preciousness;
 					return BuildingNecessity::kNeeded;
 			}
-			if (bo.max_needed_preciousness_ == 0) {
+			if (bo.max_needed_preciousness == 0) {
 				return BuildingNecessity::kNotNeeded;
 			}
-			if (bo.current_stats_ < 40) {
+			if (bo.current_stats < 40) {
+				return BuildingNecessity::kForbidden;
+			}
+			assert (bo.last_building_built != kNever);
+			if (gametime < bo.last_building_built + 3 * 60 * 1000) {
 				return BuildingNecessity::kForbidden;
 			}
 			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_);
+		} 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.produces_building_material);
 				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) {
+			if (bo.produces_building_material && bo.total_count() <= 1 && bo.current_stats > 10) {
 				return BuildingNecessity::kNeeded;
-			} else if (bo.inputs_.empty()) {
+			} 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 if (bo.current_stats > 10 + 70 / bo.outputs.size()) {
+				assert (bo.last_building_built != kNever);
+				if (gametime < bo.last_building_built + 10 * 60 * 1000) {
+					// Previous building built less then 10 minutes ago
+					// Wait a bit, perhaps average utilization will drop down in the meantime
+					return BuildingNecessity::kNeededPending;
+				} else {
+					return needed_type;
+				}
 			} else if (needs_second_for_upgrade) {
 				return needed_type;
 			} else {
 				return BuildingNecessity::kForbidden;
 			}
-		} else if (bo.is_shipyard_) {
+		} else if (bo.is_shipyard) {
 			return BuildingNecessity::kAllowed;
-		} else  if (bo.max_needed_preciousness_ == 0) {
+		} else  if (bo.max_needed_preciousness == 0) {
 			return BuildingNecessity::kNotNeeded;
 		} else {
 			return BuildingNecessity::kForbidden;
@@ -4152,9 +4187,9 @@
 		assert (bo.total_count() > 0);
 		if (bo.total_count() == 1) {
 			return BuildingNecessity::kNeeded;
-		} else if (bo.max_preciousness_ >= 10 && bo.total_count() == 2) {
+		} else if (bo.max_preciousness >= 10 && bo.total_count() == 2) {
 			return BuildingNecessity::kNeeded;
-		} else if (bo.current_stats_ > (10 + 70 / bo.outputs_.size()) / 2) {
+		} else if (bo.current_stats > (10 + 70 / bo.outputs.size()) / 2) {
 			return BuildingNecessity::kNeeded;
 		} else {
 			return BuildingNecessity::kNotNeeded;
@@ -4218,15 +4253,15 @@
 uint32_t DefaultAI::get_stocklevel(BuildingObserver& bo) {
 	uint32_t count = std::numeric_limits<uint32_t>::max();
 
-	if (!bo.outputs_.empty()) {
+	if (!bo.outputs.empty()) {
 		for (EconomyObserver* observer : economies) {
 			// Don't check if the economy has no warehouse.
 			if (observer->economy.warehouses().empty()) {
 				continue;
 			}
 
-			for (uint32_t m = 0; m < bo.outputs_.size(); ++m) {
-				DescriptionIndex wt(static_cast<size_t>(bo.outputs_.at(m)));
+			for (uint32_t m = 0; m < bo.outputs.size(); ++m) {
+				DescriptionIndex wt(static_cast<size_t>(bo.outputs.at(m)));
 				if (count > observer->economy.stock_ware(wt)) {
 					count = observer->economy.stock_ware(wt);
 				}
@@ -4336,10 +4371,10 @@
 	}
 
 	// changing priority if basic
-	if (tso.bo->trainingsite_type_ == TrainingSiteType::kBasic) {
-		for (uint32_t k = 0; k < tso.bo->inputs_.size(); ++k) {
+	if (tso.bo->trainingsite_type == TrainingSiteType::kBasic) {
+		for (uint32_t k = 0; k < tso.bo->inputs.size(); ++k) {
 			game().send_player_set_ware_priority(
-			   *ts, wwWARE, tso.bo->inputs_.at(k), HIGH_PRIORITY);
+			   *ts, wwWARE, tso.bo->inputs.at(k), HIGH_PRIORITY);
 		}
 	}
 
@@ -4356,7 +4391,7 @@
 		std::vector<WaresQueue*> const warequeues2 = tso.site->warequeues();
 		nr_warequeues = warequeues2.size();
 		for (size_t i = 0; i < nr_warequeues; ++i) {
-			if (tso.bo->substitute_inputs_.count(warequeues2[i]->get_ware()) > 0) {
+			if (tso.bo->substitute_inputs.count(warequeues2[i]->get_ware()) > 0) {
 				filled += warequeues2[i]->get_filled();
 			}
 		}
@@ -4366,7 +4401,7 @@
 
 		// checking non subsitutes
 		for (size_t i = 0; i < nr_warequeues; ++i) {
-			if (tso.bo->substitute_inputs_.count(warequeues2[i]->get_ware()) == 0) {
+			if (tso.bo->substitute_inputs.count(warequeues2[i]->get_ware()) == 0) {
 				const uint32_t required_amount
 				 =
 				 (warequeues2[i]->get_max_fill() < 5) ? warequeues2[i]->get_max_fill() : 5;
@@ -4434,7 +4469,7 @@
 	// first we make sure there is no enemy at all
 	if (map.find_fields(Area<FCoords>(f, vision + 4), nullptr, find_enemy) == 0) {
 
-		mso.enemies_nearby_ = false;
+		mso.enemies_nearby = false;
 
 		// If no enemy in sight - decrease the number of stationed soldiers
 		// as long as it is > 1 - BUT take care that there is a warehouse in the
@@ -4462,13 +4497,13 @@
 				   map.find_fields(Area<FCoords>(f, vision), nullptr, find_ally);
 
 				int16_t score = 0;
-				score += (bf.area_military_capacity_ > 6);
-				score += (bf.area_military_capacity_ > 22);
-				score += (bf.area_military_presence_ > 4);
-				score += (bf.military_loneliness_ < (180 + persistent_data->ai_personality_military_loneliness));
-				score += (bf.military_stationed_ > 2);
+				score += (bf.area_military_capacity > 6);
+				score += (bf.area_military_capacity > 22);
+				score += (bf.area_military_presence > 4);
+				score += (bf.military_loneliness < (180 + persistent_data->ai_personality_military_loneliness));
+				score += (bf.military_stationed > 2);
 				score -= size_penalty;
-				score += ((bf.unowned_land_nearby_ + allyOwnedFields) < 10);
+				score += ((bf.unowned_land_nearby + allyOwnedFields) < 10);
 
 				if (score >= 4) {
 					if (ms->get_playercaps() & Widelands::Building::PCap_Dismantle) {
@@ -4487,7 +4522,7 @@
 		uint32_t unused1 = 0;
 		uint16_t unused2 = 0;
 
-		mso.enemies_nearby_ = false;
+		mso.enemies_nearby = false;
 
 		// yes enemy is nearby, but still we must distinguish whether
 		// he is accessible (over the land)
@@ -4507,7 +4542,7 @@
 				changed = true;
 			}
 
-			mso.enemies_nearby_ = true;
+			mso.enemies_nearby = true;
 			enemy_last_seen_ = gametime;
 		} else {  // otherwise decrease soldiers
 			uint32_t const j = ms->soldier_capacity();
@@ -4544,21 +4579,24 @@
 		return prio;
 	}
 
-	if (bf.enemy_nearby_ || bf.near_border_) {
+	if (bf.enemy_nearby || bf.near_border) {
 		prio /= 2;
 	}
 
 	// if unowned territory nearby
-	prio -= bf.unowned_land_nearby_ / 4;
+	prio -= bf.unowned_land_nearby / 4;
 
 	// further decrease the score if enemy nearby
-	if (bf.enemy_nearby_) {
+	if (bf.enemy_nearby) {
 		prio -= 10;
 	}
 
 	// and if close (up to 2 fields away) from border
-	if (bf.near_border_) {
+	if (bf.near_border) {
 		prio -= 10;
+		if (spots_ < kSpotsEnough) {
+			prio +=  3 * (spots_ - kSpotsEnough);
+		}
 	}
 
 	return prio;
@@ -4567,25 +4605,25 @@
 void DefaultAI::consider_productionsite_influence(BuildableField& field,
                                                   Coords coords,
                                                   const BuildingObserver& bo) {
-	if (bo.space_consumer_ && !bo.plants_trees_ &&
+	if (bo.space_consumer && !bo.plants_trees &&
 	    game().map().calc_distance(coords, field.coords) < 8) {
-		++field.space_consumers_nearby_;
-	}
-
-	for (size_t i = 0; i < bo.inputs_.size(); ++i) {
-		++field.consumers_nearby_.at(bo.inputs_.at(i));
-	}
-
-	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_) {
-		++field.rangers_nearby_;
+		++field.space_consumers_nearby;
+	}
+
+	for (size_t i = 0; i < bo.inputs.size(); ++i) {
+		++field.consumers_nearby.at(bo.inputs.at(i));
+	}
+
+	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) {
+		++field.rangers_nearby;
 	}
 }
 
@@ -4693,8 +4731,8 @@
 	// 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) {
-			if (i->no_resources_since_ > gametime) {
-				i->no_resources_since_ = gametime;
+			if (i->no_resources_since > gametime) {
+				i->no_resources_since = gametime;
 			}
 			break;
 		}
@@ -4732,7 +4770,7 @@
 	Map& map = game().map();
 	std::list<uint32_t> queue;
 	std::unordered_set<uint32_t> done;
-	queue.push_front(coords_hash(starting_spot));
+	queue.push_front(starting_spot.hash());
 	PlayerNumber const pn = player_->player_number();
 
 	while (!queue.empty()) {
@@ -4744,7 +4782,7 @@
 
 		done.insert(queue.front());
 
-		Coords tmp_coords = coords_unhash(queue.front());
+		Coords tmp_coords = Coords::unhash(queue.front());
 
 		// if beyond range
 		if (map.calc_distance(starting_spot, tmp_coords) > max_distance) {
@@ -4777,7 +4815,7 @@
 
 			// if owned by enemy
 			if  (type == WalkSearch::kEnemy && f->get_owned_by() != pn) {
-				// for case I am not member of a team
+				// in case I am not member of a team
 				if (player_->team_number() == 0) {
 					*tested_fields = done.size();
 					return true;
@@ -4807,7 +4845,7 @@
 			map.get_neighbour(tmp_coords, dir, &neigh_coords1);
 			Coords neigh_coords2;
 			map.get_neighbour(neigh_coords1, dir, &neigh_coords2);
-			queue.push_front(coords_hash(neigh_coords2));
+			queue.push_front(neigh_coords2.hash());
 		}
 	}
 	*tested_fields = done.size();
@@ -4889,11 +4927,11 @@
 	Map& map = game().map();
 	const int32_t gametime = game().get_gametime();
 
-	// second we put current spot into visited_spots_
+	// second we put current spot into visited_spots
 	bool first_time_here = false;
-	if (so.visited_spots_.count(coords_hash(so.ship->get_position())) == 0) {
+	if (so.visited_spots.count(so.ship->get_position().hash()) == 0) {
 		first_time_here = true;
-		so.visited_spots_.insert(coords_hash(so.ship->get_position()));
+		so.visited_spots.insert(so.ship->get_position().hash());
 	}
 
 	// If we have portspace following options are avaiable:
@@ -4914,9 +4952,7 @@
 			MapRegion<Area<FCoords>> mr(
 			   game().map(), Area<FCoords>(map.get_fcoords(so.ship->exp_port_spaces().front()), 8));
 			do {
-				BlockedField blocked2(
-				   map.get_fcoords(*(mr.location().field)), gametime + 5 * 60 * 1000);
-				blocked_fields.push_back(blocked2);
+				blocked_fields.add(mr.location(), game().get_gametime() + 5 * 60 * 1000);
 			} while (mr.advance(map));
 
 			return;
@@ -4980,24 +5016,24 @@
 
 	BuildingObserver& bo = get_building_observer(b.descr().name().c_str());
 
-	if (bo.type == BuildingObserver::CONSTRUCTIONSITE) {
+	if (bo.type == BuildingObserver::Type::kConstructionsite) {
 		BuildingObserver& target_bo =
 		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
-		++target_bo.cnt_under_construction_;
-		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
+		++target_bo.cnt_under_construction;
+		if (target_bo.type == BuildingObserver::Type::kProductionsite) {
 			++num_prod_constructionsites;
 		}
-		if (target_bo.type == BuildingObserver::MILITARYSITE) {
+		if (target_bo.type == BuildingObserver::Type::kMilitarysite) {
 			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;
+		if (target_bo.type == BuildingObserver::Type::kMine) {
+			mines_per_type[target_bo.mines].in_construction += 1;
 		}
-		if (target_bo.type == BuildingObserver::TRAININGSITE) {
-			if (target_bo.trainingsite_type_ == TrainingSiteType::kBasic) {
+		if (target_bo.type == BuildingObserver::Type::kTrainingsite) {
+			if (target_bo.trainingsite_type == TrainingSiteType::kBasic) {
 				ts_basic_const_count_ += 1;
 			}
-			if (target_bo.trainingsite_type_ == TrainingSiteType::kAdvanced) {
+			if (target_bo.trainingsite_type == TrainingSiteType::kAdvanced) {
 				ts_advanced_const_count_ += 1;
 			}
 		}
@@ -5005,72 +5041,74 @@
 		set_taskpool_task_time(game().get_gametime(), SchedulerTaskId::kRoadCheck);
 
 	} else {
-		++bo.cnt_built_;
+		++bo.cnt_built;
+		const uint32_t gametime = game().get_gametime();
+		bo.last_building_built = gametime;
 
-		if (bo.type == BuildingObserver::PRODUCTIONSITE) {
+		if (bo.type == BuildingObserver::Type::kProductionsite) {
 			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_since_ =  kNever;
-			productionsites.back().bo->unoccupied_count_ += 1;
-			if (bo.is_shipyard_) {
+			productionsites.back().bo->new_building_overdue = 0;
+			productionsites.back().built_time = gametime;
+			productionsites.back().unoccupied_till = gametime;
+			productionsites.back().stats_zero = 0;
+			productionsites.back().no_resources_since =  kNever;
+			productionsites.back().bo->unoccupied_count += 1;
+			if (bo.is_shipyard) {
 				marine_task_queue.push_back(kStopShipyard);
 				marine_task_queue.push_back(kReprioritize);
 			}
 
-			for (uint32_t i = 0; i < bo.outputs_.size(); ++i)
-				++wares.at(bo.outputs_.at(i)).producers_;
+			for (uint32_t i = 0; i < bo.outputs.size(); ++i)
+				++wares.at(bo.outputs.at(i)).producers;
 
-			for (uint32_t i = 0; i < bo.inputs_.size(); ++i)
-				++wares.at(bo.inputs_.at(i)).consumers_;
-		} else if (bo.type == BuildingObserver::MINE) {
+			for (uint32_t i = 0; i < bo.inputs.size(); ++i)
+				++wares.at(bo.inputs.at(i)).consumers;
+		} else if (bo.type == BuildingObserver::Type::kMine) {
 			mines_.push_back(ProductionSiteObserver());
 			mines_.back().site = &dynamic_cast<ProductionSite&>(b);
 			mines_.back().bo = &bo;
-			mines_.back().built_time_ = game().get_gametime();
-			mines_.back().no_resources_since_ =  kNever;
-			mines_.back().bo->unoccupied_count_ += 1;
-
-			for (uint32_t i = 0; i < bo.outputs_.size(); ++i)
-				++wares.at(bo.outputs_.at(i)).producers_;
-
-			for (uint32_t i = 0; i < bo.inputs_.size(); ++i)
-				++wares.at(bo.inputs_.at(i)).consumers_;
-
-			mines_per_type[bo.mines_].finished += 1;
-
-		} else if (bo.type == BuildingObserver::MILITARYSITE) {
+			mines_.back().built_time = gametime;
+			mines_.back().no_resources_since =  kNever;
+			mines_.back().bo->unoccupied_count += 1;
+
+			for (uint32_t i = 0; i < bo.outputs.size(); ++i)
+				++wares.at(bo.outputs.at(i)).producers;
+
+			for (uint32_t i = 0; i < bo.inputs.size(); ++i)
+				++wares.at(bo.inputs.at(i)).consumers;
+
+			mines_per_type[bo.mines].finished += 1;
+
+		} else if (bo.type == BuildingObserver::Type::kMilitarysite) {
 			militarysites.push_back(MilitarySiteObserver());
 			militarysites.back().site = &dynamic_cast<MilitarySite&>(b);
 			militarysites.back().bo = &bo;
 			militarysites.back().checks = bo.desc->get_size();
-			militarysites.back().enemies_nearby_ = true;
+			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) {
+		} else if (bo.type == BuildingObserver::Type::kTrainingsite) {
 			ts_without_trainers_ += 1;
 			trainingsites.push_back(TrainingSiteObserver());
 			trainingsites.back().site = &dynamic_cast<TrainingSite&>(b);
 			trainingsites.back().bo = &bo;
-			if (bo.trainingsite_type_ == TrainingSiteType::kBasic) {
+			if (bo.trainingsite_type == TrainingSiteType::kBasic) {
 				ts_basic_count_ += 1;
 			}
-			if (bo.trainingsite_type_ == TrainingSiteType::kAdvanced) {
+			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) {
+		} else if (bo.type == BuildingObserver::Type::kWarehouse) {
 			++numof_warehouses_;
 			warehousesites.push_back(WarehouseSiteObserver());
 			warehousesites.back().site = &dynamic_cast<Warehouse&>(b);
 			warehousesites.back().bo = &bo;
-			if (bo.is_port_) {
+			if (bo.is_port) {
 				++num_ports;
 				seafaring_economy = true;
 				// unblock nearby fields, might be used for other buildings...
@@ -5078,7 +5116,7 @@
 				MapRegion<Area<FCoords>> mr(
 				   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)));
+					const int32_t hash = map.get_fcoords(*(mr.location().field)).hash();
 					if (port_reserved_coords.count(hash) > 0)
 						port_reserved_coords.erase(hash);
 				} while (mr.advance(map));
@@ -5092,46 +5130,46 @@
 
 	BuildingObserver& bo = get_building_observer(b.descr().name().c_str());
 
-	if (bo.type == BuildingObserver::CONSTRUCTIONSITE) {
+	if (bo.type == BuildingObserver::Type::kConstructionsite) {
 		BuildingObserver& target_bo =
 		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
-		--target_bo.cnt_under_construction_;
-		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
+		--target_bo.cnt_under_construction;
+		if (target_bo.type == BuildingObserver::Type::kProductionsite) {
 			--num_prod_constructionsites;
 		}
-		if (target_bo.type == BuildingObserver::MILITARYSITE) {
+		if (target_bo.type == BuildingObserver::Type::kMilitarysite) {
 			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;
+		if (target_bo.type == BuildingObserver::Type::kMine) {
+			mines_per_type[target_bo.mines].in_construction -= 1;
 		}
-		if (target_bo.type == BuildingObserver::TRAININGSITE) {
-			if (target_bo.trainingsite_type_ == TrainingSiteType::kBasic) {
+		if (target_bo.type == BuildingObserver::Type::kTrainingsite) {
+			if (target_bo.trainingsite_type == TrainingSiteType::kBasic) {
 				ts_basic_const_count_ -= 1;
 				assert(ts_basic_const_count_ >= 0);
 			}
-			if (target_bo.trainingsite_type_ == TrainingSiteType::kAdvanced) {
+			if (target_bo.trainingsite_type == TrainingSiteType::kAdvanced) {
 				ts_advanced_const_count_ -= 1;
 				assert(ts_advanced_const_count_ >= 0);
 			}
 		}
 
 	} else {
-		--bo.cnt_built_;
+		--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) {
+		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::Type::kProductionsite) {
 
 			for (std::list<ProductionSiteObserver>::iterator i = productionsites.begin();
 			     i != productionsites.end();
@@ -5141,15 +5179,15 @@
 					break;
 				}
 
-			for (uint32_t i = 0; i < bo.outputs_.size(); ++i) {
-				--wares.at(bo.outputs_.at(i)).producers_;
-			}
-
-			for (uint32_t i = 0; i < bo.inputs_.size(); ++i) {
-				--wares.at(bo.inputs_.at(i)).consumers_;
-			}
-
-		} else if (bo.type == BuildingObserver::MINE) {
+			for (uint32_t i = 0; i < bo.outputs.size(); ++i) {
+				--wares.at(bo.outputs.at(i)).producers;
+			}
+
+			for (uint32_t i = 0; i < bo.inputs.size(); ++i) {
+				--wares.at(bo.inputs.at(i)).consumers;
+			}
+
+		} else if (bo.type == BuildingObserver::Type::kMine) {
 			for (std::list<ProductionSiteObserver>::iterator i = mines_.begin(); i != mines_.end();
 			     ++i) {
 				if (i->site == &b) {
@@ -5158,17 +5196,17 @@
 				}
 			}
 
-			for (uint32_t i = 0; i < bo.outputs_.size(); ++i) {
-				--wares.at(bo.outputs_.at(i)).producers_;
-			}
-
-			for (uint32_t i = 0; i < bo.inputs_.size(); ++i) {
-				--wares.at(bo.inputs_.at(i)).consumers_;
-			}
-
-			mines_per_type[bo.mines_].finished -= 1;
-
-		} else if (bo.type == BuildingObserver::MILITARYSITE) {
+			for (uint32_t i = 0; i < bo.outputs.size(); ++i) {
+				--wares.at(bo.outputs.at(i)).producers;
+			}
+
+			for (uint32_t i = 0; i < bo.inputs.size(); ++i) {
+				--wares.at(bo.inputs.at(i)).consumers;
+			}
+
+			mines_per_type[bo.mines].finished -= 1;
+
+		} else if (bo.type == BuildingObserver::Type::kMilitarysite) {
 			msites_per_size[bo.desc->get_size()].finished -= 1;
 
 			for (std::list<MilitarySiteObserver>::iterator i = militarysites.begin();
@@ -5179,28 +5217,28 @@
 					break;
 				}
 			}
-		} else if (bo.type == BuildingObserver::TRAININGSITE) {
+		} else if (bo.type == BuildingObserver::Type::kTrainingsite) {
 
 			for (std::list<TrainingSiteObserver>::iterator i = trainingsites.begin();
 			     i != trainingsites.end();
 			     ++i) {
 				if (i->site == &b) {
 					trainingsites.erase(i);
-					if (bo.trainingsite_type_ == TrainingSiteType::kBasic) {
+					if (bo.trainingsite_type == TrainingSiteType::kBasic) {
 						ts_basic_count_ -= 1;
 						assert(ts_basic_count_ >= 0);
 					}
-					if (bo.trainingsite_type_ == TrainingSiteType::kAdvanced) {
+					if (bo.trainingsite_type == TrainingSiteType::kAdvanced) {
 						ts_advanced_count_ -= 1;
 						assert(ts_advanced_count_ >= 0);
 					}
 					break;
 				}
 			}
-		} else if (bo.type == BuildingObserver::WAREHOUSE) {
+		} else if (bo.type == BuildingObserver::Type::kWarehouse) {
 			assert(numof_warehouses_ > 0);
 			--numof_warehouses_;
-			if (bo.is_port_) {
+			if (bo.is_port) {
 				--num_ports;
 			}
 
@@ -5217,17 +5255,17 @@
 }
 
 // Checks that supply line exists for given building.
-// Recursively verify that all inputs_ have a producer.
+// Recursively verify that all inputs have a producer.
 // TODO(unknown): this function leads to periodic freezes of ~1 second on big games on my system.
 // TODO(unknown): It needs profiling and optimization.
 // NOTE: This is not needed anymore and it seems it is not missed neither
 bool DefaultAI::check_supply(const BuildingObserver& bo) {
 	size_t supplied = 0;
-	for (const int16_t& temp_inputs : bo.inputs_) {
+	for (const int16_t& temp_inputs : bo.inputs) {
 		for (const BuildingObserver& temp_building : buildings_) {
-			if (temp_building.cnt_built_ &&
-			    std::find(temp_building.outputs_.begin(), temp_building.outputs_.end(), temp_inputs) !=
-			       temp_building.outputs_.end() &&
+			if (temp_building.cnt_built &&
+			    std::find(temp_building.outputs.begin(), temp_building.outputs.end(), temp_inputs) !=
+			       temp_building.outputs.end() &&
 			    check_supply(temp_building)) {
 				++supplied;
 				break;
@@ -5235,7 +5273,7 @@
 		}
 	}
 
-	return supplied == bo.inputs_.size();
+	return supplied == bo.inputs.size();
 }
 
 // This calculates strength of vector of soldiers, f.e. soldiers in a building or
@@ -5301,40 +5339,34 @@
 	Map& map = game().map();
 
 	// define which players are attackable
-	std::vector<bool> player_attackable;
+	std::vector<Attackable> player_attackable;
 	PlayerNumber const nr_players = map.get_nrplayers();
 	player_attackable.resize(nr_players);
 	uint32_t plr_in_game = 0;
-	uint16_t const pn = player_number();
+	Widelands::PlayerNumber const pn = player_number();
 
 	iterate_players_existing_novar(p, nr_players, game())++ plr_in_game;
 
 	// receiving games statistics and parsing it (reading latest entry)
 	const Game::GeneralStatsVector& genstats = game().get_general_statistics();
 
-	// summing team power, creating team_power std::map of team_number:strength
-	std::map<TeamNumber, uint32_t> team_power;
-	for (uint8_t j = 1; j <= plr_in_game; ++j) {
-		const Player* other = game().get_player(j);
-		const TeamNumber tm = other ? other->team_number() : 0;
-		if (tm == 0) {
-			continue;
-		}
-		// for case this is new team
-		if (team_power.count(tm) == 0) {
-			// adding this team (number) to vector
-			team_power[tm] = 0;
-		}
-		try {
-			team_power[tm] += genstats.at(j - 1).miltary_strength.back();
-		} catch (const std::out_of_range&) {
-			log("ComputerPlayer(%d): genstats entry missing - size :%d\n",
-			    player_number(),
-			    static_cast<unsigned int>(genstats.size()));
+	// Collecting statistics and saving them in player_statistics object
+	for (Widelands::TeamNumber j = 1; j <= plr_in_game; ++j) {
+		const Player* this_player = game().get_player(j);
+		if (this_player) {
+			try {
+				player_statistics.add(j, this_player->team_number(), genstats.at(j - 1).miltary_strength.back());
+			} catch (const std::out_of_range&) {
+				log("ComputerPlayer(%d): genstats entry missing - size :%d\n",
+					 static_cast<unsigned int>(player_number()),
+				    static_cast<unsigned int>(genstats.size()));
+			}
 		}
 	}
 
-	// defining treshold ratio of own_strength/enemy's_strength
+	player_statistics.recalculate_team_power();
+
+	// defining treshold ratio of own_strength/enemy's strength
 	uint32_t treshold_ratio = 100;
 	if (type_ == DefaultAI::Type::kNormal) {
 		treshold_ratio = 80;
@@ -5348,7 +5380,7 @@
 	// 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_
+	// 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
@@ -5358,65 +5390,37 @@
 		treshold_ratio += persistent_data->ai_personality_attack_margin;
 	}
 
-	uint32_t my_power = 0;
-	try {
-		my_power = genstats.at(pn - 1).miltary_strength.back();
-	} catch (const std::out_of_range&) {
-		log("ComputerPlayer(%d): genstats entry missing - size :%d\n",
-		    player_number(),
-		    static_cast<unsigned int>(genstats.size()));
-	}
-	// adding power of team (minus my power) divided by 2
-	// (if I am a part of a team of course)
-	const TeamNumber team_number = player_->team_number();
-	if (team_number > 0) {
-		my_power += (team_power[team_number] - my_power) / 2;
-	}
+	const uint32_t my_power = player_statistics.get_modified_player_power(pn);
+
 
 	// now we test all players to identify 'attackable' ones
-	for (uint8_t j = 1; j <= plr_in_game; ++j) {
-		// if it's me
-		if (pn == j) {
-			player_attackable[j - 1] = false;
-			continue;
-		}
-		// if we are the same team
-		const Player* other = game().get_player(j);
-		const TeamNumber tm = other ? other->team_number() : 0;
-		if (team_number > 0 && team_number == tm) {
-			player_attackable[j - 1] = false;
+	for (Widelands::PlayerNumber j = 1; j <= plr_in_game; ++j) {
+		// if we are the same team, or it is just me
+		if (player_statistics.players_in_same_team(pn, j) || pn == j) {
+			player_attackable[j - 1] = Attackable::kNotAttackable;
 			continue;
 		}
 
 		// now we compare strength
-		try {
-			// strength of the other player
-			uint32_t players_power = 0;
-			if (!genstats.at(j - 1).miltary_strength.empty()) {
-				players_power += genstats.at(j - 1).miltary_strength.back();
-			}
-			// +power of team (if member of a team)
-			if (tm > 0) {
-				players_power += (team_power[tm] - players_power) / 2;
-			}
+		// strength of the other player (considering his team)
+		uint32_t players_power = player_statistics.get_modified_player_power(j);
 
-			if (players_power == 0) {
-				player_attackable.at(j - 1) = true;
-			} else if (my_power * 100 / players_power > treshold_ratio) {
-				player_attackable.at(j - 1) = true;
-			} else {
-				player_attackable.at(j - 1) = false;
-			}
-		} catch (const std::out_of_range&) {
-			log("ComputerPlayer(%d): genstats entry missing - size :%d\n",
-			    player_number(),
-			    static_cast<unsigned int>(genstats.size()));
-			player_attackable.at(j - 1) = false;
+		if (players_power == 0) {
+			player_attackable.at(j - 1) = Attackable::kAttackable;
+		} else if (my_power * 100 / players_power > treshold_ratio * 8) {
+			player_attackable.at(j - 1) = Attackable::kAttackableVeryWeak;
+		} else if (my_power * 100 / players_power > treshold_ratio * 4) {
+			player_attackable.at(j - 1) = Attackable::kAttackableAndWeak;
+		} else if (my_power * 100 / players_power > treshold_ratio) {
+			player_attackable.at(j - 1) = Attackable::kAttackable;
+		} else {
+			player_attackable.at(j - 1) = Attackable::kNotAttackable;
 		}
+
 	}
 
 	// first we scan vicitnity of couple of militarysites to get new enemy sites
-	// militarysites rotate
+	// Militarysites rotate (see check_militarysites())
 	int32_t i = 0;
 	for (MilitarySiteObserver mso : militarysites) {
 		i += 1;
@@ -5438,15 +5442,15 @@
 		for (uint32_t j = 0; j < immovables.size(); ++j) {
 			if (upcast(MilitarySite const, bld, immovables.at(j).object)) {
 				if (player_->is_hostile(bld->owner())) {
-					if (enemy_sites.count(coords_hash(bld->get_position())) == 0) {
-						enemy_sites[coords_hash(bld->get_position())] = EnemySiteObserver();
+					if (enemy_sites.count(bld->get_position().hash()) == 0) {
+						enemy_sites[bld->get_position().hash()] = EnemySiteObserver();
 					}
 				}
 			}
 			if (upcast(Warehouse const, wh, immovables.at(j).object)) {
 				if (player_->is_hostile(wh->owner())) {
-					if (enemy_sites.count(coords_hash(wh->get_position())) == 0) {
-						enemy_sites[coords_hash(wh->get_position())] = EnemySiteObserver();
+					if (enemy_sites.count(wh->get_position().hash()) == 0) {
+						enemy_sites[wh->get_position().hash()] = EnemySiteObserver();
 					}
 				}
 			}
@@ -5506,6 +5510,8 @@
 			;
 	}
 
+	const bool strong_enough = player_statistics.strong_enough(pn);
+
 	for (std::map<uint32_t, EnemySiteObserver>::iterator site = enemy_sites.begin();
 	     site != enemy_sites.end();
 	     ++site) {
@@ -5523,12 +5529,12 @@
 		bool is_attackable = false;
 		// we cannot attack unvisible site and there is no other way to find out
 		const bool is_visible = (1 < player_->vision
-			 	(Map::get_index(coords_unhash(site->first), map.get_width())));
+				(Map::get_index(Coords::unhash(site->first), map.get_width())));
 		uint16_t owner_number = 100;
 
 		// testing if we can attack the building - result is a flag
 		// if we dont get a flag, we remove the building from observers list
-		FCoords f = map.get_fcoords(coords_unhash(site->first));
+		FCoords f = map.get_fcoords(Coords::unhash(site->first));
 		uint32_t site_to_be_removed = std::numeric_limits<uint32_t>::max();
 		Flag* flag = nullptr;
 
@@ -5576,7 +5582,7 @@
 				}
 			}
 
-			site->second.warehouse_ = is_warehouse;
+			site->second.is_warehouse = is_warehouse;
 
 			// getting rid of default
 			if (site->second.last_time_attackable == kNever) {
@@ -5598,7 +5604,9 @@
 
 			if (site->second.attack_soldiers_strength > 0
 				&&
-				player_attackable[owner_number - 1]) {
+				(player_attackable[owner_number - 1] == Attackable::kAttackable ||
+				player_attackable[owner_number - 1] == Attackable::kAttackableAndWeak ||
+				player_attackable[owner_number - 1] == Attackable::kAttackableVeryWeak)) {
 				site->second.score = site->second.attack_soldiers_strength - site->second.defenders_strength / 2;
 
 				if (is_warehouse) {
@@ -5626,6 +5634,19 @@
 				// Applying (decreasing score) if trainingsites are not working
 				site->second.score += training_score;
 
+				// We have an advantage over stongest opponent
+				if (strong_enough) {
+					site->second.score += 3;
+				}
+
+				// Enemy is too weak, be more aggressive attacking him
+				if (player_attackable[owner_number - 1] == Attackable::kAttackableAndWeak) {
+					site->second.score += 4;
+				}
+				if (player_attackable[owner_number - 1] == Attackable::kAttackableVeryWeak) {
+					site->second.score += 8;
+				}
+
 				// treating no attack score
 				if (site->second.no_attack_counter < 0) {
 					// we cannot attack yet
@@ -5682,7 +5703,7 @@
 	assert(enemy_sites.count(best_target) > 0);
 
 	// attacking
-	FCoords f = map.get_fcoords(coords_unhash(best_target));
+	FCoords f = map.get_fcoords(Coords::unhash(best_target));