Merge lp:~widelands-dev/widelands/ai-post-b19-2 into lp:widelands

[GunChleoc]

Same proposal as Tibor made, but with prerequisite branch set. Thanks to Launchpad for not letting me add it/hiding the option in the UI.

I would like to propose this branch for merge. The changes are really big, the genetic algorithm itself and many other changes that was done along the way.
The problem is that this is kind of one-way road. Once the genetic algorithm will be in trunk, it will be difficult to come back. Or rather it will be possible but a lot of logic will need to be re-created/tested manually.

Follow up action will be to prepare saving and loading AI data to and from separate text/lua file, so that training AI will not require changes in ai_help_structs.cc and recompilation.

We can do review/code fix in multiple steps...

[GunChleoc (gunchleoc)]

@Tibor I recreated this to have a smaller diff - the trainingsites proportions branch needs to go in first.

https://code.launchpad.net/~widelands-dev/widelands/ai_trainingsites_proportion/+merge/324607

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2308. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/243585362.
Appveyor build 2142. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2142.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2330. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/244936136.
Appveyor build 2158. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2158.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2332. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/245083207.
Appveyor build 2160. State: failed. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2160.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2335. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/245269883.
Appveyor build 2163. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2163.

[GunChleoc (gunchleoc)]

Code review done.

1. Please go over my changes with a fine-tooth comb to make sure that I haven't accidentally introduced any logic changes.

2. Was the test suite already broken, or did I break it with my changes?

3. We need to keep savegame compatibility until after Bzuild 20, so savegames will remain viable for bug fixing. I have added some code so that old savegames will load, but the games will segfault, because something still needs initializing. Since you know the code better than I, can you have a look?

4. We have a bunch of hard coded ware and building names that I'd like to get rid of. Turn anything that's too complicated to solve right now into a TODO comment, so that we can fix it in a follow-up branch.

5. I found a bunch of commented out code lines, I left them in with a NOCOM comment so that you can decide if you still want them someplace.

6. I think we should have a command line switch for the training mode, so we won't have to recompile to switch modes. Let me know if you want me to take care of it.

Note that I will be unable to contribute code for a few weeks starting from Thursday next week, so if you want me to do any more coding in this branch, please let me know ASAP.

[TiborB (tiborb95)]

Gun,

thanks for review!

Savegame compatibility is quite tricky. I will look at this but I believe that proper strategy is just to ignore previous AI data (from older packet) and initialize AI data from scratch.

I also dont like addressing buildings by name, and when we discuss AI changes on forum, most players gives advices specific for buildings&tribes. I am trying to avoid this as much as possible.

I can introduce bunch of new ai_hints like "is_bakery", though opposite would be better (per each tribe):
bakery:"barbarian_bakery"
woodcutter:"barbarian_lumberjack"

For now AI expects on some spaces in code that there is exactly one building of the type. But entries in "ai_hints" are OK, and AI will make sure the building is identified, and just one.

I will start with save/load stuff....

[GunChleoc (gunchleoc)]

> Savegame compatibility is quite tricky. I will look at this but I believe that proper strategy is just to ignore previous AI data (from older packet) and initialize AI data from scratch.

I agree - we have to run the loading to eat uo the packets, but
initializing the AI data from scratch will be the way to go.

> I also dont like addressing buildings by name, and when we discuss AI changes on forum, most players gives advices specific for buildings&tribes. I am trying to avoid this as much as possible.
>
> I can introduce bunch of new ai_hints like "is_bakery", though opposite would be better (per each tribe):
> bakery:"barbarian_bakery"
> woodcutter:"barbarian_lumberjack"

You mean like we have for the port & barracks? I could implement that
pretty easily.

[TiborB (tiborb95)]

>> I can introduce bunch of new ai_hints like "is_bakery", though opposite would be better (per each tribe):
>> bakery:"barbarian_bakery"
>> woodcutter:"barbarian_lumberjack"

?You mean like we have for the port & barracks? I could implement that

Do you mean through "ai_hints"? I have to fix also "is_basic" - as you suggested, so I can to it at once. I want to be sure it is properly "plugged" to default_ai.cc

[GunChleoc (gunchleoc)]

>>> I can introduce bunch of new ai_hints like "is_bakery", though opposite would be better (per each tribe):
>>> bakery:"barbarian_bakery"
>>> woodcutter:"barbarian_lumberjack"
>
> ?You mean like we have for the port & barracks? I could implement that
>
> Do you mean through "ai_hints"? I have to fix also "is_basic" - as you suggested, so I can to it at once. I want to be sure it is properly "plugged" to default_ai.cc

No, I thought that you meant this:

https://bazaar.launchpad.net/~widelands-dev/widelands/trunk/view/head:/data/tribes/atlanteans.lua#L353

and this:

https://bazaar.launchpad.net/~widelands-dev/widelands/trunk/view/head:/src/logic/map_objects/tribes/tribe_descr.h#L106

AI hints will certainly work though.

[TiborB (tiborb95)]

I did not know about this code, it seems to be exactly what is needed. I will use this. I will implement it myself, I want to make myself familiar with this stuff.

[GunChleoc (gunchleoc)]

Sounds good to me. Holler if you need help.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2339. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/245680347.
Appveyor build 2167. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2167.

[GunChleoc (gunchleoc)]

I ran the test suite on r8148 (the last revision before I started changing stuff) and it went though for the release build, but had 3 failures on the debug build.

[TiborB (tiborb95)]

@Gun,
I found that the game crashes on line:

if (field.coords.field->get_immovable()->descr().type() == Widelands::MapObjectType::MILITARYSITE) {

(gdb) bt
#0 0x0000000000ce6f5a in Widelands::MapObject::descr (this=0x0)
    at /var/widelands2/BZR/ai-post-b19-2/src/logic/map_objects/map_object.h:229
#1 0x000000000111c015 in DefaultAI::update_buildable_field (this=0x9d9cc60, field=...)
    at /var/widelands2/BZR/ai-post-b19-2/src/ai/defaultai.cc:1243
#2 0x000000000111bc9e in DefaultAI::update_all_not_buildable_fields (this=0x9d9cc60)
    at /var/widelands2/BZR/ai-post-b19-2/src/ai/defaultai.cc:1204

Do you know what had you changed? It worked for sure before...

[TiborB (tiborb95)]

> I ran the test suite on r8148 (the last revision before I started changing stuff) and it went though for the release build, but had 3 failures on the debug build.

The log says it is failed assert in AI code, there is player statistics (land, enemy size) missing - I can work this around easily, so do not bother yourself about it..

[TiborB (tiborb95)]

re:
if (field.coords.field->get_immovable()->descr().type() == Widelands::MapObjectType::MILITARYSITE) {
crash

it crashes also with brand new game, so it is not related to save/load

[GunChleoc (gunchleoc)]

That's a change I made because it's more efficient than an upcast (I recenty learned that dynamic_cast is expensive). This of course assumes that there is an immovable on the field.

So, either test if the immovable is nullptr first, or change back to upcast.

[TiborB (tiborb95)]

OK, makes sense. I did not know you had changed that line. I will add a test there if there is a building there.

[SirVer (sirver)]

drive by: I like this stack overflow for information about dynamic_cast<> cost: https://stackoverflow.com/questions/4050901/performance-of-dynamic-cast

tl;dr: dynamic_cast<> is not crazy expensive, but if you can do without, great. It also is usually bad design if you require dynamic_cast<> - but unfortunately, we have plenty of bad design in Widelands, so you have to use it sometimes, since you cannot design around our errors of the past.

[GunChleoc (gunchleoc)]

BTW comments like

  //Should happen only rarely so we print a warning here

will break codecheck, always use a blank space:

  // Should happen only rarely so we print a warning here

Regarding your question in the code, size_t is an unsigned type http://www.cplusplus.com/reference/cstddef/size_t/?kw=size_t

[TiborB (tiborb95)]

I presume that clang-format will take care of that, will not? Once all changes are done I will run clang-format and retest and let you know.

in 8163 I introduced new special wares, investigate diff for this revision if you are interested. I did not introduce the helper function, I think we can manage without it, especially now, when I shortened the code. But if you insist I can.

[TiborB (tiborb95)]

Gun,
I did some changes to critical materials stuff, I made some mistakes in 8163 it seems.

Also there are some notes for you, look for "@Gun" in the diff

The biggest issue that remains is that command line switch, I have to investigate this a bit

[GunChleoc (gunchleoc)]

I have answered the notes. I have also renamed "stones" to "granite". This was a leftover from my terminology cleanup for Build19 that was never implemented in the AI variables and functions - "stones" it the mountain map resource, "granite" is the ware now. The immovables littered around the map are "rocks".

I think you can get rid of one of the new definitions. If a building has refinedlog() listed in its outputs, it is automatically a logrefiner().

Also, why do we need this assertion?

    assert(count_buildings_with_attribute(BuildingAttribute::kIronMine) <= 3);

If somebody mods a tribe with even more mine upgrades, or many different types of iron ore producers, the assertion won't hold.

[TiborB (tiborb95)]

As for mines<=3 question, you are right, if somebody creates tribe with more mines he will have to modify the assertion - should not be a big deal, I even inserted a comment there. But for now I want to be 100% sure that it does what it is supposed to do..

[GunChleoc (gunchleoc)]

Sounds good to me.

[GunChleoc (gunchleoc)]

I ave been thinking about the command line parameter, we should do that in a follow-up branch and just set kAITrainingMode to false for now. This will make it easier to review.

You can also use kAITrainingMode in the interactive base for switching the game speed code on and off, this way that code can stay in and be always valid.

[TiborB (tiborb95)]

OK, we will leave the command line switch for the next time. I will go over the code again and let you know when it will be ready....

[TiborB (tiborb95)]

OK, next try please

Just 2 points
- diff here on web page is truncated
- there is still one NOCOM and response to Gun in that cut off part of the diff...

[GunChleoc (gunchleoc)]

I did a few small cleanups, this is ready to go now. Thanks for taking on this huge job!

@bunnybot merge

review: Approve

[TiborB (tiborb95)]

I am bit afraid of reaction of players, the change of behavior is really significant

[GunChleoc (gunchleoc)]

The forum people are generally very friendly and supportive, so try not to worry about it too much. The new AI seems to perform better than the old one already. Of course, there will be bugs or things not working as expected, but that's just how big changes work in software development. Well just have to fix them then as they come up.

I expect that this will produce a lot less new bugs and crashes than I myself have caused since Build 19, and I'm glad that somebody is doing AI stuff, because I don't know the first thing about AI development ;)

[GunChleoc (gunchleoc)]

We still have codecheck warnings. Travis is having problems today, so best wait until tomorrow and fix them then.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2392. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/247861477.
Appveyor build 2220. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2220.

[bunnybot (widelandsofficial)]

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

Travis build 2392. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/247861477.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2403. State: failed. Details: https://travis-ci.org/widelands/widelands/builds/248478925.
Appveyor build 2231. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2231.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 2406. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/248928377.
Appveyor build 2234. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_ai_post_b19_2-2234.

[TiborB (tiborb95)]

CI seems to be OK now. Can it be merged?

[GunChleoc (gunchleoc)]

Yes, let's merge this :)

@bunnybot merge

BTW: I have all my editors set to automatically kill trailing whitespaces. This helps keeping the diffs small and avoids that particular codecheck fail.

[TiborB (tiborb95)]

Oh, I did not know such feature exists. My editor (geany) has it so I will enable it...

=== modified file 'data/tribes/atlanteans.lua'
--- data/tribes/atlanteans.lua	2017-04-30 10:30:02 +0000
+++ data/tribes/atlanteans.lua	2017-07-03 17:39:38 +0000
@@ -352,4 +352,9 @@
    headquarters = "atlanteans_headquarters",
    port = "atlanteans_port",
    barracks = "atlanteans_barracks",
+   bakery = "atlanteans_bakery",
+   ironore = "iron_ore",
+   rawlog = "log",
+   refinedlog = "planks",
+   granite = "granite",
 }

=== modified file 'data/tribes/barbarians.lua'
--- data/tribes/barbarians.lua	2017-04-30 10:30:02 +0000
+++ data/tribes/barbarians.lua	2017-07-03 17:39:38 +0000
@@ -285,4 +285,9 @@
    headquarters = "barbarians_headquarters",
    port = "barbarians_port",
    barracks = "barbarians_barracks",
+   bakery = "barbarians_bakery",
+   ironore = "iron_ore",
+   rawlog = "log",
+   refinedlog = "blackwood",
+   granite = "granite",
 }

=== modified file 'data/tribes/buildings/productionsites/atlanteans/bakery/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/bakery/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/productionsites/atlanteans/bakery/init.lua	2017-07-03 17:39:38 +0000
@@ -32,7 +32,7 @@
    },
 
    aihints = {
-      forced_after = 1200,
+      basic_amount = 1,
       prohibited_till = 900
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/barracks/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/barracks/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/productionsites/atlanteans/barracks/init.lua	2017-07-03 17:39:38 +0000
@@ -34,7 +34,6 @@
    },
 
    aihints = {
-      forced_after = 1000,
       very_weak_ai_limit = 1,
       weak_ai_limit = 3
    },

=== modified file 'data/tribes/buildings/productionsites/atlanteans/blackroot_farm/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/blackroot_farm/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/atlanteans/blackroot_farm/init.lua	2017-07-03 17:39:38 +0000
@@ -29,7 +29,6 @@
 
    aihints = {
       prohibited_till = 600,
-      forced_after = 800,
       space_consumer = true
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/crystalmine/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/crystalmine/init.lua	2017-02-18 23:07:56 +0000
+++ data/tribes/buildings/productionsites/atlanteans/crystalmine/init.lua	2017-07-03 17:39:38 +0000
@@ -36,6 +36,7 @@
 
    aihints = {
       mines = "stones",
+      basic_amount = 1,
       prohibited_till = 600
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/farm/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/farm/init.lua	2016-01-28 05:24:34 +0000
+++ data/tribes/buildings/productionsites/atlanteans/farm/init.lua	2017-07-03 17:39:38 +0000
@@ -30,9 +30,9 @@
 
    aihints = {
       space_consumer = true,
+      basic_amount = 1,
        -- Farm needs spidercloth to be built and spidercloth needs corn for production
        -- -> farm should be built ASAP!
-      forced_after = 400,
       prohibited_till = 200
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/fishers_house/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/fishers_house/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/atlanteans/fishers_house/init.lua	2017-07-03 17:39:38 +0000
@@ -26,6 +26,7 @@
 
    aihints = {
       needs_water = true,
+      basic_amount = 1,
       prohibited_till = 600
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/mill/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/mill/init.lua	2016-10-30 19:15:45 +0000
+++ data/tribes/buildings/productionsites/atlanteans/mill/init.lua	2017-07-03 17:39:38 +0000
@@ -33,6 +33,7 @@
    },
 
    aihints = {
+      basic_amount = 1,
       prohibited_till = 600
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/sawmill/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/sawmill/init.lua	2016-12-11 09:29:28 +0000
+++ data/tribes/buildings/productionsites/atlanteans/sawmill/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,7 @@
    },
 
    aihints = {
-      forced_after = 250,
+      basic_amount = 2,
       prohibited_till = 250,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/atlanteans/smokery/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/smokery/init.lua	2016-10-26 19:21:32 +0000
+++ data/tribes/buildings/productionsites/atlanteans/smokery/init.lua	2017-07-03 17:39:38 +0000
@@ -32,7 +32,7 @@
    },
 
    aihints = {
-      forced_after = 800,
+      basic_amount = 1,
       prohibited_till = 180,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/atlanteans/spiderfarm/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/spiderfarm/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/atlanteans/spiderfarm/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,7 @@
    },
 
    aihints = {
-      forced_after = 450,
+      basic_amount = 1,
       prohibited_till = 350
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/toolsmithy/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/toolsmithy/init.lua	2016-10-30 19:15:45 +0000
+++ data/tribes/buildings/productionsites/atlanteans/toolsmithy/init.lua	2017-07-03 17:39:38 +0000
@@ -32,7 +32,6 @@
    },
 
    aihints = {
-      forced_after = 500,
       prohibited_till = 450
    },
 

=== modified file 'data/tribes/buildings/productionsites/atlanteans/weaving_mill/init.lua'
--- data/tribes/buildings/productionsites/atlanteans/weaving_mill/init.lua	2016-12-14 09:09:34 +0000
+++ data/tribes/buildings/productionsites/atlanteans/weaving_mill/init.lua	2017-07-03 17:39:38 +0000
@@ -32,8 +32,8 @@
    },
 
    aihints = {
-      forced_after = 600,
-      prohibited_till = 450,
+      prohibited_till = 400,
+      basic_amount = 1,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2
    },

=== modified file 'data/tribes/buildings/productionsites/barbarians/barracks/init.lua'
--- data/tribes/buildings/productionsites/barbarians/barracks/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/productionsites/barbarians/barracks/init.lua	2017-07-03 17:39:38 +0000
@@ -33,7 +33,7 @@
    },
 
    aihints = {
-      forced_after = 1000,
+      basic_amount = 1,
       very_weak_ai_limit = 1,
       weak_ai_limit = 3
    },

=== modified file 'data/tribes/buildings/productionsites/barbarians/farm/init.lua'
--- data/tribes/buildings/productionsites/barbarians/farm/init.lua	2016-01-28 05:24:34 +0000
+++ data/tribes/buildings/productionsites/barbarians/farm/init.lua	2017-07-03 17:39:38 +0000
@@ -40,8 +40,7 @@
    },
 
    aihints = {
-      space_consumer = true,
-      forced_after = 600
+      space_consumer = true
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/gamekeepers_hut/init.lua'
--- data/tribes/buildings/productionsites/barbarians/gamekeepers_hut/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/barbarians/gamekeepers_hut/init.lua	2017-07-03 17:39:38 +0000
@@ -35,7 +35,8 @@
 
    aihints = {
       renews_map_resource = "meat",
-      prohibited_till = 900
+      prohibited_till = 900,
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/hunters_hut/init.lua'
--- data/tribes/buildings/productionsites/barbarians/hunters_hut/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/barbarians/hunters_hut/init.lua	2017-07-03 17:39:38 +0000
@@ -34,7 +34,8 @@
    },
 
    aihints = {
-      prohibited_till = 500
+      prohibited_till = 500,
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/lime_kiln/init.lua'
--- data/tribes/buildings/productionsites/barbarians/lime_kiln/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/barbarians/lime_kiln/init.lua	2017-07-03 17:39:38 +0000
@@ -31,9 +31,9 @@
    },
 
    aihints = {
-      forced_after = 600,
       very_weak_ai_limit = 1,
-      weak_ai_limit = 2
+      weak_ai_limit = 2,
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/lumberjacks_hut/init.lua'
--- data/tribes/buildings/productionsites/barbarians/lumberjacks_hut/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/barbarians/lumberjacks_hut/init.lua	2017-07-03 17:39:38 +0000
@@ -32,8 +32,7 @@
    },
 
    aihints = {
-      forced_after = 180,
-      prohibited_till = 180,
+      basic_amount = 1,
       logproducer = true
    },
 

=== modified file 'data/tribes/buildings/productionsites/barbarians/metal_workshop/init.lua'
--- data/tribes/buildings/productionsites/barbarians/metal_workshop/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/barbarians/metal_workshop/init.lua	2017-07-03 17:39:38 +0000
@@ -44,7 +44,7 @@
    },
 
    aihints = {
-      forced_after = 400,
+      basic_amount = 2,
       prohibited_till = 400
    },
 

=== modified file 'data/tribes/buildings/productionsites/barbarians/micro_brewery/init.lua'
--- data/tribes/buildings/productionsites/barbarians/micro_brewery/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/barbarians/micro_brewery/init.lua	2017-07-03 17:39:38 +0000
@@ -34,7 +34,6 @@
    },
 
    aihints = {
-      forced_after = 500
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/rangers_hut/init.lua'
--- data/tribes/buildings/productionsites/barbarians/rangers_hut/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/barbarians/rangers_hut/init.lua	2017-07-03 17:39:38 +0000
@@ -34,7 +34,7 @@
    aihints = {
       renews_map_resource = "log",
       space_consumer = true,
-      prohibited_till = 200
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/reed_yard/init.lua'
--- data/tribes/buildings/productionsites/barbarians/reed_yard/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/barbarians/reed_yard/init.lua	2017-07-03 17:39:38 +0000
@@ -27,7 +27,7 @@
 
    aihints = {
       space_consumer = true,
-      forced_after = 250,
+      basic_amount = 1,
       prohibited_till = 250
    },
 

=== modified file 'data/tribes/buildings/productionsites/barbarians/smelting_works/init.lua'
--- data/tribes/buildings/productionsites/barbarians/smelting_works/init.lua	2016-10-24 10:07:57 +0000
+++ data/tribes/buildings/productionsites/barbarians/smelting_works/init.lua	2017-07-03 17:39:38 +0000
@@ -35,6 +35,7 @@
 
    aihints = {
       prohibited_till = 400,
+      basic_amount = 1,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2
    },

=== modified file 'data/tribes/buildings/productionsites/barbarians/tavern/init.lua'
--- data/tribes/buildings/productionsites/barbarians/tavern/init.lua	2016-10-24 10:10:06 +0000
+++ data/tribes/buildings/productionsites/barbarians/tavern/init.lua	2017-07-03 17:39:38 +0000
@@ -38,7 +38,7 @@
    },
 
    aihints = {
-      forced_after = 900
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/well/init.lua'
--- data/tribes/buildings/productionsites/barbarians/well/init.lua	2016-10-05 05:29:11 +0000
+++ data/tribes/buildings/productionsites/barbarians/well/init.lua	2017-07-03 17:39:38 +0000
@@ -33,8 +33,7 @@
 
    aihints = {
       mines_water = true,
-      prohibited_till = 800,
-      forced_after = 800
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/barbarians/wood_hardener/init.lua'
--- data/tribes/buildings/productionsites/barbarians/wood_hardener/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/barbarians/wood_hardener/init.lua	2017-07-03 17:39:38 +0000
@@ -38,7 +38,7 @@
    },
 
    aihints = {
-      forced_after = 250,
+      basic_amount = 1,
       prohibited_till = 250,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/empire/armorsmithy/init.lua'
--- data/tribes/buildings/productionsites/empire/armorsmithy/init.lua	2016-10-30 19:06:01 +0000
+++ data/tribes/buildings/productionsites/empire/armorsmithy/init.lua	2017-07-03 17:39:38 +0000
@@ -43,7 +43,6 @@
 
    aihints = {
       prohibited_till = 700,
-      forced_after = 900
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/bakery/init.lua'
--- data/tribes/buildings/productionsites/empire/bakery/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/productionsites/empire/bakery/init.lua	2017-07-03 17:39:38 +0000
@@ -37,7 +37,7 @@
 
    aihints = {
       prohibited_till = 600,
-      forced_after = 700
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/barracks/init.lua'
--- data/tribes/buildings/productionsites/empire/barracks/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/productionsites/empire/barracks/init.lua	2017-07-03 17:39:38 +0000
@@ -35,7 +35,6 @@
    },
 
    aihints = {
-      forced_after = 1000,
       very_weak_ai_limit = 1,
       weak_ai_limit = 3
    },

=== modified file 'data/tribes/buildings/productionsites/empire/brewery/init.lua'
--- data/tribes/buildings/productionsites/empire/brewery/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/brewery/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,6 @@
    },
 
    aihints = {
-      forced_after = 900,
       prohibited_till = 600,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/empire/farm/init.lua'
--- data/tribes/buildings/productionsites/empire/farm/init.lua	2016-01-28 05:24:34 +0000
+++ data/tribes/buildings/productionsites/empire/farm/init.lua	2017-07-03 17:39:38 +0000
@@ -30,8 +30,8 @@
    },
 
    aihints = {
-      space_consumer = true,
-      forced_after = 900
+      basic_amount = 1,
+      space_consumer = true
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/inn/init.lua'
--- data/tribes/buildings/productionsites/empire/inn/init.lua	2016-10-26 19:21:32 +0000
+++ data/tribes/buildings/productionsites/empire/inn/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,6 @@
    },
 
    aihints = {
-      forced_after = 900,
       prohibited_till = 600
    },
 

=== modified file 'data/tribes/buildings/productionsites/empire/marblemine/init.lua'
--- data/tribes/buildings/productionsites/empire/marblemine/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/marblemine/init.lua	2017-07-03 17:39:38 +0000
@@ -38,7 +38,8 @@
    aihints = {
       mines = "stones",
       mines_percent = 50,
-      prohibited_till = 450
+      prohibited_till = 450,
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/piggery/init.lua'
--- data/tribes/buildings/productionsites/empire/piggery/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/piggery/init.lua	2017-07-03 17:39:38 +0000
@@ -33,7 +33,6 @@
    },
 
    aihints = {
-      forced_after = 1800
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/sawmill/init.lua'
--- data/tribes/buildings/productionsites/empire/sawmill/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/sawmill/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,7 @@
    },
 
    aihints = {
-      forced_after = 250,
+      basic_amount = 2,
       prohibited_till = 250,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/empire/sheepfarm/init.lua'
--- data/tribes/buildings/productionsites/empire/sheepfarm/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/sheepfarm/init.lua	2017-07-03 17:39:38 +0000
@@ -31,7 +31,7 @@
    },
 
    aihints = {
-      prohibited_till = 600
+      prohibited_till = 300
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/stonemasons_house/init.lua'
--- data/tribes/buildings/productionsites/empire/stonemasons_house/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/stonemasons_house/init.lua	2017-07-03 17:39:38 +0000
@@ -32,7 +32,7 @@
    },
 
    aihints = {
-      forced_after = 400,
+      basic_amount = 1,
       prohibited_till = 400,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/productionsites/empire/tavern/init.lua'
--- data/tribes/buildings/productionsites/empire/tavern/init.lua	2016-10-26 19:21:32 +0000
+++ data/tribes/buildings/productionsites/empire/tavern/init.lua	2017-07-03 17:39:38 +0000
@@ -33,7 +33,7 @@
    },
 
    aihints = {
-      forced_after = 900,
+      basic_amount = 1,
       prohibited_till = 300
    },
 

=== modified file 'data/tribes/buildings/productionsites/empire/toolsmithy/init.lua'
--- data/tribes/buildings/productionsites/empire/toolsmithy/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/toolsmithy/init.lua	2017-07-03 17:39:38 +0000
@@ -32,7 +32,6 @@
    },
 
    aihints = {
-      forced_after = 400,
       prohibited_till = 400
    },
 

=== modified file 'data/tribes/buildings/productionsites/empire/vineyard/init.lua'
--- data/tribes/buildings/productionsites/empire/vineyard/init.lua	2015-12-11 16:54:00 +0000
+++ data/tribes/buildings/productionsites/empire/vineyard/init.lua	2017-07-03 17:39:38 +0000
@@ -29,7 +29,7 @@
 
    aihints = {
       space_consumer = true,
-      forced_after = 300
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/weaponsmithy/init.lua'
--- data/tribes/buildings/productionsites/empire/weaponsmithy/init.lua	2016-10-30 19:06:01 +0000
+++ data/tribes/buildings/productionsites/empire/weaponsmithy/init.lua	2017-07-03 17:39:38 +0000
@@ -39,7 +39,8 @@
    },
 
    aihints = {
-      prohibited_till = 900
+      prohibited_till = 900,
+      forced_after = 3600
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/productionsites/empire/winery/init.lua'
--- data/tribes/buildings/productionsites/empire/winery/init.lua	2016-09-03 14:59:10 +0000
+++ data/tribes/buildings/productionsites/empire/winery/init.lua	2017-07-03 17:39:38 +0000
@@ -33,10 +33,10 @@
    },
 
    aihints = {
-      forced_after = 600,
       prohibited_till = 600,
       very_weak_ai_limit = 1,
-      weak_ai_limit = 2
+      weak_ai_limit = 2,
+      basic_amount = 1
    },
 
    working_positions = {

=== modified file 'data/tribes/buildings/trainingsites/atlanteans/dungeon/init.lua'
--- data/tribes/buildings/trainingsites/atlanteans/dungeon/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/atlanteans/dungeon/init.lua	2017-07-03 17:39:38 +0000
@@ -112,7 +112,6 @@
    },
 
    aihints = {
-      trainingsite_type = "advanced",
       prohibited_till = 1500,
       very_weak_ai_limit = 0,
       weak_ai_limit = 1

=== modified file 'data/tribes/buildings/trainingsites/atlanteans/labyrinth/init.lua'
--- data/tribes/buildings/trainingsites/atlanteans/labyrinth/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/atlanteans/labyrinth/init.lua	2017-07-03 17:39:38 +0000
@@ -36,7 +36,6 @@
    aihints = {
       prohibited_till = 900,
       forced_after = 1500,
-      trainingsite_type = "basic",
       very_weak_ai_limit = 1,
       weak_ai_limit = 2
    },

=== modified file 'data/tribes/buildings/trainingsites/barbarians/battlearena/init.lua'
--- data/tribes/buildings/trainingsites/barbarians/battlearena/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/barbarians/battlearena/init.lua	2017-07-03 17:39:38 +0000
@@ -48,7 +48,6 @@
    aihints = {
       prohibited_till = 900,
       forced_after = 1500,
-      trainingsite_type = "basic",
       very_weak_ai_limit = 1,
       weak_ai_limit = 3
    },

=== modified file 'data/tribes/buildings/trainingsites/barbarians/trainingcamp/init.lua'
--- data/tribes/buildings/trainingsites/barbarians/trainingcamp/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/barbarians/trainingcamp/init.lua	2017-07-03 17:39:38 +0000
@@ -41,7 +41,6 @@
 
    aihints = {
       prohibited_till = 1500,
-      trainingsite_type = "advanced",
       very_weak_ai_limit = 0,
       weak_ai_limit = 1
    },

=== modified file 'data/tribes/buildings/trainingsites/empire/arena/init.lua'
--- data/tribes/buildings/trainingsites/empire/arena/init.lua	2017-03-23 07:36:36 +0000
+++ data/tribes/buildings/trainingsites/empire/arena/init.lua	2017-07-03 17:39:38 +0000
@@ -37,7 +37,6 @@
    },
 
    aihints = {
-      trainingsite_type = "basic",
       trainingsites_max_percent = 20,
       prohibited_till = 900,
       very_weak_ai_limit = 1,

=== modified file 'data/tribes/buildings/trainingsites/empire/colosseum/init.lua'
--- data/tribes/buildings/trainingsites/empire/colosseum/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/empire/colosseum/init.lua	2017-07-03 17:39:38 +0000
@@ -34,7 +34,6 @@
 
    aihints = {
       prohibited_till = 1200,
-      trainingsite_type = "basic",
       forced_after = 1800,
       very_weak_ai_limit = 1,
       weak_ai_limit = 2

=== modified file 'data/tribes/buildings/trainingsites/empire/trainingcamp/init.lua'
--- data/tribes/buildings/trainingsites/empire/trainingcamp/init.lua	2017-02-10 09:40:17 +0000
+++ data/tribes/buildings/trainingsites/empire/trainingcamp/init.lua	2017-07-03 17:39:38 +0000
@@ -35,7 +35,6 @@
 
    aihints = {
       prohibited_till = 1500,
-      trainingsite_type = "advanced",
       very_weak_ai_limit = 0,
       weak_ai_limit = 1
    },

=== modified file 'data/tribes/empire.lua'
--- data/tribes/empire.lua	2017-04-30 10:30:02 +0000
+++ data/tribes/empire.lua	2017-07-03 17:39:38 +0000
@@ -326,4 +326,9 @@
    headquarters = "empire_headquarters",
    port = "empire_port",
    barracks = "empire_barracks",
+   bakery = "empire_bakery",
+   ironore = "iron_ore",
+   rawlog = "log",
+   refinedlog = "planks",
+   granite = "granite",
 }

=== modified file 'src/ai/ai_help_structs.cc'
--- src/ai/ai_help_structs.cc	2017-01-25 18:55:59 +0000
+++ src/ai/ai_help_structs.cc	2017-07-03 17:39:38 +0000
@@ -20,6 +20,7 @@
 #include "ai/ai_help_structs.h"
 
 #include "base/macros.h"
+#include "base/time_string.h"
 #include "logic/map.h"
 #include "logic/player.h"
 
@@ -27,6 +28,8 @@
 constexpr int kRoadNotFound = -1000;
 constexpr int kShortcutWithinSameEconomy = 1000;
 constexpr int kRoadToDifferentEconomy = 10000;
+constexpr int kUpperDefaultMutationLimit = 200;
+constexpr int kLowerDefaultMutationLimit = 150;
 
 namespace Widelands {
 
@@ -102,15 +105,12 @@
 // 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) {
+FindEnemyNodeWalkable::FindEnemyNodeWalkable(Player* p, Game& g) : player(p), game(g) {
 }
 
-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));
+bool FindEnemyNodeWalkable::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())));
 }
 
 // Sometimes we need to know how many nodes our allies owns
@@ -127,11 +127,23 @@
 // 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) {
+FindNodeUnownedMineable::FindNodeUnownedMineable(Player* p, Game& g, int32_t t)
+   : player(p), game(g), ore_type(t) {
 }
 
 bool FindNodeUnownedMineable::accept(const Map&, const FCoords& fc) const {
-	return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_owned_by() == 0);
+	if (ore_type == INVALID_INDEX) {
+		return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_owned_by() == neutral());
+	}
+	return (fc.field->nodecaps() & BUILDCAPS_MINE) && (fc.field->get_owned_by() == neutral()) &&
+	       fc.field->get_resources() == ore_type;
+}
+
+FindNodeUnownedBuildable::FindNodeUnownedBuildable(Player* p, Game& g) : player(p), game(g) {
+}
+
+bool FindNodeUnownedBuildable::accept(const Map&, const FCoords& fc) const {
+	return (fc.field->nodecaps() & BUILDCAPS_SIZEMASK) && (fc.field->get_owned_by() == neutral());
 }
 
 // Unowned but walkable fields nearby
@@ -139,7 +151,7 @@
 }
 
 bool FindNodeUnownedWalkable::accept(const Map&, const FCoords& fc) const {
-	return (fc.field->nodecaps() & MOVECAPS_WALK) && (fc.field->get_owned_by() == 0);
+	return (fc.field->nodecaps() & MOVECAPS_WALK) && (fc.field->get_owned_by() == neutral());
 }
 
 // Looking only for mines-capable fields nearby
@@ -181,14 +193,35 @@
    : flag(&f), cost(c), distance(d) {
 }
 
+EventTimeQueue::EventTimeQueue() {
+}
+
+void EventTimeQueue::push(const uint32_t production_time) {
+	queue.push(production_time);
+}
+
+uint32_t EventTimeQueue::count(const uint32_t current_time) {
+	strip_old(current_time);
+	return queue.size();
+}
+
+void EventTimeQueue::strip_old(const uint32_t current_time) {
+	while (!queue.empty() && queue.front() < current_time - duration_) {
+		queue.pop();
+	}
+}
+
 BuildableField::BuildableField(const Widelands::FCoords& fc)
    : coords(fc),
      field_info_expiration(20000),
      preferred(false),
      enemy_nearby(0),
+     enemy_accessible_(false),
+     enemy_wh_nearby(false),
      unowned_land_nearby(0),
      near_border(false),
      unowned_mines_spots_nearby(0),
+     unowned_iron_mines_nearby(false),
      trees_nearby(0),
      // explanation of starting values
      // this is done to save some work for AI (CPU utilization)
@@ -209,15 +242,22 @@
      area_military_capacity(0),
      military_loneliness(1000),
      military_in_constr_nearby(0),
-     area_military_presence(0),
+     own_military_presence(0),
+     enemy_military_presence(0),
+     ally_military_presence(0),
      military_stationed(0),
      unconnected_nearby(false),
      military_unstationed(0),
-     is_portspace(false),
+     own_non_military_nearby(0),
+     is_portspace(Widelands::ExtendedBool::kUnset),
      port_nearby(false),
      portspace_nearby(Widelands::ExtendedBool::kUnset),
      max_buildcap_nearby(0),
-     last_resources_check_time(0) {
+     last_resources_check_time(0),
+     military_score_(0),
+     inland(false),
+     local_soldier_capacity(0),
+     is_militarysite(false) {
 }
 
 int32_t BuildableField::own_military_sites_nearby_() {
@@ -240,6 +280,19 @@
 	return cnt_built + cnt_under_construction;
 }
 
+bool BuildingObserver::is(BuildingAttribute attribute) const {
+	return is_what.count(attribute) == 1;
+}
+
+void BuildingObserver::set_is(const BuildingAttribute attribute) {
+	is_what.insert(attribute);
+}
+
+void BuildingObserver::unset_is(const BuildingAttribute attribute) {
+	is_what.erase(attribute);
+	assert(!is(attribute));
+}
+
 Widelands::AiModeBuildings BuildingObserver::aimode_limit_status() {
 	if (total_count() > cnt_limit_by_aimode) {
 		return Widelands::AiModeBuildings::kLimitExceeded;
@@ -250,7 +303,7 @@
 	}
 }
 bool BuildingObserver::buildable(Widelands::Player& p) {
-	return is_buildable && p.is_building_type_allowed(id);
+	return is(BuildingAttribute::kBuildable) && p.is_building_type_allowed(id);
 }
 
 // Computer player does not get notification messages about enemy militarysites
@@ -264,16 +317,769 @@
      attack_soldiers_strength(0),
      defenders_strength(0),
      stationed_soldiers(0),
-     last_time_attackable(std::numeric_limits<uint32_t>::max()),
+     last_time_seen(0),
      last_tested(0),
      score(0),
      mines_nearby(Widelands::ExtendedBool::kUnset),
-     no_attack_counter(0) {
+     last_time_attacked(0),
+     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) {
+MineTypesObserver::MineTypesObserver()
+   : in_construction(0), finished(0), is_critical(false), unoccupied(0) {
+}
+
+ExpansionType::ExpansionType() {
+	type = ExpansionMode::kResources;
+}
+
+void ExpansionType::set_expantion_type(const ExpansionMode etype) {
+	type = etype;
+}
+
+ManagementData::ManagementData() {
+	score = 1;
+	primary_parent = 255;
+	next_neuron_id = 0;
+	performance_change = 0;
+}
+
+// Initialization of neuron. Neuron is defined by curve (type) and weight [-kWeightRange, kWeightRange]
+// third argument is just id
+Neuron::Neuron(int8_t w, uint8_t f, uint16_t i) : weight(w), type(f), id(i) {
+	assert(type < neuron_curves.size());
+	assert(weight >= -kNeuronWeightLimit && weight <= kNeuronWeightLimit);
+	recalculate();
+}
+
+// Weight, or rather value in range [-kWeightRange, kWeightRange]. Automatically adjusts the weight to the range in case of
+// overflow.
+void Neuron::set_weight(int8_t w) {
+	weight = Neuron::clip_weight_to_range(w);
+}
+
+// Neuron stores calculated values in an array of size 21.
+// This has to be recalculated when the weight or curve type change
+void Neuron::recalculate() {
+	assert(neuron_curves.size() > type);
+	for (uint8_t i = 0; i <= kNeuronMaxPosition; i += 1) {
+		results[i] = weight * neuron_curves[type][i] / kNeuronWeightLimit;
+	}
+}
+
+// The Following two functions return Neuron values on position
+int8_t Neuron::get_result(const size_t pos) {
+	assert(pos <= kNeuronMaxPosition);
+	return results[pos];
+}
+
+// get value corresponding to input in range 0-20, if you are out of range
+// the input will be cropped
+int8_t Neuron::get_result_safe(int32_t pos, const bool absolute) {
+	// pos has to be normalized into range 0 - 20(kNeuronMaxPosition)
+	pos = std::max(0, std::min(static_cast<int>(kNeuronMaxPosition), pos));
+
+	assert(pos <= static_cast<int32_t>(kNeuronMaxPosition));
+	assert(pos >= 0);
+	assert(results[pos] >= -kNeuronWeightLimit && results[pos] <= kNeuronWeightLimit);
+
+	if (absolute) {
+		return std::abs(results[pos]);
+	}
+	return results[pos];
+}
+
+// Setting the type of curve
+void Neuron::set_type(uint8_t new_type) {
+	assert(new_type < neuron_curves.size());
+	type = new_type;
+}
+
+// FNeuron is basically a single uint32_t integer, and the AI can query every bit of that uint32_t
+FNeuron::FNeuron(uint32_t c, uint16_t i) {
+	core = c;
+	id = i;
+}
+
+// Returning a result depending on combinations of 5 bools
+// Bools are completely anonymous, but can present any yes/no inputs, e.g. imagine the AI that is
+// to figure out if it should attack from a militarysite. The inputs can be:
+// bool1 - are we stronger than the enemy?
+// bool2 - do we have a basic economy established?
+// bool3 - do we have local predominance?
+// bool4 - has our strength grown during the last 60 minutes?
+// bool5 - are there mines in the vicinity?
+// These five bools can create 32 combinations = yes/no answers.
+// In fact this can be perceived as a complicated if..then structure, but one that can
+// adjust automatically as a part of training.
+// Or rather it is a 5-dimensional table with 2 columns in every dimension :)
+// In fact this concept if very demanding for training so we don't use it much
+bool FNeuron::get_result(
+   const bool bool1, const bool bool2, const bool bool3, const bool bool4, const bool bool5) {
+	return core.test(bool1 * 16 + bool2 * 8 + bool3 * 4 + bool4 * 2 + bool5);
+}
+
+// Returning bool on a position
+bool FNeuron::get_position(const uint8_t pos) {
+	assert(pos < kFNeuronBitSize);
+	return core.test(pos);
+}
+
+// Returning numerical value of FNeuron. Used for saving and priting into log
+uint32_t FNeuron::get_int() {
+	return core.to_ulong();
+}
+
+// This is basically a mutation of FNeuron
+void FNeuron::flip_bit(const uint8_t pos) {
+	assert(pos < kFNeuronBitSize);
+	core.flip(pos);
+}
+
+// Shifting the value in range -kWeightRange to kWeightRange, if zero_align is true, it is now allowed to shift
+// from negative to positive and vice versa, 0 must be used.
+int8_t ManagementData::shift_weight_value(const int8_t old_value, const bool aggressive) {
+
+	int16_t halfVArRange = 50;
+	if (aggressive) {
+		halfVArRange = 200;
+	}
+
+	const int16_t upper_limit = std::min<int16_t>(old_value + halfVArRange, kNeuronWeightLimit);
+	const int16_t bottom_limit = std::max<int16_t>(old_value - halfVArRange, -kNeuronWeightLimit);
+	int16_t new_value = bottom_limit + std::rand() % (upper_limit - bottom_limit + 1);
+
+	if (!aggressive && ((old_value > 0 && new_value < 0) || (old_value < 0 && new_value > 0))) {
+		new_value = 0;
+	}
+
+	new_value = Neuron::clip_weight_to_range(new_value);
+	return static_cast<int8_t>(new_value);
+}
+
+// Used to score performance of AI
+// Should be disabled for "production"
+void ManagementData::review(const uint32_t gametime,
+                            PlayerNumber pn,
+                            const uint32_t land,
+                            const uint32_t max_e_land,
+                            const uint32_t old_land,
+                            const uint16_t attackers,
+                            const int16_t trained_soldiers,
+                            const int16_t latest_attackers,
+                            const uint16_t conq_ws) {
+
+	const int16_t main_bonus =
+	   ((static_cast<int32_t>(land - old_land) > 0 && land > max_e_land * 5 / 6 && attackers > 0 &&
+	     trained_soldiers > 0 && latest_attackers > 0) ?
+	       kBonus :
+	       0);
+
+	const int16_t land_delta_bonus = static_cast<int16_t>(land - old_land) * kLandDeltaMultiplier;
+
+	score = land / kCurrentLandDivider + land_delta_bonus + main_bonus +
+	        attackers * kAttackersMultiplier + ((attackers > 0) ? kAttackBonus : -kAttackBonus) +
+	        trained_soldiers * kTrainedSoldiersScore + +kConqueredWhBonus + conq_ws;
+
+	log(" %2d %s: reviewing AI mngm. data, sc: %5d Pr.p: %d (l: %4d / %4d / %4d, "
+	       "at:%4d(%3d), ts:%4d(%2d), ConqWH:%2d)\n",
+	       pn, gamestring_with_leading_zeros(gametime), score, primary_parent,
+	       land / kCurrentLandDivider, main_bonus, land_delta_bonus,
+	       attackers * kAttackersMultiplier, latest_attackers,
+	       trained_soldiers * kTrainedSoldiersScore, trained_soldiers, conq_ws);
+
+	if (score < -10000 || score > 30000) {
+		log(
+		   "%2d %s: reviewing AI mngm. data, score too extreme: %4d\n",
+		   pn, gamestring_with_leading_zeros(gametime), score);
+	}
+	assert(score > -10000 && score < 100000);
+}
+
+// Here we generate new AI DNA (no mutation yet) and push them into persistent data
+// this can cause inconsistency between local and persistent
+void ManagementData::new_dna_for_persistent(const uint8_t pn, const Widelands::AiType type) {
+
+	ai_type = type;
+
+	log ("%2d: DNA initialization... \n", pn);
+
+   // AutoSCore_AIDNA_1
+    const std::vector<int16_t> AI_initial_military_numbers_A =
+      {  18,  -42,   21,   59,   -7,  -78,  -22,   81,   48,    0,  //  AutoContent_01_AIDNA_1
+        -82,   45,  -96,   16,   70,  -30,   33,   79,  -78,  -42,  //  AutoContent_02_AIDNA_1
+         79,  -16,   34,   46,  -22,    0,   45,  -29,   53,   51,  //  AutoContent_03_AIDNA_1
+         24,   47,  -27,   80,  -86,   46,  -63,  -47,   20,  -63,  //  AutoContent_04_AIDNA_1
+         78,   51,  -11,  -77,   20,   38,    6,   37,  -64,  -41,  //  AutoContent_05_AIDNA_1
+         -3,  -55,   62,    0,   64,  -92,    4,  -89,   71,  -18,  //  AutoContent_06_AIDNA_1
+        -87,   56,   17,  -34,  -69,   24,  -57,   84,   40,  -51,  //  AutoContent_07_AIDNA_1
+          0,   44,    0,   -2,  -11,   -4,  -96,  -35,  -29,  -12,  //  AutoContent_08_AIDNA_1
+         71,  -98,  -25,   50,   97,   74,    0,   65,  -60,   23,  //  AutoContent_09_AIDNA_1
+         38,   53,   74,    0,  -43,   27,   32,   37,  -24,  -65,  //  AutoContent_10_AIDNA_1
+         16,  -42,   19,  -94,  -28,   83,  -55,  -63,   16,  -41,  //  AutoContent_11_AIDNA_1
+         28,   -3,    0,  -87,   32,    5,    4,    6,  -20,   62,  //  AutoContent_12_AIDNA_1
+         85,    0,   58,   48,  -80,  -20,  -49,   71,   60,    8,  //  AutoContent_13_AIDNA_1
+        -52,   59,  100,  -74,    0,  -36,   -9,   80,   41,  -67,  //  AutoContent_14_AIDNA_1
+          0,   15,  -96,  -51,  -21,   11,  -27,  -30,   76,  -47   //  AutoContent_15_AIDNA_1
+       }
+		;
+
+	assert(kMagicNumbersSize == AI_initial_military_numbers_A.size());
+
+	const std::vector<int8_t> input_weights_A =
+		//  0     1     2     3     4     5     6     7     8     9
+      {  48,  -85,  -26,   47,  -93,  -22,  -91,   84,   24,  -12,  //  AutoContent_16_AIDNA_1
+         98,  -59,  -89,   76,   81,   95,  -91,  -90,  -56,  -15,  //  AutoContent_17_AIDNA_1
+        -65,  -18,    6,  -65,   41,   38,   47,  -31,   79,   23,  //  AutoContent_18_AIDNA_1
+         16,   25,  -59,    0,  -38,  -85,  -60,  -42,    0,  -70,  //  AutoContent_19_AIDNA_1
+        -78,  -86,  -87,  -55,   92,  -63,  -21,  -76,    4,   87,  //  AutoContent_20_AIDNA_1
+         58,  -40,   71,  -90,  -72,    0,  -47,  -94,  -15,   66,  //  AutoContent_21_AIDNA_1
+        -32,    9,   67,  -47,  -44,  -76,  -53,   57,  -31,  -47,  //  AutoContent_22_AIDNA_1
+          0,  -28,  -16,   48,   41,  -45,   36,   -8,   51,  -49   //  AutoContent_23_AIDNA_1
+	}
+			;
+	const std::vector<int8_t> input_func_A =
+      {   1,    0,    1,    2,    2,    1,    0,    0,    0,    0,  //  AutoContent_24_AIDNA_1
+          2,    1,    2,    2,    2,    1,    2,    2,    2,    1,  //  AutoContent_25_AIDNA_1
+          2,    2,    0,    2,    2,    1,    0,    1,    0,    2,  //  AutoContent_26_AIDNA_1
+          1,    2,    2,    1,    2,    1,    0,    1,    2,    1,  //  AutoContent_27_AIDNA_1
+          2,    1,    2,    0,    0,    1,    2,    0,    0,    0,  //  AutoContent_28_AIDNA_1
+          1,    0,    0,    1,    0,    1,    0,    0,    1,    1,  //  AutoContent_29_AIDNA_1
+          2,    0,    1,    2,    0,    2,    2,    2,    1,    0,  //  AutoContent_30_AIDNA_1
+          2,    1,    2,    2,    1,    1,    0,    2,    2,    1   //  AutoContent_31_AIDNA_1
+	}
+		;
+	assert(kNeuronPoolSize == input_func_A.size());
+	assert(kNeuronPoolSize == input_weights_A.size());
+
+	const std::vector<uint32_t> f_neurons_A =
+      { 471130763,  1322756799,  1148682382,  2713953719,  194460207,  18113635,  2947490886,  3275944172,  3438582086,  856208494,  //  AutoContent_32_AIDNA_1
+        1326156684,  986431571,  3465514749,  1962749574,  1523585333,  1376482111,  1223335901,  2962231598,  657710612,  578259960,  //  AutoContent_33_AIDNA_1
+        1271222963,  2915927856,  3396846486,  1743568169,  2679432920,  410834609,  134904175,  2968201710,  2132567223,  2248461478,  //  AutoContent_34_AIDNA_1
+        161963959,  3295327519,  670058472,  2013696856,  3608400883,  496651103,  733137541,  2952748738,  3307293853,  3886490843,  //  AutoContent_35_AIDNA_1
+        3233788172,  715230539,  2583635732,  4271028953,  1217674278,  4043323645,  1857109651,  2181897047,  2825979187,  3081298269,  //  AutoContent_36_AIDNA_1
+        1277901018,  1255642150,  2384261818,  2866704864,  755617465,  835768208,  1394358417,  4012239945,  2601238115,  3933467106  //  AutoContent_37_AIDNA_1
+	 };
+	assert(kFNeuronPoolSize == f_neurons_A.size());
+
+
+    // AutoSCore_AIDNA_2
+	const std::vector<int16_t> AI_initial_military_numbers_B =
+      {  18,  -42,   21,   59,   -7,  -78,  -22,   81,   48,    0,  //  AutoContent_01_AIDNA_2
+        -55,   45,  -96,   16,   70,  -30,   33,   79,  -78,  -42,  //  AutoContent_02_AIDNA_2
+         79,  -16,   34,   46,  -22,    0,   45,  -33,   53,   51,  //  AutoContent_03_AIDNA_2
+         49,   47,  -27,   80,  -86,   46,  -63,  -47,   20,  -63,  //  AutoContent_04_AIDNA_2
+         78,   51,   23,  -77,   20,   38,    6,   37,  -64,  -41,  //  AutoContent_05_AIDNA_2
+         -3,  -55,   62,    0,   64,  -92,    4,  -89,   71,  -18,  //  AutoContent_06_AIDNA_2
+        -87,   56,   17,  -34,  -69,   24,  -57,   84,   40,  -51,  //  AutoContent_07_AIDNA_2
+          0,   44,    0,   -2,  -11,   -4,  -96,  -35,  -29,  -12,  //  AutoContent_08_AIDNA_2
+         71,  -98,  -25,   50,   97,   74,    0,   65,  -60,   23,  //  AutoContent_09_AIDNA_2
+         38,   53,   74,    0,  -15,   27,   32,   37,  -24,  -65,  //  AutoContent_10_AIDNA_2
+         16,  -42,   19,  -94,  -28,   83,  -55,  -63,   16,  -41,  //  AutoContent_11_AIDNA_2
+         28,   -3,    0,  -87,   32,    5,    4,    6,  -20,   62,  //  AutoContent_12_AIDNA_2
+         85,    0,   58,   48,  -80,  -20,  -49,   71,   60,    8,  //  AutoContent_13_AIDNA_2
+        -52,   59,  100,  -74,    0,  -36,   -9,   80,   41,  -67,  //  AutoContent_14_AIDNA_2
+          0,   15,  -96,  -51,  -21,   11,  -27,  -30,   76,  -47   //  AutoContent_15_AIDNA_2
+		}
+		;
+	assert(kMagicNumbersSize == AI_initial_military_numbers_B.size());
+
+	const std::vector<int8_t> input_weights_B =
+      {  48,  -85,  -26,   47,  -93,  -22,  -91,   84,   50,  -12,  //  AutoContent_16_AIDNA_2
+         98,  -59,  -89,   76,   81,   95,  -91,  -90,  -56,  -15,  //  AutoContent_17_AIDNA_2
+        -65,  -18,    6,  -65,   41,   38,   47,  -31,   79,   23,  //  AutoContent_18_AIDNA_2
+         16,   25,  -59,    0,  -38,  -85,  -60,  -42,    0,  -70,  //  AutoContent_19_AIDNA_2
+        -78,  -86,  -87,  -55,   92,  -63,  -21,  -76,    4,   87,  //  AutoContent_20_AIDNA_2
+         58,  -40,   71,  -90,  -72,    0,  -47,  -94,  -15,   66,  //  AutoContent_21_AIDNA_2
+        -32,    9,   67,  -47,  -44,  -76,  -53,   57,  -31,  -47,  //  AutoContent_22_AIDNA_2
+          0,  -28,  -16,   48,   41,  -45,   36,   -8,   51,  -49   //  AutoContent_23_AIDNA_2
+}
+	      ;
+
+	const std::vector<int8_t> input_func_B =
+      {   1,    0,    1,    2,    2,    1,    0,    0,    0,    0,  //  AutoContent_24_AIDNA_2
+          2,    1,    2,    2,    2,    1,    2,    2,    2,    1,  //  AutoContent_25_AIDNA_2
+          2,    2,    0,    2,    2,    1,    0,    1,    0,    2,  //  AutoContent_26_AIDNA_2
+          1,    2,    2,    1,    2,    1,    0,    1,    2,    1,  //  AutoContent_27_AIDNA_2
+          2,    1,    2,    0,    0,    1,    2,    0,    0,    0,  //  AutoContent_28_AIDNA_2
+          1,    0,    0,    1,    0,    1,    0,    0,    1,    1,  //  AutoContent_29_AIDNA_2
+          2,    0,    1,    2,    0,    2,    2,    2,    1,    0,  //  AutoContent_30_AIDNA_2
+          2,    1,    2,    2,    1,    1,    0,    2,    2,    1   //  AutoContent_31_AIDNA_2
+}
+		;
+		assert(kNeuronPoolSize == input_func_B.size());
+		assert(kNeuronPoolSize == input_weights_B.size());
+
+
+	const std::vector<uint32_t> f_neurons_B =
+      { 471130763,  1322756799,  1148682382,  2713953719,  194460207,  18113635,  2947490886,  3275944172,  3438582022,  855676014,  //  AutoContent_32_AIDNA_2
+        1326156684,  986431571,  3465514749,  1962749574,  1523650869,  1376482111,  2347409353,  2962227502,  657710612,  578259960,  //  AutoContent_33_AIDNA_2
+        1271222963,  2915927856,  3396846486,  1743568169,  2679432920,  410834609,  134904175,  2968201710,  2132567223,  2248461478,  //  AutoContent_34_AIDNA_2
+        161963959,  3295327519,  670058472,  2013696856,  4145271795,  496651103,  733211269,  2952748738,  1159810205,  3886490843,  //  AutoContent_35_AIDNA_2
+        3225153820,  732007755,  2583635732,  4271028825,  1217674278,  4043323645,  1857109651,  2249005911,  2825979187,  3081298269,  //  AutoContent_36_AIDNA_2
+        1277901018,  1255642150,  2384261818,  2866704864,  755617465,  835768208,  1394096273,  4012239945,  2609626723,  3932418530  //  AutoContent_37_AIDNA_2
+	 };
+	assert(kFNeuronPoolSize == f_neurons_B.size());
+
+
+    // AutoSCore_AIDNA_3
+	const std::vector<int16_t> AI_initial_military_numbers_C =
+      {  18,  -42,   63,   82,   -7,  -78,  -22,   81,   48,    0,  //  AutoContent_01_AIDNA_3
+        -55,   55,  -96,   16,   70,  -30,   33,   79,  -78,  -42,  //  AutoContent_02_AIDNA_3
+         79,  -16,   34,   46,    0,    0,    0,  -29,   53,   51,  //  AutoContent_03_AIDNA_3
+         24,   47,  -27,   42,  -86,   46,  -63,  -47,   20,  -63,  //  AutoContent_04_AIDNA_3
+         78,   31,   98,  -73,   20,   38,   44,   37,  -64,  -41,  //  AutoContent_05_AIDNA_3
+         -3,  -55,   67,    0,   64,  -92,    4,  -89,   71,  -60,  //  AutoContent_06_AIDNA_3
+        -87,   56,   17,  -34,  -69,   24,  -57,   50,   40,  -51,  //  AutoContent_07_AIDNA_3
+        -34,   44,    0,   -2,  -11,   -4,  -96,  -35,  -29,  -12,  //  AutoContent_08_AIDNA_3
+         68,  -98,  -25,   50,   97,   74,    0,   65,  -60,   23,  //  AutoContent_09_AIDNA_3
+         38,   53,   74,    0,  -15,   27,   32,   61,  -24,  -65,  //  AutoContent_10_AIDNA_3
+         16,  -42,   19,  -94,  -65,   83,  -55,  -63,   16,  -41,  //  AutoContent_11_AIDNA_3
+         74,   -3,    0,  -87,   32,    5,    4,    6,  -70,   62,  //  AutoContent_12_AIDNA_3
+         85,    0,   58,   48,  -80,  -20,  -49,   71,   60,    8,  //  AutoContent_13_AIDNA_3
+        -52,   30,   69,  -74,    0,  -36,  -57,   80,   64,  -67,  //  AutoContent_14_AIDNA_3
+          0,   15,  -96,  -51,  -21,    0,  -33,  -30,   76,  -47   //  AutoContent_15_AIDNA_3
+       }
+
+		;
+
+		assert(kMagicNumbersSize == AI_initial_military_numbers_C.size());
+
+	const std::vector<int8_t> input_weights_C =
+      {  48,  -85,  -26,   47,  -65,  -19,  -91,   84,   92,  -12,  //  AutoContent_16_AIDNA_3
+         78,  -59,  -89,   76,   81,   95,  -91,  -90,  -56,  -15,  //  AutoContent_17_AIDNA_3
+        -65,  -18,    6,  -65,   17,   38,   47,  -45,   79,   23,  //  AutoContent_18_AIDNA_3
+         16,   25,  -59,   36,  -38,  -85,  -60,  -42,    0,  -70,  //  AutoContent_19_AIDNA_3
+        -78,  -86,  -87,  -55,   92,  -63,  -21,  -76,    4,   87,  //  AutoContent_20_AIDNA_3
+         58,  -40,   71,  -90,  -72,    0,  -47,  -94,  -15,   95,  //  AutoContent_21_AIDNA_3
+        -32,    9,   67,  -47,  -44,  -76,  -53,   57,  -31,  -47,  //  AutoContent_22_AIDNA_3
+          0,  -28,  -16,   48,   41,  -45,   36,   -8,   63,  -49   //  AutoContent_23_AIDNA_3
+       }
+			;
+	const std::vector<int8_t> input_func_C =
+      {   1,    0,    1,    2,    2,    1,    0,    0,    0,    0,  //  AutoContent_24_AIDNA_3
+          2,    1,    2,    2,    1,    1,    2,    2,    2,    1,  //  AutoContent_25_AIDNA_3
+          2,    2,    0,    2,    2,    1,    0,    1,    0,    2,  //  AutoContent_26_AIDNA_3
+          1,    2,    2,    1,    2,    1,    0,    1,    2,    1,  //  AutoContent_27_AIDNA_3
+          2,    1,    2,    0,    0,    1,    2,    0,    0,    0,  //  AutoContent_28_AIDNA_3
+          1,    0,    0,    1,    0,    2,    0,    0,    1,    1,  //  AutoContent_29_AIDNA_3
+          2,    0,    1,    2,    0,    2,    2,    2,    1,    0,  //  AutoContent_30_AIDNA_3
+          2,    1,    2,    2,    1,    1,    0,    2,    2,    1   //  AutoContent_31_AIDNA_3
+       }
+			;
+	assert(kNeuronPoolSize == input_func_C.size());
+	assert(kNeuronPoolSize == input_weights_C.size());
+
+	const std::vector<uint32_t> f_neurons_C =
+      {  202828425,  1322625717,  1148682382,  2244191679,  194456367,  26493027,  2947491014,  3410163948,  3438582086,  856208494,  //  AutoContent_32_AIDNA_3
+        1259048860,  986431571,  3457662708,  1954360966,  1523650869,  1376351039,  1223335901,  2997887274,  657657361,  645368312,  //  AutoContent_33_AIDNA_3
+        1271218867,  2915927856,  3933717470,  2011479337,  2645864080,  408737457,  2282387823,  2968205806,  1597793527,  2248461494,  //  AutoContent_34_AIDNA_3
+        161963959,  1147843615,  670058474,  2013712728,  4145271795,  496651102,  724812677,  2952748738,  1629834973,  3819381979,  //  AutoContent_35_AIDNA_3
+        3233788172,  732007755,  2583635734,  4271028825,  1217670182,  4043323645,  1857109659,  2249005911,  2834367795,  3072909661,  //  AutoContent_36_AIDNA_3
+        1278949528,  1792513063,  2384261690,  2732487136,  755615385,  835767184,  1393834641,  4012239945,  2601238115,  2859725290  //  AutoContent_37_AIDNA_3
+	 };
+	assert(kFNeuronPoolSize == f_neurons_C.size());
+
+
+    // AutoSCore_AIDNA_4
+	const std::vector<int16_t> AI_initial_military_numbers_D =
+      {  18,  -42,   21,   59,   -7,  -78,  -22,   81,   48,    0,  //  AutoContent_01_AIDNA_4
+        -55,   45,  -96,   16,   70,  -30,   33,   79,  -78,  -42,  //  AutoContent_02_AIDNA_4
+         79,  -16,   34,   46,  -22,    0,   45,  -29,   53,   51,  //  AutoContent_03_AIDNA_4
+         24,   47,  -27,   80,  -86,   46,  -63,  -47,   20,  -63,  //  AutoContent_04_AIDNA_4
+         78,   51,  -25,  -77,   20,   38,    6,   37,  -64,  -41,  //  AutoContent_05_AIDNA_4
+         -3,  -55,   62,    0,   64,  -92,    4,  -89,   71,  -18,  //  AutoContent_06_AIDNA_4
+        -87,   56,   17,  -34,  -69,   24,  -57,   84,   40,  -51,  //  AutoContent_07_AIDNA_4
+          0,   44,    0,   -2,  -11,   -4,  -96,  -35,  -29,  -12,  //  AutoContent_08_AIDNA_4
+         71,  -98,  -25,   50,   97,   74,    0,   65,  -60,   23,  //  AutoContent_09_AIDNA_4
+         38,   53,   74,    0,  -15,   27,   32,   37,  -24,  -65,  //  AutoContent_10_AIDNA_4
+         16,  -61,   19,  -94,  -28,   83,  -55,  -63,   16,  -41,  //  AutoContent_11_AIDNA_4
+         28,   -3,    0,  -87,   32,    5,    4,    6,  -20,   62,  //  AutoContent_12_AIDNA_4
+         85,    0,   58,   48,  -80,  -20,  -49,   71,   60,    8,  //  AutoContent_13_AIDNA_4
+        -52,   59,  100,  -74,    0,  -36,   -9,   80,   41,  -67,  //  AutoContent_14_AIDNA_4
+          0,   15,  -96,  -51,  -21,   11,  -27,  -30,   76,  -47   //  AutoContent_15_AIDNA_4
+	}
+		;
+	assert(kMagicNumbersSize == AI_initial_military_numbers_D.size());
+
+	const std::vector<int8_t> input_weights_D =
+      {  48,  -85,  -26,   47,  -93,  -22,  -91,   84,   50,  -12,  //  AutoContent_16_AIDNA_4
+         98,  -59,  -89,   76,   81,   95,  -91,  -90,  -56,  -15,  //  AutoContent_17_AIDNA_4
+        -65,  -18,    6,  -65,   41,   38,   47,  -31,   79,   23,  //  AutoContent_18_AIDNA_4
+         16,   25,  -59,    0,  -38,  -85,  -60,  -42,    0,  -70,  //  AutoContent_19_AIDNA_4
+        -78,  -86,  -87,  -55,   92,  -63,  -21,  -76,    4,   87,  //  AutoContent_20_AIDNA_4
+         58,  -40,   71,  -90,  -72,    0,  -47,  -94,  -15,   66,  //  AutoContent_21_AIDNA_4
+        -32,    9,   67,  -47,  -44,  -76,  -53,   57,  -31,  -47,  //  AutoContent_22_AIDNA_4
+          0,  -28,  -16,   48,   41,  -45,   36,   -8,   63,  -49   //  AutoContent_23_AIDNA_4
+	}
+	      ;
+
+	const std::vector<int8_t> input_func_D =
+      {   1,    0,    1,    2,    2,    1,    0,    0,    0,    0,  //  AutoContent_24_AIDNA_4
+          2,    1,    2,    2,    2,    1,    2,    2,    2,    1,  //  AutoContent_25_AIDNA_4
+          2,    2,    0,    2,    2,    1,    0,    1,    0,    2,  //  AutoContent_26_AIDNA_4
+          1,    2,    2,    1,    2,    1,    0,    1,    2,    1,  //  AutoContent_27_AIDNA_4
+          2,    1,    2,    0,    0,    1,    2,    0,    0,    0,  //  AutoContent_28_AIDNA_4
+          1,    0,    0,    1,    0,    1,    0,    0,    1,    1,  //  AutoContent_29_AIDNA_4
+          2,    0,    1,    2,    0,    2,    2,    2,    1,    0,  //  AutoContent_30_AIDNA_4
+          2,    1,    2,    2,    1,    1,    0,    2,    2,    1   //  AutoContent_31_AIDNA_4
+	}
+		;
+	assert(kNeuronPoolSize == input_func_D.size());
+	assert(kNeuronPoolSize == input_weights_D.size());
+
+	const std::vector<uint32_t> f_neurons_D =
+      { 471130763,  1322756799,  1148682382,  2713953719,  194460175,  18113635,  2947490886,  3275944172,  3438582214,  856208494,  //  AutoContent_32_AIDNA_4
+        1326156684,  449560659,  3465512701,  1962749574,  1523650869,  1376482111,  2347409353,  2962227502,  657710614,  578259960,  //  AutoContent_33_AIDNA_4
+        1271222963,  2915927856,  3396846486,  1743568169,  2679432920,  410834611,  134904175,  2968201710,  2132567223,  2248461478,  //  AutoContent_34_AIDNA_4
+        161963959,  3295327519,  670058472,  2013696856,  3608400883,  496651103,  733137541,  2952748738,  1159810205,  3886490843,  //  AutoContent_35_AIDNA_4
+        3225153820,  732007755,  2583635732,  4271028825,  1217674278,  4043323645,  1857109651,  2248481623,  3899721011,  3081298269,  //  AutoContent_36_AIDNA_4
+        1277901016,  1255642150,  2384261818,  2866704864,  755617465,  835768208,  1394358417,  4012239945,  2601238115,  3933467106  //  AutoContent_37_AIDNA_4
+	 };
+	assert(kFNeuronPoolSize == f_neurons_D.size());
+
+	primary_parent = std::rand() % 4;
+	const uint8_t parent2 = std::rand() % 4;
+
+	log ("    ... Primary parent: %d, secondary parent: %d\n", primary_parent, parent2);
+
+	// First setting of military numbers, they go directly to persistent data
+	for (uint16_t i = 0; i < kMagicNumbersSize; i += 1) {
+		// Child inherits DNA with probability 5:1 from main parent
+		uint8_t dna_donor = (std::rand() % kSecondParentProbability > 0) ? primary_parent : parent2;
+		if (i == kMutationRatePosition) { // Overwriting
+			dna_donor = primary_parent;
+		}
+
+		switch (dna_donor) {
+			case 0 :
+				set_military_number_at(i, AI_initial_military_numbers_A[i]);
+				break;
+			case 1 :
+				set_military_number_at(i, AI_initial_military_numbers_B[i]);
+				break;
+			case 2 :
+				set_military_number_at(i, AI_initial_military_numbers_C[i]);
+				break;
+			case 3 :
+				set_military_number_at(i, AI_initial_military_numbers_D[i]);
+				break;
+			default:
+				log ("parent %d?\n", dna_donor);
+				NEVER_HERE();
+			}
+		}
+
+	pd->neuron_weights.clear();
+	pd->neuron_functs.clear();
+	pd->f_neurons.clear();
+
+	for (uint16_t i = 0; i < kNeuronPoolSize; i += 1) {
+		const uint8_t dna_donor = (std::rand() % kSecondParentProbability > 0) ? primary_parent : parent2;
+
+		switch (dna_donor) {
+			case 0 :
+				pd->neuron_weights.push_back(input_weights_A[i]);
+				pd->neuron_functs.push_back(input_func_A[i]);
+				break;
+			case 1 :
+				pd->neuron_weights.push_back(input_weights_B[i]);
+				pd->neuron_functs.push_back(input_func_B[i]);
+				break;
+			case 2 :
+				pd->neuron_weights.push_back(input_weights_C[i]);
+				pd->neuron_functs.push_back(input_func_C[i]);
+				break;
+			case 3 :
+				pd->neuron_weights.push_back(input_weights_D[i]);
+				pd->neuron_functs.push_back(input_func_D[i]);
+				break;
+			default:
+				log ("parent %d?\n", dna_donor);
+				NEVER_HERE();
+		}
+	}
+
+
+	for (uint16_t i = 0; i < kFNeuronPoolSize; i += 1) {
+		const uint8_t dna_donor = (std::rand() % kSecondParentProbability > 0) ? primary_parent : parent2;
+		switch (dna_donor) {
+			case 0 :
+				pd->f_neurons.push_back(f_neurons_A[i]);
+				break;
+			case 1 :
+				pd->f_neurons.push_back(f_neurons_B[i]);
+				break;
+			case 2 :
+				pd->f_neurons.push_back(f_neurons_C[i]);
+				break;
+			case 3 :
+				pd->f_neurons.push_back(f_neurons_D[i]);
+				break;
+			default:
+				log ("parent %d?\n", dna_donor);
+				NEVER_HERE();
+		}
+	}
+
+	pd->magic_numbers_size = kMagicNumbersSize;
+	pd->neuron_pool_size = kNeuronPoolSize;
+	pd->f_neuron_pool_size = kFNeuronPoolSize;
+
+}
+// Decides if mutation takes place and how intensive it will be
+MutatingIntensity ManagementData::do_mutate(const uint8_t is_preferred, const int16_t mutation_probability) {
+	if (is_preferred > 0) {
+		return MutatingIntensity::kAgressive;
+	}
+	if (std::rand() % mutation_probability == 0) {
+		return MutatingIntensity::kNormal;
+	}
+	return MutatingIntensity::kNo;
+}
+
+// Mutating, but all done on persistent data
+void ManagementData::mutate(const uint8_t pn) {
+
+	int16_t probability =
+	   shift_weight_value(get_military_number_at(kMutationRatePosition), false) + 101;
+	if (probability > kUpperDefaultMutationLimit) {
+		probability = kUpperDefaultMutationLimit;
+	}
+	if (probability < kLowerDefaultMutationLimit) {
+		probability = kLowerDefaultMutationLimit;
+	}
+
+	set_military_number_at(kMutationRatePosition, probability - 101);
+
+	// decreasing probability (or rather increasing probability of mutation) if weaker player
+	if (ai_type == Widelands::AiType::kWeak) {
+		probability /= 2;
+		log("%2d: Weak mode, increasing mutation probability to 1 / %d\n", pn, probability);
+	} else if (ai_type == Widelands::AiType::kVeryWeak) {
+		probability /= 4;
+		log("%2d: Very weak mode, increasing mutation probability to 1 / %d\n", pn, probability);
+	}
+
+	assert(probability > 0 && probability <= 201);
+
+	log("%2d: mutating DNA with probability 1 / %3d:\n", pn, probability);
+
+	if (probability < 201) {
+
+		// Modifying pool of Military numbers
+		{
+			// Preferred numbers are ones that will be mutated agressively in full range [-kWeightRange, kWeightRange]
+			std::set<int32_t> preferred_numbers = {};
+
+			for (uint16_t i = 0; i < kMagicNumbersSize; i += 1) {
+				if (i == kMutationRatePosition) {  // mutated above
+					continue;
+				}
+
+				const MutatingIntensity mutating_intensity = do_mutate(preferred_numbers.count(i) > 0, probability);
+
+				if (mutating_intensity != MutatingIntensity::kNo) {
+					const int16_t old_value = get_military_number_at(i);
+					const int16_t new_value = shift_weight_value(get_military_number_at(i), mutating_intensity == MutatingIntensity::kAgressive);
+					set_military_number_at(i, new_value);
+					log("      Magic number %3d: value changed: %4d -> %4d  %s\n", i, old_value,
+					       new_value, (mutating_intensity == MutatingIntensity::kAgressive) ? "aggressive" : "");
+				}
+			}
+		}
+
+		// Modifying pool of neurons
+		{
+			// Neurons to be mutated more agressively
+			std::set<int32_t> preferred_neurons = {};
+			for (auto& item : neuron_pool) {
+
+				const MutatingIntensity mutating_intensity = do_mutate(preferred_neurons.count(item.get_id()) > 0, probability);
+
+				if (mutating_intensity != MutatingIntensity::kNo) {
+					const int16_t old_value = item.get_weight();
+					if (std::rand() % 4 == 0) {
+						assert(!neuron_curves.empty());
+						item.set_type(std::rand() % neuron_curves.size());
+						pd->neuron_functs[item.get_id()] = item.get_type();
+					} else {
+						int16_t new_value = shift_weight_value(item.get_weight(), mutating_intensity == MutatingIntensity::kAgressive);
+						item.set_weight(new_value);
+						pd->neuron_weights[item.get_id()] = item.get_weight();
+					}
+					log("      Neuron %2d: weight: %4d -> %4d, new curve: %d   %s\n", item.get_id(),
+					       old_value, item.get_weight(), item.get_type(),
+					       (mutating_intensity == MutatingIntensity::kAgressive) ? "aggressive" : "");
+
+					item.recalculate();
+				}
+			}
+		}
+
+		// Modifying pool of f-neurons
+		{
+			// FNeurons to be mutated more agressively
+			std::set<int32_t> preferred_f_neurons = {};
+			for (auto& item : f_neuron_pool) {
+				uint8_t changed_bits = 0;
+				// is this a preferred neuron
+				if (preferred_f_neurons.count(item.get_id()) > 0) {
+					for (uint8_t i = 0; i < kFNeuronBitSize; i += 1) {
+						if (std::rand() % 5 == 0) {
+							item.flip_bit(i);
+							changed_bits += 1;
+						}
+					}
+				} else {  // normal mutation
+					for (uint8_t i = 0; i < kFNeuronBitSize; i += 1) {
+						if (std::rand() % (probability * 3) == 0) {
+							item.flip_bit(i);
+							changed_bits += 1;
+						}
+					}
+				}
+
+				if (changed_bits) {
+					pd->f_neurons[item.get_id()] = item.get_int();
+					log("      F-Neuron %2d: new value: %13ul, changed bits: %2d   %s\n",
+					       item.get_id(), item.get_int(), changed_bits,
+					       (preferred_f_neurons.count(item.get_id()) > 0) ? "aggressive" : "");
+				}
+			}
+		}
+	}
+
+	test_consistency();
+}
+
+// Now we copy persistent to local
+void ManagementData::copy_persistent_to_local() {
+
+	assert(pd->neuron_weights.size() == kNeuronPoolSize);
+	assert(pd->neuron_functs.size() == kNeuronPoolSize);
+	neuron_pool.clear();
+	for (uint32_t i = 0; i < kNeuronPoolSize; i = i + 1) {
+		neuron_pool.push_back(Neuron(pd->neuron_weights[i], pd->neuron_functs[i], i));
+	}
+
+	assert(pd->f_neurons.size() == kFNeuronPoolSize);
+	f_neuron_pool.clear();
+	for (uint32_t i = 0; i < kFNeuronPoolSize; i = i + 1) {
+		f_neuron_pool.push_back(FNeuron(pd->f_neurons[i], i));
+	}
+
+	pd->magic_numbers_size = kMagicNumbersSize;
+	pd->neuron_pool_size = kNeuronPoolSize;
+	pd->f_neuron_pool_size = kFNeuronPoolSize;
+
+	test_consistency();
+	log("    ... DNA initialized\n");
+}
+
+void ManagementData::test_consistency(bool itemized) {
+
+	assert(pd->neuron_weights.size() == pd->neuron_pool_size);
+	assert(pd->neuron_functs.size() == pd->neuron_pool_size);
+	assert(neuron_pool.size() == pd->neuron_pool_size);
+	assert(neuron_pool.size() == kNeuronPoolSize);
+
+	assert(pd->magic_numbers_size == kMagicNumbersSize);
+	assert(pd->magic_numbers.size() == kMagicNumbersSize);
+
+	assert(pd->f_neurons.size() == pd->f_neuron_pool_size);
+	assert(f_neuron_pool.size() == pd->f_neuron_pool_size);
+	assert(f_neuron_pool.size() == kFNeuronPoolSize);
+
+	if (itemized) {
+		// comparing contents of neuron and fneuron pools
+		for (uint16_t i = 0; i < kNeuronPoolSize; i += 1) {
+			assert(pd->neuron_weights[i] == neuron_pool[i].get_weight());
+			assert(pd->neuron_functs[i] == neuron_pool[i].get_type());
+			assert(neuron_pool[i].get_id() == i);
+		}
+		for (uint16_t i = 0; i < kFNeuronPoolSize; i += 1) {
+			assert(pd->f_neurons[i] == f_neuron_pool[i].get_int());
+			assert(f_neuron_pool[i].get_id() == i);
+		}
+	}
+
+	return;
+}
+
+// Print DNA data to console, used for training
+// TODO(tiborb): Once we will have AI dumped into files, this should be removed
+// Also, used only for training
+void ManagementData::dump_data() {
+	// dumping new numbers
+	log("     actual military_numbers (%lu):\n      {", pd->magic_numbers.size());
+	uint16_t itemcounter = 1;
+	uint16_t line_counter = 1;
+	for (const auto& item : pd->magic_numbers) {
+		log(" %3d%s", item, (&item != &pd->magic_numbers.back()) ? ", " : "  ");
+		if (itemcounter % 10 == 0) {
+			log(" //  AutoContent_%02d\n       ", line_counter);
+			line_counter += 1;
+		}
+		++itemcounter;
+	}
+	log("}\n");
+
+	log("     actual neuron setup:\n      ");
+	log("{ ");
+	itemcounter = 1;
+	for (auto& item : neuron_pool) {
+		log(" %3d%s", item.get_weight(), (&item != &neuron_pool.back()) ? ", " : "  ");
+		if (itemcounter % 10 == 0) {
+			log(" //  AutoContent_%02d\n       ", line_counter);
+			line_counter += 1;
+		}
+		++itemcounter;
+	}
+	log("}\n      { ");
+	itemcounter = 1;
+	for (auto& item : neuron_pool) {
+		log(" %3d%s", item.get_type(), (&item != &neuron_pool.back()) ? ", " : "  ");
+		if (itemcounter % 10 == 0) {
+			log(" //  AutoContent_%02d\n       ", line_counter);
+			line_counter += 1;
+		}
+		++itemcounter;
+	}
+	log("}\n");
+
+	log("     actual f-neuron setup:\n      ");
+	log("{ ");
+	itemcounter = 1;
+	for (auto& item : f_neuron_pool) {
+		log(" %8u%s", item.get_int(), (&item != &f_neuron_pool.back()) ? ", " : "  ");
+		if (itemcounter % 10 == 0) {
+			log(" //  AutoContent_%02d\n       ", line_counter);
+			line_counter += 1;
+		}
+		++itemcounter;
+	}
+	log("}\n");
+}
+
+// Querying military number at a possition
+int16_t ManagementData::get_military_number_at(uint8_t pos) {
+	assert(pos < kMagicNumbersSize);
+	return pd->magic_numbers[pos];
+}
+
+// Setting military number (persistent numbers are used also for local use)
+void ManagementData::set_military_number_at(const uint8_t pos, int16_t value) {
+	assert(pos < kMagicNumbersSize);
+
+	while (pos >= pd->magic_numbers.size()) {
+		pd->magic_numbers.push_back(0);
+	}
+
+	value = Neuron::clip_weight_to_range(value);
+	pd->magic_numbers[pos] = value;
 }
 
 uint16_t MineTypesObserver::total_count() const {
@@ -292,7 +1098,7 @@
    : due_time(time), id(t), priority(p), descr(d) {
 }
 
-bool SchedulerTask::operator<(SchedulerTask other) const {
+bool SchedulerTask::operator<(const SchedulerTask& other) const {
 	return priority > other.priority;
 }
 
@@ -450,9 +1256,7 @@
 	}
 }
 
-bool FlagsForRoads::get_winner(uint32_t* winner_hash, uint32_t pos) {
-	assert(pos == 1 || pos == 2);
-	uint32_t counter = 1;
+bool FlagsForRoads::get_winner(uint32_t* winner_hash) {
 	// If AI can ask for 2nd position, but there is only one viable candidate
 	// we return the first one of course
 	bool has_winner = false;
@@ -466,37 +1270,98 @@
 		*winner_hash = candidate_flag.coords_hash;
 		has_winner = true;
 
-		if (counter == pos) {
+		if (std::rand() % 3 > 0) {
+			// with probability of 2/3 we accept this flag
 			return true;
-		} else if (counter < pos) {
-			counter += 1;
-		} else {
-			break;
 		}
 	}
+
 	if (has_winner) {
 		return true;
 	}
 	return false;
 }
 
-// This is an struct that stores strength of players, info on teams and provides some outputs from
-// these data
-PlayersStrengths::PlayerStat::PlayerStat() : team_number(0), players_power(0) {
-}
-PlayersStrengths::PlayerStat::PlayerStat(Widelands::TeamNumber tc, uint32_t pp)
-   : team_number(tc), players_power(pp) {
+PlayersStrengths::PlayersStrengths() : update_time(0) {
+}
+
+// Default constructor
+PlayersStrengths::PlayerStat::PlayerStat()
+   : team_number(0),
+     is_enemy(false),
+     players_power(0),
+     old_players_power(0),
+     old60_players_power(0),
+     players_casualities(0) {
+}
+
+// Constructor to be used
+PlayersStrengths::PlayerStat::PlayerStat(Widelands::TeamNumber tc,
+                                         bool e,
+                                         uint32_t pp,
+                                         uint32_t op,
+                                         uint32_t o60p,
+                                         uint32_t cs,
+                                         uint32_t land,
+                                         uint32_t oland,
+                                         uint32_t o60l)
+   : team_number(tc),
+     is_enemy(e),
+     players_power(pp),
+     old_players_power(op),
+     old60_players_power(o60p),
+     players_casualities(cs),
+     players_land(land),
+     old_players_land(oland),
+     old60_players_land(o60l) {
+	last_time_seen = kNever;
 }
 
 // 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)));
+// We keep information for
+// - player strength / power
+// - player casualties
+// - player land
+// We store actual values, but for some of them we store also
+// - old = 15 mins ago
+// - old60 = 60 mins ago
+// e.g. players_power / old_players_power / old60_players_power
+// we recieve also player and team numbers to figure out if we are enemies, or in the team
+void PlayersStrengths::add(Widelands::PlayerNumber pn,
+                           Widelands::PlayerNumber opn,
+                           Widelands::TeamNumber mytn,
+                           Widelands::TeamNumber pltn,
+                           uint32_t pp,
+                           uint32_t op,
+                           uint32_t o60p,
+                           uint32_t cs,
+                           uint32_t land,
+                           uint32_t oland,
+                           uint32_t o60l) {
+	if (all_stats.count(opn) == 0) {
+		bool enemy = false;
+		if (pn == opn) {
+			;
+		} else if (pltn == 0 || mytn == 0) {
+			enemy = true;
+		} else if (pltn != mytn) {
+			enemy = true;
+		}
+		this_player_number = pn;
+		all_stats.insert(std::make_pair(
+		   opn, PlayerStat(pltn, enemy, pp, op, o60p, cs, land, oland, o60l)));
 	} else {
-		all_stats[pn].players_power = pp;
+		all_stats[opn].players_power = pp;
+		all_stats[opn].old_players_power = op;
+		all_stats[opn].old60_players_power = o60p;
+		all_stats[opn].players_casualities = cs;
+		all_stats[opn].players_land = land;
+		all_stats[opn].old_players_land = oland;
+		all_stats[opn].old60_players_land = oland;
 	}
 }
 
+// After statistics for team members are updated, this calculation is needed
 void PlayersStrengths::recalculate_team_power() {
 	team_powers.clear();
 	for (auto& item : all_stats) {
@@ -510,6 +1375,186 @@
 	}
 }
 
+// This just goes over information about all enemies and where they were seen the last time
+bool PlayersStrengths::any_enemy_seen_lately(const uint32_t gametime) {
+	for (auto& item : all_stats) {
+		if (item.second.is_enemy && player_seen_lately(item.first, gametime)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+// Returns count of nearby enemies
+uint8_t PlayersStrengths::enemies_seen_lately_count(const uint32_t gametime) {
+	uint8_t count = 0;
+	for (auto& item : all_stats) {
+		if (item.second.is_enemy && player_seen_lately(item.first, gametime)) {
+			count += 1;
+		}
+	}
+	return count;
+}
+
+// When we see enemy, we use this to store the time
+void PlayersStrengths::set_last_time_seen(const uint32_t seentime, Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) == 0) {
+		return;
+	}
+	all_stats[pn].last_time_seen = seentime;
+}
+
+bool PlayersStrengths::get_is_enemy(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) == 0) {
+		// Should happen only rarely so we print a warning here
+		log("%d: WARNING: player has no statistics yet\n", this_player_number);
+		return false;
+	}
+	return all_stats[pn].is_enemy;
+}
+
+// Was the player seen less then 2 minutes ago
+bool PlayersStrengths::player_seen_lately(Widelands::PlayerNumber pn, const uint32_t gametime) {
+	if (all_stats.count(pn) == 0) {
+		// Should happen only rarely so we print a warning here
+		log("%d: WARNING: player has no statistics yet\n", this_player_number);
+		return false;
+	}
+	if (all_stats[pn].last_time_seen == kNever) {
+		return false;
+	}
+	if (all_stats[pn].last_time_seen + (2U * 60U * 1000U) > gametime) {
+		return true;
+	}
+	return false;
+}
+
+// This is the strength of a player
+uint32_t PlayersStrengths::get_player_power(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) > 0) {
+		return all_stats[pn].players_power;
+	};
+	return 0;
+}
+
+// This is the land size owned by player
+uint32_t PlayersStrengths::get_player_land(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) > 0) {
+		return all_stats[pn].players_land;
+	};
+	return 0;
+}
+
+// Calculates the strength of the enemies seen within the last 2 minutes
+uint32_t PlayersStrengths::get_visible_enemies_power(const uint32_t gametime) {
+	uint32_t pw = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first) && player_seen_lately(item.first, gametime)) {
+			pw += item.second.players_power;
+		}
+	}
+	return pw;
+}
+
+uint32_t PlayersStrengths::get_enemies_average_power() {
+	uint32_t sum = 0;
+	uint8_t count = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first)) {
+			sum += item.second.players_power;
+			++count;
+		}
+	}
+	if (count > 0) {
+		return sum / count;
+	}
+	return 0;
+}
+
+uint32_t PlayersStrengths::get_enemies_average_land() {
+	uint32_t sum = 0;
+	uint8_t count = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first)) {
+			sum += item.second.players_land;
+			++count;
+		}
+	}
+	if (count > 0) {
+		return sum / count;
+	}
+	return 0;
+}
+
+// Strength of stronger player
+uint32_t PlayersStrengths::get_enemies_max_power() {
+	uint32_t power = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first)) {
+			power = std::max<uint32_t>(power, item.second.players_power);
+		}
+	}
+	return power;
+}
+
+uint32_t PlayersStrengths::get_enemies_max_land() {
+	uint32_t land = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first)) {
+			land = std::max<uint32_t>(land, item.second.players_land);
+		}
+	}
+	return land;
+}
+
+uint32_t PlayersStrengths::get_old_player_power(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) > 0) {
+		return all_stats[pn].old_players_power;
+	}
+	return 0;
+}
+
+uint32_t PlayersStrengths::get_old60_player_power(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) > 0) {
+		return all_stats[pn].old60_players_power;
+	}
+	return 0;
+}
+
+uint32_t PlayersStrengths::get_old_player_land(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) == 0) {
+		log(" %d: Players statistics are still empty\n", pn);
+		return 0;
+	}
+	return all_stats[pn].old_players_land;
+}
+
+uint32_t PlayersStrengths::get_old60_player_land(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) == 0) {
+		log(" %d: Players statistics are still empty\n", pn);
+		return 0;
+	}
+	return all_stats[pn].old60_players_land;
+}
+
+uint32_t PlayersStrengths::get_old_visible_enemies_power(const uint32_t gametime) {
+	uint32_t pw = 0;
+	for (auto& item : all_stats) {
+		if (get_is_enemy(item.first) && player_seen_lately(item.first, gametime)) {
+			pw += item.second.old_players_power;
+		}
+	}
+	return pw;
+}
+
+// This is casualities of player
+uint32_t PlayersStrengths::get_player_casualities(Widelands::PlayerNumber pn) {
+	if (all_stats.count(pn) > 0) {
+		return all_stats[pn].players_casualities;
+	}
+	return 0;
+}
+
 // 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;
@@ -517,19 +1562,24 @@
 	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;
 }
 
+// Are the player in the same team
 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) {
+	assert(all_stats.count(pl1) > 0);
+	assert(all_stats.count(pl2) > 0);
+	if (pl1 == pl2) {
+		return false;
+	} else if (all_stats[pl1].team_number > 0 &&
+	           all_stats[pl1].team_number == all_stats[pl2].team_number) {
 		// team number 0 = no team
-		return all_stats[pl1].team_number > 0 &&
-		       all_stats[pl1].team_number == all_stats[pl2].team_number;
+		return true;
 	} else {
 		return false;
 	}
@@ -551,4 +1601,19 @@
 	return my_strength > strongest_opponent_strength + 50;
 }
 
-}  // namespace WIdelands
+// Update_time is used to prevent too frequent updates of statistics
+void PlayersStrengths::set_update_time(const uint32_t gametime) {
+	update_time = gametime;
+}
+
+uint32_t PlayersStrengths::get_update_time() {
+	return update_time;
+}
+
+ProductionSiteObserver::ProductionSiteObserver()
+   : no_resources_since(kNever),
+     upgrade_pending(false),
+     dismantle_pending_since(kNever) {
+}
+
+}  // namespace Widelands

=== modified file 'src/ai/ai_help_structs.h'
--- src/ai/ai_help_structs.h	2017-06-24 08:47:46 +0000
+++ src/ai/ai_help_structs.h	2017-07-03 17:39:38 +0000
@@ -21,6 +21,7 @@
 #define WL_AI_AI_HELP_STRUCTS_H
 
 #include <list>
+#include <queue>
 #include <unordered_set>
 
 #include "ai/ai_hints.h"
@@ -43,6 +44,8 @@
 
 enum class ExtendedBool : uint8_t { kUnset, kTrue, kFalse };
 
+enum class MutatingIntensity : uint8_t { kNo, kNormal, kAgressive };
+
 enum class BuildingNecessity : uint8_t {
 	kForced,
 	kNeeded,
@@ -54,6 +57,33 @@
 	kForbidden
 };
 
+// A building type can have no, one or multiple of these attributes
+enum class BuildingAttribute : uint8_t {
+	kBakery,
+	kRanger,
+	kBuildable,
+	kLumberjack,
+	kPort,
+	kNeedsRocks,
+	kWell,
+	kNeedsCoast,
+	kHunter,
+	kFisher,
+	kShipyard,
+	kBarracks,
+	kSpaceConsumer,
+	kRecruitment,
+	kBuildingMatProducer,
+	kUpgradeSubstitutes,
+	kUpgradeExtends,
+	kLogRefiner,
+	kIronMine
+};
+
+enum class AiType : uint8_t { kVeryWeak, kWeak, kNormal };
+
+enum class ExpansionMode : uint8_t { kResources = 0, kSpace = 1, kEconomy = 2, kBoth = 3 };
+
 enum class AiModeBuildings : uint8_t { kAnotherAllowed, kOnLimit, kLimitExceeded };
 
 enum class SchedulerTaskId : uint8_t {
@@ -74,9 +104,28 @@
 	kCheckTrainingsites,
 	kCountMilitaryVacant,
 	kCheckEnemySites,
+	kManagementUpdate,
+	kUpdateStats,
 	kUnset
 };
 
+// This is a simplification of a curve, to avoid repeated calculation
+const std::vector<std::vector<int8_t>> neuron_curves = {
+   {0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100},
+   {0, 0, 1, 2, 4, 6, 9, 12, 16, 20, 25, 30, 36, 42, 49, 56, 64, 72, 81, 90, 100},
+   {0, 17, 25, 32, 38, 44, 49, 53, 58, 62, 66, 70, 74, 78, 81, 84, 88, 91, 94, 97, 100},
+};
+
+constexpr int kMagicNumbersSize = 150;
+constexpr int kNeuronPoolSize = 80;
+constexpr int kFNeuronPoolSize = 60;
+constexpr int kFNeuronBitSize = 32;
+constexpr int kMutationRatePosition = 42;
+// TODO(tiborb): this should be replaced by command line switch
+constexpr bool kAITrainingMode = false;
+
+constexpr uint32_t kNever = std::numeric_limits<uint32_t>::max();
+
 struct CheckStepRoadAI {
 	CheckStepRoadAI(Player* const pl, uint8_t const mc, bool const oe);
 
@@ -112,17 +161,14 @@
 	Game& game;
 };
 
-// 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 {
-	FindNodeUnowned(Player* p, Game& g, bool oe = false);
+// We need to count walkable fields owned by enemy
+struct FindEnemyNodeWalkable {
+	FindEnemyNodeWalkable(Player* p, Game& g);
 
 	bool accept(const Map&, const FCoords& fc) const;
 
 	Player* player;
 	Game& game;
-	bool only_enemies;
 };
 
 // Sometimes we need to know how many nodes our allies owns
@@ -140,7 +186,19 @@
 // pay speciall attention to fields where mines can be built.
 // Fields should be completely unowned
 struct FindNodeUnownedMineable {
-	FindNodeUnownedMineable(Player* p, Game& g);
+	FindNodeUnownedMineable(Player* p, Game& g, int32_t t = INVALID_INDEX);
+
+	bool accept(const Map&, const FCoords& fc) const;
+
+	Player* player;
+	Game& game;
+	int32_t ore_type;
+};
+
+// When looking for unowned terrain to acquire, we must
+// consider if any buildings can be built on unowned land.
+struct FindNodeUnownedBuildable {
+	FindNodeUnownedBuildable(Player* p, Game& g);
 
 	bool accept(const Map&, const FCoords& fc) const;
 
@@ -216,6 +274,18 @@
 	int32_t distance;
 };
 
+struct EventTimeQueue {
+	EventTimeQueue();
+
+	void push(uint32_t);
+	uint32_t count(uint32_t);
+	void strip_old(uint32_t);
+
+private:
+	uint32_t duration_ = 20 * 60 * 1000;
+	std::queue<uint32_t> queue;
+};
+
 struct WalkableSpot {
 	Coords coords;
 	bool has_flag;
@@ -238,11 +308,17 @@
 
 	bool preferred;
 	bool enemy_nearby;
+	bool enemy_accessible_;
 
-	uint8_t unowned_land_nearby;
+	bool enemy_wh_nearby;
+	uint16_t unowned_land_nearby;
+	uint16_t enemy_owned_land_nearby;
+	uint16_t unowned_buildable_spots_nearby;
+	uint16_t nearest_buildable_spot_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;
+	uint16_t unowned_mines_spots_nearby;
+	uint16_t unowned_iron_mines_nearby;
 	uint8_t trees_nearby;
 	uint8_t rocks_nearby;
 	int16_t water_nearby;
@@ -264,22 +340,29 @@
 	// are construction sites that will change this once they are built
 	int16_t military_in_constr_nearby;
 	// actual count of soldiers in nearby buldings
-	int16_t area_military_presence;
+	int16_t own_military_presence;
+	int16_t enemy_military_presence;
+	int16_t enemy_military_sites;  // Including unfinished
+	int16_t ally_military_presence;
 	// stationed (manned) military buildings nearby
 	int16_t military_stationed;
-	// stationed (manned) military buildings nearby
 	// unconnected buildings nearby
 	bool unconnected_nearby;
 	int16_t military_unstationed;
-	bool is_portspace;
+	int16_t own_non_military_nearby;
+	bool defense_msite_allowed;
+	Widelands::ExtendedBool 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;
-	// it is not necessary to check resources (stones, fish...) too frequently as they do not change
-	// fast
-	// this stores time of last check
+	// It is not necessary to check resources (stones, fish...) too frequently as they do not change
+	// fast. This stores the time of the last check.
 	uint32_t last_resources_check_time;
+	int32_t military_score_;
+	bool inland;
+	uint16_t local_soldier_capacity;
+	bool is_militarysite;
 
 	std::vector<uint8_t> consumers_nearby;
 	std::vector<uint8_t> producers_nearby;
@@ -322,33 +405,27 @@
 	Widelands::AiModeBuildings aimode_limit_status();
 	bool buildable(Widelands::Player& p);
 
+	// Convenience functions for is_what
+	bool is(BuildingAttribute) const;
+	void set_is(BuildingAttribute);
+	void unset_is(BuildingAttribute);
+
 	char const* name;
 	Widelands::DescriptionIndex id;
 	Widelands::BuildingDescr const* desc;
 
 	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;
+	uint8_t max_trainingsites_proportion;
 
 	uint16_t unconnected_count;  // to any warehouse (count of such buildings)
 
@@ -358,16 +435,9 @@
 
 	std::vector<Widelands::DescriptionIndex> inputs;
 	std::vector<Widelands::DescriptionIndex> outputs;
+	std::vector<Widelands::DescriptionIndex> positions;
 	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;
-	// produces some additional wares
-	bool upgrade_extends;
-
 	// It seems that fish and meat are subsitutes (for trainingsites), so
 	// when testing if a trainingsite is supplied enough
 	// we count the wares together
@@ -388,7 +458,7 @@
 	int32_t cnt_upgrade_pending;  // number of buildings that are to be upgraded
 
 	// used to track amount of wares produced by building
-	uint32_t stocklevel;
+	uint32_t stocklevel_count;
 	uint32_t stocklevel_time;  // time when stocklevel_ was last time recalculated
 	uint32_t last_dismantle_time;
 	uint32_t construction_decision_time;
@@ -397,25 +467,27 @@
 	uint32_t unoccupied_count;
 
 	bool build_material_shortage;
+
+private:
+	std::set<BuildingAttribute> is_what;
 };
 
 struct ProductionSiteObserver {
+	ProductionSiteObserver();
 	Widelands::ProductionSite* site;
 	uint32_t built_time;
 	uint32_t unoccupied_till;
-	uint8_t stats_zero;
 	uint32_t no_resources_since;
 	bool upgrade_pending;
+	uint32_t dismantle_pending_since;
 	BuildingObserver* bo;
 };
 
 struct MilitarySiteObserver {
 	Widelands::MilitarySite* site;
 	BuildingObserver* bo;
-	uint8_t checks;
-	// when considering attack most military sites are inside territory and should be skipped during
-	// evaluation
-	bool enemies_nearby;
+	uint16_t understaffed;
+	uint32_t last_change;  // to prevent switching the occupancy policy too fast
 	uint32_t built_time;
 };
 
@@ -457,13 +529,15 @@
 
 	bool is_warehouse;
 	int32_t attack_soldiers_strength;
+	int32_t attack_soldiers_competency;
 	int32_t defenders_strength;
 	uint8_t stationed_soldiers;
-	uint32_t last_time_attackable;
+	uint32_t last_time_seen;
 	uint32_t last_tested;
 	int16_t score;
 	Widelands::ExtendedBool mines_nearby;
-	int16_t no_attack_counter;
+	uint32_t last_time_attacked;
+	uint32_t attack_counter;
 };
 
 // as all mines have 3 levels, AI does not know total count of mines per mined material
@@ -475,6 +549,122 @@
 
 	uint16_t in_construction;
 	uint16_t finished;
+	bool is_critical;
+	uint16_t unoccupied;
+};
+
+constexpr int kNeuronWeightLimit = 100;
+constexpr size_t kNeuronMaxPosition = 20;
+constexpr size_t kSecondParentProbability = 50;
+
+// A bunch of parameters used for trainig AI (for calculation of fitness function result)
+constexpr int16_t kCurrentLandDivider = 2;
+constexpr int16_t kLandDeltaMultiplier = 1;
+constexpr int16_t kBonus = 1000;
+constexpr int16_t kAttackersMultiplier = 1;
+constexpr int16_t kAttackBonus = 100;
+constexpr int16_t kTrainedSoldiersScore = 250;
+constexpr int16_t kConqueredWhBonus = 500;
+
+struct Neuron {
+	static int clip_weight_to_range(int w) {
+		assert(w < 125);
+		assert(w > -125);
+		return std::max(-kNeuronWeightLimit, std::min(kNeuronWeightLimit, w));
+	}
+
+	Neuron(int8_t, uint8_t, uint16_t);
+	void recalculate();
+	void set_weight(int8_t w);
+	int8_t get_weight() {
+		return weight;
+	}
+	int8_t get_result(size_t);
+	int8_t get_result_safe(int32_t, bool = false);
+	void set_type(uint8_t);
+	uint8_t get_type() {
+		return type;
+	}
+	uint16_t get_id() {
+		return id;
+	}
+
+private:
+	int8_t results[21];  // kPositions + 1
+	int8_t weight;
+	uint8_t type;
+	uint16_t id;
+};
+
+struct FNeuron {
+	FNeuron(uint32_t, uint16_t);
+
+	void flip_bit(uint8_t);
+	bool get_result(bool, bool, bool, bool bool4 = true, bool bool5 = true);
+	bool get_position(uint8_t);
+	uint32_t get_int();
+	uint16_t get_id() {
+		return id;
+	};
+
+private:
+	std::bitset<kFNeuronBitSize> core;
+	uint16_t id;
+};
+
+struct ExpansionType {
+	ExpansionType();
+
+	void set_expantion_type(ExpansionMode);
+	ExpansionMode get_expansion_type() {
+		return type;
+	};
+
+private:
+	ExpansionMode type;
+};
+
+// This is to keep all data related to AI magic numbers
+struct ManagementData {
+	ManagementData();
+
+	std::vector<Neuron> neuron_pool;
+	std::vector<FNeuron> f_neuron_pool;
+	Widelands::Player::AiPersistentState* pd;
+
+	void mutate(PlayerNumber = 0);
+	void new_dna_for_persistent(uint8_t, Widelands::AiType);
+	void copy_persistent_to_local();
+	void review(
+	   uint32_t, PlayerNumber, uint32_t, uint32_t, uint32_t, uint16_t, int16_t, int16_t, uint16_t);
+	void dump_data();
+	uint16_t new_neuron_id() {
+		++next_neuron_id;
+		return next_neuron_id - 1;
+	};
+	void reset_neuron_id() {
+		next_neuron_id = 0;
+	}
+	uint16_t new_bi_neuron_id() {
+		++next_bi_neuron_id;
+		return next_bi_neuron_id - 1;
+	};
+	void reset_bi_neuron_id() {
+		next_bi_neuron_id = 0;
+	}
+	int16_t get_military_number_at(uint8_t);
+	void set_military_number_at(uint8_t, int16_t);
+	MutatingIntensity do_mutate(uint8_t, int16_t);
+	int8_t shift_weight_value(int8_t, bool = true);
+	void test_consistency(bool = false);
+
+private:
+	int32_t score;
+	uint8_t primary_parent;
+	uint16_t next_neuron_id;
+	uint16_t next_bi_neuron_id;
+	uint16_t performance_change;
+	Widelands::AiType ai_type;
 };
 
 // this is used to count militarysites by their size
@@ -492,7 +682,7 @@
 	              const uint8_t p,
 	              const char* d);
 
-	bool operator<(SchedulerTask other) const;
+	bool operator<(const SchedulerTask& other) const;
 
 	uint32_t due_time;
 	Widelands::SchedulerTaskId id;
@@ -560,34 +750,87 @@
 	// Updating walking distance over existing roads
 	void set_road_distance(Widelands::Coords coords, int32_t distance);
 	// Finally we query the flag that we will build a road to
-	bool get_winner(uint32_t* winner_hash, uint32_t pos);
+	bool get_winner(uint32_t* winner_hash);
 };
 
 // This is a struct that stores strength of players, info on teams and provides some outputs from
 // these data
 struct PlayersStrengths {
+private:
 	struct PlayerStat {
 		PlayerStat();
-		PlayerStat(Widelands::TeamNumber tc, uint32_t pp);
+		PlayerStat(Widelands::TeamNumber tc,
+		           bool en,
+		           uint32_t pp,
+		           uint32_t op,
+		           uint32_t o60p,
+		           uint32_t cs,
+		           uint32_t land,
+		           uint32_t oland,
+		           uint32_t o60l);
 
 		Widelands::TeamNumber team_number;
+		bool is_enemy;
 		uint32_t players_power;
+		uint32_t old_players_power;
+		uint32_t old60_players_power;
+		uint32_t players_casualities;
+		uint32_t last_time_seen;
+		uint32_t players_land;
+		uint32_t old_players_land;
+		uint32_t old60_players_land;
 	};
 
+public:
+	PlayersStrengths();
 	// Inserting/updating data
-	void add(Widelands::PlayerNumber pn, Widelands::TeamNumber tn, uint32_t pp);
+	void add(Widelands::PlayerNumber pn,
+	         Widelands::PlayerNumber opn,
+	         Widelands::TeamNumber mytn,
+	         Widelands::TeamNumber pltn,
+	         uint32_t pp,
+	         uint32_t op,
+	         uint32_t o60p,
+	         uint32_t cs,
+	         uint32_t land,
+	         uint32_t oland,
+	         uint32_t o60l);
 	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);
+	uint32_t get_player_power(Widelands::PlayerNumber pn);
+	uint32_t get_old_player_power(Widelands::PlayerNumber pn);
+	uint32_t get_old60_player_power(Widelands::PlayerNumber pn);
+	uint32_t get_player_land(Widelands::PlayerNumber pn);
+	uint32_t get_old_player_land(Widelands::PlayerNumber pn);
+	uint32_t get_old60_player_land(Widelands::PlayerNumber pn);
+	uint32_t get_visible_enemies_power(uint32_t);
+	uint32_t get_enemies_average_power();
+	uint32_t get_enemies_average_land();
+	uint32_t get_enemies_max_power();
+	uint32_t get_enemies_max_land();
+	uint32_t get_old_visible_enemies_power(uint32_t);
+	uint32_t get_player_casualities(Widelands::PlayerNumber pn);
 	bool players_in_same_team(Widelands::PlayerNumber pl1, Widelands::PlayerNumber pl2);
 	bool strong_enough(Widelands::PlayerNumber pl);
+	void set_last_time_seen(uint32_t, Widelands::PlayerNumber);
+	bool player_seen_lately(Widelands::PlayerNumber, uint32_t);
+	bool get_is_enemy(Widelands::PlayerNumber);
+	uint8_t enemies_seen_lately_count(uint32_t);
+	bool any_enemy_seen_lately(uint32_t);
+	PlayerNumber this_player_number;
+	void set_update_time(uint32_t);
+	uint32_t get_update_time();
 
+private:
 	// 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;
+
+	uint32_t update_time;
 };
 }  // namespace Widelands
 

=== modified file 'src/ai/ai_hints.cc'
--- src/ai/ai_hints.cc	2017-05-25 07:16:05 +0000
+++ src/ai/ai_hints.cc	2017-07-03 17:39:38 +0000
@@ -38,27 +38,19 @@
         table->has_key("mountain_conqueror") ? table->get_bool("mountain_conqueror") : false),
      shipyard_(table->has_key("shipyard") ? table->get_bool("shipyard") : false),
      prohibited_till_(table->has_key("prohibited_till") ? table->get_int("prohibited_till") : 0),
+     basic_amount_(table->has_key("basic_amount") ? table->get_int("basic_amount") : 0),
      // 10 days default
      forced_after_(table->has_key("forced_after") ? table->get_int("forced_after") : 864000),
      mines_percent_(table->has_key("mines_percent") ? table->get_int("mines_percent") : 100),
      very_weak_ai_limit_(
         table->has_key("very_weak_ai_limit") ? table->get_int("very_weak_ai_limit") : -1),
      weak_ai_limit_(table->has_key("weak_ai_limit") ? table->get_int("weak_ai_limit") : -1),
-     trainingsite_type_(TrainingSiteType::kNoTS),
      trainingsites_max_percent_(table->has_key("trainingsites_max_percent") ?
                                    table->get_int("trainingsites_max_percent") :
                                    0) {
-
-	if (table->has_key("trainingsite_type")) {
-		if (table->get_string("trainingsite_type") == "basic") {
-			trainingsite_type_ = TrainingSiteType::kBasic;
-		} else if (table->get_string("trainingsite_type") == "advanced") {
-			trainingsite_type_ = TrainingSiteType::kAdvanced;
-		}
-	}
 }
 
-void BuildingHints::set_trainingsites_max_percent(uint8_t percent) {
+void BuildingHints::set_trainingsites_max_percent(int percent) {
 	trainingsites_max_percent_ = percent;
 }
 

=== modified file 'src/ai/ai_hints.h'
--- src/ai/ai_hints.h	2017-06-24 08:47:46 +0000
+++ src/ai/ai_hints.h	2017-07-03 17:39:38 +0000
@@ -28,8 +28,6 @@
 #include "base/macros.h"
 #include "scripting/lua_table.h"
 
-enum class TrainingSiteType : uint8_t { kNoTS = 0, kBasic = 1, kAdvanced = 2 };
-
 /// This struct is used to read out the data given in [aihints] section of a
 /// buildings conf file. It is used to tell the computer player about the
 /// special properties of a building.
@@ -95,6 +93,10 @@
 		return prohibited_till_;
 	}
 
+	uint32_t basic_amount() const {
+		return basic_amount_;
+	}
+
 	uint32_t get_forced_after() const {
 		return forced_after_;
 	}
@@ -111,11 +113,7 @@
 		return weak_ai_limit_;
 	}
 
-	TrainingSiteType get_trainingsite_type() const {
-		return trainingsite_type_;
-	}
-
-	void set_trainingsites_max_percent(uint8_t percent);
+	void set_trainingsites_max_percent(int percent);
 
 	uint8_t trainingsites_max_percent() const;
 
@@ -133,11 +131,11 @@
 	bool mountain_conqueror_;
 	bool shipyard_;
 	int32_t prohibited_till_;
+	uint32_t basic_amount_;
 	int32_t forced_after_;
 	int8_t mines_percent_;
 	int16_t very_weak_ai_limit_;
 	int16_t weak_ai_limit_;
-	TrainingSiteType trainingsite_type_;
 	int trainingsites_max_percent_;
 
 	DISALLOW_COPY_AND_ASSIGN(BuildingHints);

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2017-06-24 20:22:19 +0000
+++ src/ai/defaultai.cc	2017-07-03 17:39:38 +0000
@@ -62,13 +62,16 @@
 constexpr int kMinBFCheckInterval = 5 * 1000;
 constexpr int kMinMFCheckInterval = 19 * 1000;
 constexpr int kMarineDecisionInterval = 20 * 1000;
+constexpr int kRemainingBasicBuildingsResetTime = 1 * 60 * 1000;
 
 // 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 uint16_t kTargetQuantCap = 30;
+
+// this is intended for map developers & testers, should be off by default
 constexpr bool kPrintStats = false;
 
 // for scheduler
@@ -81,37 +84,29 @@
 DefaultAI::VeryWeakImpl DefaultAI::very_weak_impl;
 
 /// Constructor of DefaultAI
-DefaultAI::DefaultAI(Game& ggame, PlayerNumber const pid, DefaultAI::Type const t)
+DefaultAI::DefaultAI(Game& ggame, PlayerNumber const pid, Widelands::AiType const t)
    : ComputerPlayer(ggame, pid),
      type_(t),
      player_(nullptr),
      tribe_(nullptr),
+     attackers_count_(0),
      next_ai_think_(0),
      scheduler_delay_counter_(0),
      wood_policy_(WoodPolicy::kAllowRangers),
-     num_prod_constructionsites(0),
+     numof_psites_in_constr(0),
      num_ports(0),
      numof_warehouses_(0),
+     numof_warehouses_in_const_(0),
      military_last_dismantle_(0),
      military_last_build_(0),
      time_of_last_construction_(0),
      next_mine_construction_due_(0),
-     ts_basic_count_(0),
-     ts_basic_const_count_(0),
-     ts_advanced_count_(0),
-     ts_advanced_const_count_(0),
+     fishers_count_(0),
+     bakeries_count_(),
+     ts_finished_count_(0),
+     ts_in_const_count_(0),
      ts_without_trainers_(0),
      inhibit_road_building_(0),
-     last_road_dismantled_(0),
-     enemy_last_seen_(kNever),
-     vacant_mil_positions_(0),
-     last_attack_time_(0),
-     enemysites_check_delay_(60),
-     spots_(0),
-     new_buildings_stop_(false),
-     resource_necessity_territory_(100),
-     resource_necessity_mines_(100),
-     resource_necessity_water_(0),
      resource_necessity_water_needed_(false),
      highest_nonmil_prio_(0),
      seafaring_economy(false),
@@ -249,6 +244,8 @@
 
 	const int32_t delay_time = gametime - taskPool.front().due_time;
 
+	Map& map = game().map();
+
 	// Here we decide how many jobs will be run now (none - 5)
 	// in case no job is due now, it can be zero
 	uint32_t jobs_to_run_count = (delay_time < 0) ? 0 : 1;
@@ -400,7 +397,7 @@
 			// checking 3 mines if possible
 			{
 				int32_t mines_to_check = (mines_.size() < 5) ? mines_.size() : 5;
-				for (int j = 0; j < mines_to_check; j += 1) {
+				for (int j = 0; j < mines_to_check; ++j) {
 					// every run of check_mines_() checks one mine
 					if (check_mines_(gametime)) {
 						// if significant change takes place do not go on
@@ -411,9 +408,11 @@
 			break;
 		case SchedulerTaskId::kCheckMilitarysites:
 			// just to be sure the value is reset
-			// 4 seconds is really fine
-			set_taskpool_task_time(gametime + 4 * 1000, SchedulerTaskId::kCheckMilitarysites);
-			check_militarysites(gametime);
+			if (check_militarysites(gametime)) {
+				set_taskpool_task_time(gametime + 15 * 1000, SchedulerTaskId::kCheckMilitarysites);
+			} else {
+				set_taskpool_task_time(gametime + 4 * 1000, SchedulerTaskId::kCheckMilitarysites);
+			}
 			break;
 		case SchedulerTaskId::kCheckTrainingsites:
 			set_taskpool_task_time(
@@ -422,7 +421,7 @@
 			break;
 		case SchedulerTaskId::kCountMilitaryVacant:
 			count_military_vacant_positions();
-			set_taskpool_task_time(gametime + 45 * 1000, SchedulerTaskId::kCountMilitaryVacant);
+			set_taskpool_task_time(gametime + 25 * 1000, SchedulerTaskId::kCountMilitaryVacant);
 			break;
 		case SchedulerTaskId::kWareReview:
 			if (check_economies()) {  // economies must be consistent
@@ -435,13 +434,38 @@
 			if (check_economies()) {  // economies must be consistent
 				return;
 			}
-			set_taskpool_task_time(gametime + 30 * 60 * 1000, SchedulerTaskId::kPrintStats);
-			print_stats();
+			set_taskpool_task_time(gametime + 10 * 60 * 1000, SchedulerTaskId::kPrintStats);
+			print_stats(gametime);
 			break;
 		case SchedulerTaskId::kCheckEnemySites:
 			check_enemy_sites(gametime);
 			set_taskpool_task_time(gametime + 19 * 1000, SchedulerTaskId::kCheckEnemySites);
 			break;
+		case SchedulerTaskId::kManagementUpdate:
+			// This task is used for training the AI, so it should be usually disabled
+			{  // statistics for spotted warehouses
+				uint16_t conquered_wh = 0;
+				for (auto coords : enemy_warehouses) {
+					if (get_land_owner(map, coords) == player_number()) {
+						++conquered_wh;
+					}
+				};
+				if (!enemy_warehouses.empty())
+					log("Conquered warehouses: %d / %lu\n", conquered_wh, enemy_warehouses.size());
+				management_data.review(gametime, player_number(),
+				                       player_statistics.get_player_land(player_number()),
+				                       player_statistics.get_enemies_max_land(),
+				                       player_statistics.get_old60_player_land(player_number()),
+				                       attackers_count_, soldier_trained_log.count(gametime),
+				                       soldier_attacks_log.count(gametime), conquered_wh);
+				set_taskpool_task_time(
+				   gametime + kManagementUpdateInterval, SchedulerTaskId::kManagementUpdate);
+			}
+			break;
+		case SchedulerTaskId::kUpdateStats:
+			update_player_stat(gametime);
+			set_taskpool_task_time(gametime + kStatUpdateInterval, SchedulerTaskId::kUpdateStats);
+			break;
 		case SchedulerTaskId::kUnset:
 			NEVER_HERE();
 		}
@@ -474,7 +498,92 @@
 
 	const DescriptionIndex& nr_buildings = game().tribes().nrbuildings();
 
-	// Collect information about the different buildings that our tribe can have
+	// The data struct below is owned by Player object, the purpose is to have them saved therein
+	persistent_data = player_->get_mutable_ai_persistent_state();
+	management_data.pd = player_->get_mutable_ai_persistent_state();
+	const bool create_basic_buildings_list = (gametime < kRemainingBasicBuildingsResetTime);
+
+	if (persistent_data->initialized == kFalse) {
+		// As all data are initialized without given values, they must be populated with reasonable
+		// values first
+		persistent_data->colony_scan_area = kColonyScanStartArea;
+		persistent_data->trees_around_cutters = 0;
+		persistent_data->initialized = kTrue;
+		persistent_data->last_attacked_player = std::numeric_limits<int16_t>::max();
+		persistent_data->expedition_start_time = kNoExpedition;
+		persistent_data->ships_utilization = 200;
+		persistent_data->no_more_expeditions = kFalse;
+		persistent_data->target_military_score = 100;
+		persistent_data->least_military_score = 0;
+		persistent_data->ai_productionsites_ratio = std::rand() % 5 + 7;
+		persistent_data->ai_personality_mil_upper_limit = 100;
+
+		// all zeroes
+		assert(persistent_data->neuron_weights.empty());
+		assert(persistent_data->neuron_functs.empty());
+		assert(persistent_data->magic_numbers_size == 0);
+		assert(persistent_data->neuron_pool_size == 0);
+		assert(persistent_data->magic_numbers.empty());
+
+		// AI's DNA population
+		management_data.new_dna_for_persistent(player_number(), type_);
+		management_data.copy_persistent_to_local();
+		management_data.mutate(player_number());
+		if (kAITrainingMode) {
+			management_data.dump_data();
+		}
+
+		management_data.test_consistency(true);
+		assert(management_data.get_military_number_at(42) ==
+		       management_data.get_military_number_at(kMutationRatePosition));
+
+	} else if (persistent_data->initialized == kTrue) {
+		// Doing some consistency checks
+		check_range<uint32_t>(
+		   persistent_data->expedition_start_time, gametime, "expedition_start_time");
+		check_range<uint16_t>(persistent_data->ships_utilization, 0, 10000, "ships_utilization_");
+
+		// for backward consistency
+		if (persistent_data->ai_personality_mil_upper_limit <
+		    persistent_data->target_military_score) {
+			persistent_data->ai_personality_mil_upper_limit = persistent_data->target_military_score;
+		}
+		if (persistent_data->least_military_score > persistent_data->target_military_score) {
+			persistent_data->least_military_score = persistent_data->target_military_score;
+		}
+
+		if (kAITrainingMode) {
+			log("%2d: reinitializing dna (kAITrainingMode set true)", player_number());
+			management_data.new_dna_for_persistent(player_number(), type_);
+			management_data.copy_persistent_to_local();
+			management_data.mutate(player_number());
+
+		} else {
+			management_data.copy_persistent_to_local();
+		}
+
+		management_data.test_consistency(true);
+		if (kAITrainingMode) {
+			management_data.dump_data();
+		}
+
+		log(" %2d: %lu basic buildings in savegame file. %s\n", player_number(),
+		    persistent_data->remaining_basic_buildings.size(),
+		    (create_basic_buildings_list) ?
+		       "New list will be recreated though (kAITrainingMode is true)" :
+		       "");
+
+	} else {
+		throw wexception("Corrupted AI data");
+	}
+
+	// Even if we have basic buildings from savefile, we ignore them and recreate them based
+	// on lua conf files
+	if (create_basic_buildings_list) {
+		persistent_data->remaining_basic_buildings.clear();
+		persistent_data->remaining_buildings_size = 0;
+	}
+
 	for (DescriptionIndex building_index = 0; building_index < nr_buildings; ++building_index) {
 		const BuildingDescr& bld = *tribe_->get_building_descr(building_index);
 		if (!tribe_->has_building(building_index) && bld.type() != MapObjectType::MILITARYSITE) {
@@ -494,7 +603,7 @@
 		bo.cnt_target = 1;  // default for everything
 		bo.cnt_limit_by_aimode = std::numeric_limits<int32_t>::max();
 		bo.cnt_upgrade_pending = 0;
-		bo.stocklevel = 0;
+		bo.stocklevel_count = 0;
 		bo.stocklevel_time = 0;
 		bo.last_dismantle_time = 0;
 		// this is set to negative number, otherwise the AI would wait 25 sec
@@ -508,23 +617,41 @@
 		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();
+		if (bld.is_buildable()) {
+			bo.set_is(BuildingAttribute::kBuildable);
+		}
+		if (bh.is_logproducer()) {
+			bo.set_is(BuildingAttribute::kLumberjack);
+		}
+		if (bh.is_graniteproducer()) {
+			bo.set_is(BuildingAttribute::kNeedsRocks);
+		}
+		if (create_basic_buildings_list &&
+		    bh.basic_amount() > 0) {  // This is the very begining of the game
+			persistent_data->remaining_basic_buildings[bo.id] = bh.basic_amount();
+			++persistent_data->remaining_buildings_size;
+		}
+		if (bh.get_needs_water()) {
+			bo.set_is(BuildingAttribute::kNeedsCoast);
+		}
+		if (bh.mines_water()) {
+			bo.set_is(BuildingAttribute::kWell);
+		}
+		if (bh.is_space_consumer()) {
+			bo.set_is(BuildingAttribute::kSpaceConsumer);
+		}
+		if (bh.for_recruitment()) {
+			bo.set_is(BuildingAttribute::kRecruitment);
+		}
 		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;
+		if (bld.get_isport()) {
+			bo.set_is(BuildingAttribute::kPort);
+		}
+		bo.max_trainingsites_proportion = 100;
 		bo.max_preciousness = 0;
 		bo.max_needed_preciousness = 0;
 
@@ -534,18 +661,16 @@
 
 		// I just presume cut wood is named "log" in the game
 		if (tribe_->safe_ware_index("log") == bo.production_hint) {
-			bo.plants_trees = true;
-		} else {
-			bo.plants_trees = false;
+			bo.set_is(BuildingAttribute::kRanger);
 		}
 
 		// Is total count of this building limited by AI mode?
-		if (type_ == DefaultAI::Type::kVeryWeak && bh.get_very_weak_ai_limit() >= 0) {
+		if (type_ == Widelands::AiType::kVeryWeak && bh.get_very_weak_ai_limit() >= 0) {
 			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.name);
 		}
-		if (type_ == DefaultAI::Type::kWeak && bh.get_weak_ai_limit() >= 0) {
+		if (type_ == Widelands::AiType::kWeak && bh.get_weak_ai_limit() >= 0) {
 			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.name);
@@ -562,6 +687,11 @@
 			for (const DescriptionIndex& temp_output : prod.output_ware_types()) {
 				bo.outputs.push_back(temp_output);
 			}
+			for (const auto temp_position : prod.working_positions()) {
+				bo.positions.push_back(temp_position.first);
+			}
+
+			iron_ore_id = tribe_->ironore();
 
 			if (bo.type == BuildingObserver::Type::kMine) {
 				// get the resource needed by the mine
@@ -575,23 +705,36 @@
 				if (mines_per_type.count(bo.mines) == 0) {
 					mines_per_type[bo.mines] = MineTypesObserver();
 				}
+				// Identify iron mines based on output
+				if (bo.outputs[0] == iron_ore_id) {
+					bo.set_is(BuildingAttribute::kIronMine);
+					mines_per_type[bo.mines].is_critical = true;
+				}
 			}
 
 			// here we identify hunters
 			if (bo.outputs.size() == 1 && tribe_->safe_ware_index("meat") == bo.outputs.at(0)) {
-				bo.is_hunter = true;
-			} else {
-				bo.is_hunter = false;
+				bo.set_is(BuildingAttribute::kHunter);
 			}
 
 			// and fishers
 			if (bo.outputs.size() == 1 && tribe_->safe_ware_index("fish") == bo.outputs.at(0)) {
-				bo.is_fisher = true;
-			} else {
-				bo.is_fisher = false;
+				bo.set_is(BuildingAttribute::kFisher);
 			}
 
-			bo.is_shipyard = bh.is_shipyard();
+			if (bh.is_shipyard()) {
+				bo.set_is(BuildingAttribute::kShipyard);
+			}
+			if (building_index == tribe_->barracks()) {
+				bo.set_is(BuildingAttribute::kBarracks);
+			}
+			if (building_index == tribe_->bakery()) {
+				bo.set_is(BuildingAttribute::kBakery);
+			}
+			// Identify refined log producer
+			if (bo.outputs.size() == 1 && bo.outputs[0] == tribe_->refinedlog()) {
+				bo.set_is(BuildingAttribute::kLogRefiner);
+			}
 
 			// now we find out if the upgrade of the building is a full substitution
 			// (produces all wares as current one)
@@ -607,10 +750,10 @@
 				}
 				// now testing outputs of current building
 				// and comparing
-				bo.upgrade_substitutes = true;
+				bo.set_is(BuildingAttribute::kUpgradeSubstitutes);
 				for (DescriptionIndex ware : bo.outputs) {
 					if (enh_outputs.count(ware) == 0) {
-						bo.upgrade_substitutes = false;
+						bo.unset_is(BuildingAttribute::kUpgradeSubstitutes);
 						break;
 					}
 				}
@@ -620,40 +763,50 @@
 				for (const DescriptionIndex& ware : bo.outputs) {
 					cur_outputs.insert(ware);
 				}
-				bo.upgrade_extends = false;
+				// Does upgraded building produce any different outputs?
 				for (DescriptionIndex ware : enh_outputs) {
 					if (cur_outputs.count(ware) == 0) {
-						bo.upgrade_extends = true;
+						bo.set_is(BuildingAttribute::kUpgradeExtends);
 						break;
 					}
 				}
 			}
 
 			// now we identify producers of critical build materials
-			// hardwood now
 			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.produces_building_material = true;
-				}
-			}
+				// building material except for trivial material
+				if (tribe_->is_construction_material(ware) &&
+				    !(ware == tribe_->rawlog() || ware == tribe_->granite())) {
+					bo.set_is(BuildingAttribute::kBuildingMatProducer);
+					if (bo.type == BuildingObserver::Type::kMine) {
+						has_critical_mines = true;
+						mines_per_type[bo.mines].is_critical = true;
+					}
+				}
+			}
+
+			for (const auto& temp_buildcosts : prod.buildcost()) {
+				// building material except for trivial material
+				if (tribe_->is_construction_material(temp_buildcosts.first) &&
+				    !(temp_buildcosts.first == tribe_->rawlog() ||
+				      temp_buildcosts.first == tribe_->granite())) {
+					bo.critical_building_material.push_back(temp_buildcosts.first);
+				}
+			}
+
 			continue;
 		}
 
 		// 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::Type::kMilitarysite;
 			const MilitarySiteDescr& milit = dynamic_cast<const MilitarySiteDescr&>(bld);
 			for (const auto& temp_buildcosts : milit.buildcost()) {
-				// bellow are non-critical wares (well, various types of wood)
-				if (tribe_->ware_index("log") == temp_buildcosts.first ||
-				    tribe_->ware_index("blackwood") == temp_buildcosts.first ||
-				    tribe_->ware_index("planks") == temp_buildcosts.first)
+				// Below are non-critical wares (well, various types of wood)
+				if (temp_buildcosts.first == tribe_->rawlog() ||
+				    temp_buildcosts.first == tribe_->refinedlog())
 					continue;
-
 				bo.critical_building_material.push_back(temp_buildcosts.first);
 			}
 			continue;
@@ -666,6 +819,8 @@
 
 		if (bld.type() == MapObjectType::TRAININGSITE) {
 			bo.type = BuildingObserver::Type::kTrainingsite;
+			bo.max_trainingsites_proportion = bh.trainingsites_max_percent();
+			assert(bo.max_trainingsites_proportion <= 100);
 			const TrainingSiteDescr& train = dynamic_cast<const TrainingSiteDescr&>(bld);
 			for (const auto& temp_input : train.input_wares()) {
 				bo.inputs.push_back(temp_input.first);
@@ -678,19 +833,17 @@
 					bo.substitute_inputs.insert(temp_input.first);
 				}
 
+				// Creating vector with critical material, to be used to discourage
+				// building of new sites if ware is lacking
 				for (const auto& temp_buildcosts : train.buildcost()) {
-					// critical wares for trainingsites
-					if (tribe_->ware_index("spidercloth") == temp_buildcosts.first ||
-					    tribe_->ware_index("gold") == temp_buildcosts.first ||
-					    tribe_->ware_index("grout") == temp_buildcosts.first) {
+					// building material except for trivial material
+					if (!(temp_buildcosts.first == tribe_->rawlog() ||
+					      temp_buildcosts.first == tribe_->refinedlog() ||
+					      temp_buildcosts.first == tribe_->granite())) {
 						bo.critical_building_material.push_back(temp_buildcosts.first);
 					}
 				}
 			}
-			bo.trainingsite_type = bh.get_trainingsite_type();
-			// it would behave badly if no type was set
-			// make sure all TS have its type set properly in conf files
-			assert(bo.trainingsite_type != TrainingSiteType::kNoTS);
 			continue;
 		}
 
@@ -700,6 +853,16 @@
 		}
 	}
 
+	// We must verify that some buildings has been identified
+	// Also note that the AI assumes that some buildings are unique, if you want to
+	// create e.g. two barracks or bakeries, the impact on the AI must be considered
+	assert(count_buildings_with_attribute(BuildingAttribute::kBarracks) == 1);
+	assert(count_buildings_with_attribute(BuildingAttribute::kBakery) == 1);
+	assert(count_buildings_with_attribute(BuildingAttribute::kLogRefiner) == 1);
+	assert(count_buildings_with_attribute(BuildingAttribute::kIronMine) >= 1);
+	// If there will be a tribe with more than 3 mines of the same type, just increase the number
+	assert(count_buildings_with_attribute(BuildingAttribute::kIronMine) <= 3);
+
 	// atlanteans they consider water as a resource
 	// (together with mines, rocks and wood)
 	if (tribe_->name() == "atlanteans") {
@@ -743,13 +906,21 @@
 	                                 "check unbuildable fields"));
 	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 15 * 60 * 1000),
 	                                 SchedulerTaskId::kWareReview, 9, "wares review"));
-	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 30 * 60 * 1000),
+	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 10 * 60 * 1000),
 	                                 SchedulerTaskId::kPrintStats, 9, "print statistics"));
 	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 1 * 60 * 1000),
 	                                 SchedulerTaskId::kCountMilitaryVacant, 2,
 	                                 "count military vacant"));
 	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 10 * 60 * 1000),
 	                                 SchedulerTaskId::kCheckEnemySites, 6, "check enemy sites"));
+	if (kAITrainingMode) {
+		taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 10 * 1000),
+		                                 SchedulerTaskId::kManagementUpdate, 8, "reviewing"));
+	}
+	taskPool.push_back(SchedulerTask(std::max<uint32_t>(gametime, 9 * 1000),
+	                                 SchedulerTaskId::kUpdateStats, 6, "update player stats"));
+	taskPool.push_back(SchedulerTask(
+	   std::max<uint32_t>(gametime, 10 * 1000), SchedulerTaskId::kUpdateStats, 15, "review"));
 
 	Map& map = game().map();
 
@@ -821,7 +992,8 @@
 
 	// 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->is(BuildingAttribute::kSpaceConsumer) &&
+		    !ps_obs.bo->is(BuildingAttribute::kRanger)) {
 			MapRegion<Area<FCoords>> mr(
 			   map, Area<FCoords>(map.get_fcoords(ps_obs.site->get_position()), 4));
 			do {
@@ -830,45 +1002,19 @@
 		}
 	}
 
-	// The data struct below is owned by Player object, the purpose is to have them saved therein
-	persistent_data = player_->get_mutable_ai_persistent_state();
-
-	if (persistent_data->initialized == kFalse) {
-		// As all data are initialized without given values, they must be populated with reasonable
-		// values first
-		persistent_data->colony_scan_area = kColonyScanStartArea;
-		persistent_data->trees_around_cutters = 0;
-		persistent_data->initialized = kTrue;
-		persistent_data->last_attacked_player = std::numeric_limits<int16_t>::max();
-		persistent_data->expedition_start_time = kNoExpedition;
-		persistent_data->ships_utilization = 200;
-		persistent_data->no_more_expeditions = kFalse;
-		persistent_data->target_military_score = 0;
-		persistent_data->least_military_score = 100;
-		persistent_data->ai_personality_military_loneliness = std::rand() % 5 * 30 - 60;
-		persistent_data->ai_personality_attack_margin = std::max(std::rand() % 20 - 5, 0);
-		persistent_data->ai_productionsites_ratio = std::rand() % 5 + 7;
-		persistent_data->ai_personality_wood_difference = std::rand() % 40 - 20;
-		persistent_data->ai_personality_early_militarysites = std::rand() % 20 + 20;
-		persistent_data->last_soldier_trained = kNever;
-	} else if (persistent_data->initialized == kTrue) {
-		// Doing some consistency checks
-		check_range<uint32_t>(
-		   persistent_data->expedition_start_time, gametime, "expedition_start_time");
-		check_range<uint16_t>(persistent_data->ships_utilization, 0, 10000, "ships_utilization_");
-		check_range<int16_t>(persistent_data->ai_personality_military_loneliness, -60, 60,
-		                     "ai_personality_military_loneliness");
-		check_range<int32_t>(
-		   persistent_data->ai_personality_attack_margin, 15, "ai_personality_attack_margin");
-		check_range<uint32_t>(
-		   persistent_data->ai_productionsites_ratio, 5, 15, "ai_productionsites_ratio");
-		check_range<int32_t>(persistent_data->ai_personality_wood_difference, -20, 19,
-		                     "ai_personality_wood_difference");
-		check_range<uint32_t>(persistent_data->ai_personality_early_militarysites, 20, 40,
-		                      "ai_personality_early_militarysites");
-	} else {
-		throw wexception("Corrupted AI data");
+	// printing identified basic buildings if we are in the basic economy mode
+	basic_economy_established = persistent_data->remaining_basic_buildings.empty();
+	if (!basic_economy_established) {
+		log("%2d: Initializing in the basic economy mode, required buildings:\n", player_number());
+		for (auto bb : persistent_data->remaining_basic_buildings) {
+			log("   %3d / %-25s- target %d\n", bb.first, get_building_observer(bb.first).name,
+			    bb.second);
+		}
 	}
+	assert(persistent_data->remaining_basic_buildings.size() ==
+	       persistent_data->remaining_buildings_size);
+
+	update_player_stat(gametime);
 
 	// Initialise the max duration of a single ship's expedition
 	const uint32_t map_area = uint32_t(map.get_height()) * map.get_width();
@@ -893,6 +1039,18 @@
 		// Current gametime is better then 'kNoExpedition'
 		persistent_data->expedition_start_time = gametime;
 	}
+
+	// just to be sure we have iron mines identified
+	assert(iron_ore_id != INVALID_INDEX);
+
+	productionsites_ratio_ = management_data.get_military_number_at(86) / 10 + 12;
+
+	// Just to be initialized
+	soldier_status_ = SoldiersStatus::kEnough;
+	vacant_mil_positions_average_ = 0;
+	spots_avail.resize(4);
+	trees_nearby_treshold_ = 3 + std::abs(management_data.get_military_number_at(121)) / 2;
+	last_road_dismantled_ = 0;
 }
 
 /**
@@ -1022,27 +1180,66 @@
 }
 
 /// Updates one buildable field
-void DefaultAI::update_buildable_field(BuildableField& field, uint16_t range, bool military) {
+void DefaultAI::update_buildable_field(BuildableField& field) {
 	// look if there is any unowned land nearby
 	Map& map = game().map();
 	const uint32_t gametime = game().get_gametime();
 	FindNodeUnownedWalkable find_unowned_walkable(player_, game());
+	FindEnemyNodeWalkable find_enemy_owned_walkable(player_, game());
+	FindNodeUnownedBuildable find_unowned_buildable(player_, game());
 	FindNodeUnownedMineable find_unowned_mines_pots(player_, game());
+	FindNodeUnownedMineable find_unowned_iron_mines(player_, game(), iron_ore_id);
+	FindNodeAllyOwned find_ally(player_, game(), player_number());
 	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_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;
-	if (AllyOwnedFields > 0) {
+
+	constexpr uint16_t kProductionArea = 6;
+	constexpr uint16_t kBuildableSpotsCheckArea = 10;
+	constexpr uint16_t kEnemyCheckArea = 16;
+	const uint16_t ms_enemy_check_area =
+	   kEnemyCheckArea + std::abs(management_data.get_military_number_at(75)) / 10;
+	constexpr uint16_t kDistantResourcesArea = 20;
+
+	uint16_t actual_enemy_check_area = kEnemyCheckArea;
+	field.is_militarysite = false;
+	if (field.coords.field->get_immovable()) {
+		if (field.coords.field->get_immovable()->descr().type() ==
+		    Widelands::MapObjectType::MILITARYSITE) {
+			field.is_militarysite = true;
+			actual_enemy_check_area = ms_enemy_check_area;
+		}
+	}
+
+	field.unowned_land_nearby = map.find_fields(
+	   Area<FCoords>(field.coords, actual_enemy_check_area), nullptr, find_unowned_walkable);
+
+	field.enemy_owned_land_nearby = map.find_fields(
+	   Area<FCoords>(field.coords, actual_enemy_check_area), nullptr, find_enemy_owned_walkable);
+
+	field.nearest_buildable_spot_nearby = std::numeric_limits<uint16_t>::max();
+	if (field.unowned_land_nearby > 0) {
+		std::vector<Coords> found_buildable_fields;
+
+		field.unowned_buildable_spots_nearby =
+		   map.find_fields(Area<FCoords>(field.coords, kBuildableSpotsCheckArea),
+		                   &found_buildable_fields, find_unowned_buildable);
+		// Now iterate over fields to get nearest one
+		for (auto& coords : found_buildable_fields) {
+			const uint32_t cur_distance = map.calc_distance(coords, field.coords);
+			if (cur_distance < field.nearest_buildable_spot_nearby) {
+				field.nearest_buildable_spot_nearby = cur_distance;
+			}
+		}
+	} else {
+		field.unowned_buildable_spots_nearby = 0;
+	}
+
+	// Is this near the border? Get rid of fields owned by ally
+	if (map.find_fields(Area<FCoords>(field.coords, 3), nullptr, find_ally) ||
+	    map.find_fields(Area<FCoords>(field.coords, 3), nullptr, find_unowned_walkable)) {
 		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;
-		}
+	} else {
+		field.near_border = false;
 	}
 
 	// are we going to count resources now?
@@ -1054,26 +1251,39 @@
 		field.last_resources_check_time = gametime;
 	}
 
-	// to save some CPU
-	if (mines_.size() > 8 && !resource_count_now) {
-		field.unowned_mines_spots_nearby = 0;
-	} else {
-		uint32_t close_mines =
-		   map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_unowned_mines_pots);
+	// testing mines
+	if (resource_count_now) {
+		uint32_t close_mines = map.find_fields(
+		   Area<FCoords>(field.coords, kProductionArea), nullptr, find_unowned_mines_pots);
 		uint32_t distant_mines =
-		   map.find_fields(Area<FCoords>(field.coords, (range + 6 < 14) ? 14 : range + 6), nullptr,
+		   map.find_fields(Area<FCoords>(field.coords, kDistantResourcesArea), nullptr,
+
 		                   find_unowned_mines_pots);
 		distant_mines = distant_mines - close_mines;
 		field.unowned_mines_spots_nearby = 4 * close_mines + distant_mines / 2;
 		if (distant_mines > 0) {
 			field.unowned_mines_spots_nearby += 15;
 		}
+		if (field.unowned_mines_spots_nearby > 0 &&
+		    // for performance considerations we count iron nodes only if we have less than 2 iron
+		    // mines now...
+		    (mines_per_type[iron_ore_id].in_construction + mines_per_type[iron_ore_id].finished) <=
+		       1) {
+			// counting iron mines, if we have less than two iron mines
+			field.unowned_iron_mines_nearby = map.find_fields(
+			   Area<FCoords>(field.coords, kDistantResourcesArea), nullptr, find_unowned_iron_mines);
+		} else {
+			field.unowned_iron_mines_nearby = 0;
+		}
 	}
 
 	// identifying portspace fields
-	if (!field.is_portspace) {  // if we know it, no need to do it once more
+	if (field.is_portspace ==
+	    Widelands::ExtendedBool::kUnset) {  // 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 = ExtendedBool::kTrue;
+		} else {
+			field.is_portspace = ExtendedBool::kFalse;
 		}
 	}
 
@@ -1090,15 +1300,20 @@
 	}
 
 	// testing if a port is nearby, such field will get a priority boost
-	uint16_t nearest_distance = std::numeric_limits<uint16_t>::max();
-	for (const WarehouseSiteObserver& wh_obs : warehousesites) {
-		const uint16_t actual_distance = map.calc_distance(field.coords, wh_obs.site->get_position());
-		nearest_distance = std::min(nearest_distance, actual_distance);
-	}
-	if (nearest_distance < 15) {
-		field.port_nearby = true;
-	} else {
-		field.port_nearby = false;
+	if (resource_count_now) {  // misusing a bit
+		uint16_t nearest_distance = std::numeric_limits<uint16_t>::max();
+		for (const WarehouseSiteObserver& wh_obs : warehousesites) {
+			if (wh_obs.bo->is(BuildingAttribute::kPort)) {
+				const uint16_t actual_distance =
+				   map.calc_distance(field.coords, wh_obs.site->get_position());
+				nearest_distance = std::min(nearest_distance, actual_distance);
+			}
+		}
+		if (nearest_distance < 15) {
+			field.port_nearby = true;
+		} else {
+			field.port_nearby = false;
+		}
 	}
 
 	// testing fields in radius 1 to find biggest buildcaps.
@@ -1115,119 +1330,63 @@
 
 	assert((player_->get_buildcaps(field.coords) & BUILDCAPS_SIZEMASK) <= field.max_buildcap_nearby);
 
-	// collect information about resources in the area
-	std::vector<ImmovableFound> immovables;
-	// Search in a radius of range
-	map.find_immovables(Area<FCoords>(field.coords, range), &immovables);
-
-	// Is this a general update or just for military consideration
-	// (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.unconnected_nearby = false;
-		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> resource_list;
-		std::vector<Bob*> critters_list;
-
-		if (field.water_nearby == kUncalculated) {
-			assert(field.open_water_nearby == kUncalculated);
-
-			FindNodeWater find_water(game().world());
-			field.water_nearby = map.find_fields(Area<FCoords>(field.coords, 5), nullptr, find_water);
-
-			if (field.water_nearby > 0) {
-				FindNodeOpenWater find_open_water(game().world());
-				field.open_water_nearby =
-				   map.find_fields(Area<FCoords>(field.coords, 5), nullptr, find_open_water);
-			}
-
-			if (resource_necessity_water_needed_) {  // for atlanteans
-				field.distant_water =
-				   map.find_fields(Area<FCoords>(field.coords, 14), nullptr, find_water) -
-				   field.water_nearby;
-				assert(field.open_water_nearby <= field.water_nearby);
-			}
-		}
-
-		// counting fields with fish
-		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();
-		}
-
-		// 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();
-		}
-
-		FCoords fse;
-		map.get_neighbour(field.coords, WALK_SE, &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;
-			}
-		}
-
-		for (uint32_t i = 0; i < immovables.size(); ++i) {
-			const BaseImmovable& base_immovable = *immovables.at(i).object;
-
-			if (upcast(PlayerImmovable const, player_immovable, &base_immovable)) {
-
-				// TODO(unknown): Only continue; if this is an opposing site
-				// 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;
-					}
-
-					continue;
-				}
-				// here we identify the buiding (including expected building if constructionsite)
-				// and calculate some statistics about nearby buildings
-				if (upcast(ProductionSite const, productionsite, player_immovable)) {
-					BuildingObserver& bo = get_building_observer(productionsite->descr().name().c_str());
-					consider_productionsite_influence(field, immovables.at(i).coords, bo);
-				}
-				if (upcast(ConstructionSite const, constructionsite, player_immovable)) {
-					const BuildingDescr& target_descr = constructionsite->building();
-					BuildingObserver& bo = get_building_observer(target_descr.name().c_str());
-					consider_productionsite_influence(field, immovables.at(i).coords, bo);
-				}
-			}
-
-			if (immovables.at(i).object->has_attribute(tree_attr)) {
-				++field.trees_nearby;
-			}
-		}
+	// Testing surface water (once only)
+	// TODO(GunChleoc): We can change the terrain by scripting, so we should work with notifications
+	// here.
+	// Let's leave this as it is for now for performance reasons - terrain change of water is
+	// currently only
+	// used in the Atlantean scenario.
+	if (field.water_nearby == kUncalculated) {
+		assert(field.open_water_nearby == kUncalculated);
+
+		FindNodeWater find_water(game().world());
+		field.water_nearby =
+		   map.find_fields(Area<FCoords>(field.coords, kProductionArea), nullptr, find_water);
+
+		if (field.water_nearby > 0) {
+			FindNodeOpenWater find_open_water(game().world());
+			field.open_water_nearby =
+			   map.find_fields(Area<FCoords>(field.coords, kProductionArea), nullptr, find_open_water);
+		}
+
+		if (resource_necessity_water_needed_) {  // for atlanteans
+			field.distant_water = map.find_fields(Area<FCoords>(field.coords, kDistantResourcesArea),
+			                                      nullptr, find_water) -
+			                      field.water_nearby;
+			assert(field.open_water_nearby <= field.water_nearby);
+		}
+	}
+
+	FCoords fse;
+	map.get_neighbour(field.coords, WALK_SE, &fse);
+	field.preferred = false;
+	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;
+		}
+	}
+
+	// counting fields with fish
+	if (field.water_nearby > 0 && (field.fish_nearby == kUncalculated || resource_count_now)) {
+		field.fish_nearby = map.find_fields(Area<FCoords>(field.coords, kProductionArea), nullptr,
+		                                    FindNodeResource(world.get_resource("fish")));
+	}
+
+	// Counting resources that do not change fast
+	if (resource_count_now) {
+		// Counting fields with critters (game)
+		field.critters_nearby =
+		   map.find_bobs(Area<FCoords>(field.coords, kProductionArea), nullptr, FindBobCritter());
 
 		// Rocks are not renewable, we will count them only if previous state is nonzero
-		if (field.rocks_nearby > 0 && resource_count_now) {
-
-			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;
+		if (field.rocks_nearby > 0) {
+			field.rocks_nearby = map.find_immovables(
+			   Area<FCoords>(map.get_fcoords(field.coords), kProductionArea), nullptr,
+			   FindImmovableAttribute(MapObjectDescr::get_attribute_id("rocks")));
+
+			// adding 5 if rocks found
+			field.rocks_nearby = (field.rocks_nearby > 0) ? field.rocks_nearby + 2 : 0;
 		}
 
 		// ground water is not renewable and its amount can only fall, we will count them only if
@@ -1235,47 +1394,136 @@
 		if (field.ground_water > 0) {
 			field.ground_water = field.coords.field->get_resources_amount();
 		}
-	}
-
-	// The following is done always (regardless of military or not)
-
-	// We get immovables with higher radius
-	immovables.clear();
-	map.find_immovables(Area<FCoords>(field.coords, (range < 11) ? 11 : range), &immovables);
+
+		// Counting trees nearby
+		int32_t const tree_attr = MapObjectDescr::get_attribute_id("tree");
+		field.trees_nearby =
+		   map.find_immovables(Area<FCoords>(map.get_fcoords(field.coords), kProductionArea), nullptr,
+		                       FindImmovableAttribute(tree_attr));
+	}
+
+	// resetting some values
+	field.enemy_nearby =
+	   (field.enemy_owned_land_nearby > std::abs(management_data.get_military_number_at(41) / 4)) ?
+	      true :
+	      false;
+	if (field.enemy_owned_land_nearby == 0) {
+		assert(!field.enemy_nearby);
+	}
+
+	// resetting a bunch of values for the field
+	field.ally_military_presence = 0;
+	field.area_military_capacity = 0;
+	field.consumers_nearby.clear();
+	field.consumers_nearby.resize(wares.size());
+	field.enemy_military_presence = 0;
+	field.enemy_military_sites = 0;
+	field.enemy_wh_nearby = false;
+	field.military_in_constr_nearby = 0;
+	field.military_loneliness = 1000;
 	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.own_military_presence = 0;
+	field.own_non_military_nearby = 0;
+	field.producers_nearby.clear();
+	field.producers_nearby.resize(wares.size());
+	field.rangers_nearby = 0;
+	field.space_consumers_nearby = 0;
+	field.supporters_nearby.clear();
+	field.supporters_nearby.resize(wares.size());
 	field.unconnected_nearby = false;
 
+	// collect information about productionsites nearby
+	std::vector<ImmovableFound> immovables;
+	// Search in a radius of range
+	map.find_immovables(Area<FCoords>(field.coords, kProductionArea + 2), &immovables);
+
+	// function seems to return duplicates, so we will use serial numbers to filter them out
+	std::set<uint32_t> unique_serials;
+
+	for (uint32_t i = 0; i < immovables.size(); ++i) {
+		const BaseImmovable& base_immovable = *immovables.at(i).object;
+		if (!unique_serials.insert(base_immovable.serial()).second) {
+			continue;  // serial was not inserted in the set, so this is a duplicate
+		}
+
+		if (upcast(PlayerImmovable const, player_immovable, &base_immovable)) {
+
+			// TODO(unknown): Only continue if this is an opposing site
+			// allied sites should be counted for military influence
+			if (player_immovable->owner().player_number() != pn) {
+				continue;
+			}
+			// here we identify the buiding (including expected building if constructionsite)
+			// and calculate some statistics about nearby buildings
+			if (player_immovable->descr().type() == MapObjectType::PRODUCTIONSITE) {
+				BuildingObserver& bo = get_building_observer(player_immovable->descr().name().c_str());
+				consider_productionsite_influence(field, immovables.at(i).coords, bo);
+			} else if (upcast(ConstructionSite const, constructionsite, player_immovable)) {
+				const BuildingDescr& target_descr = constructionsite->building();
+				BuildingObserver& bo = get_building_observer(target_descr.name().c_str());
+				consider_productionsite_influence(field, immovables.at(i).coords, bo);
+			}
+		}
+	}
+
+	// Now testing military aspects
+	immovables.clear();
+	map.find_immovables(Area<FCoords>(field.coords, actual_enemy_check_area), &immovables);
+
 	// We are interested in unconnected immovables, but we must be also close to connected ones
 	bool any_connected_imm = false;
 	bool any_unconnected_imm = false;
+	unique_serials.clear();
 
 	for (uint32_t i = 0; i < immovables.size(); ++i) {
-
 		const BaseImmovable& base_immovable = *immovables.at(i).object;
 
-		// testing if it is enemy-owned field
-		// TODO(unknown): count such fields...
-		if (upcast(PlayerImmovable const, player_immovable, &base_immovable)) {
-
-			// TODO(unknown): Only continue; if this is an opposing site
-			// 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;
-				}
-				continue;
-			}
+		if (!unique_serials.insert(base_immovable.serial()).second) {
+			continue;  // serial was not inserted in the set, so this is duplicate
 		}
 
-		// if we are here, immovable is ours
+		// testing if immovable is owned by someone else and collecting some statistics
 		if (upcast(Building const, building, &base_immovable)) {
 
-			// connected to warehouse
+			const PlayerNumber bpn = building->owner().player_number();
+			if (player_statistics.get_is_enemy(bpn)) {  // owned by enemy
+				assert(!player_statistics.players_in_same_team(bpn, pn));
+				field.enemy_nearby = true;
+				if (upcast(MilitarySite const, militarysite, building)) {
+					field.enemy_military_presence +=
+					   militarysite->soldier_control()->stationed_soldiers().size();
+					++field.enemy_military_sites;
+				}
+				if (upcast(ConstructionSite const, constructionsite, building)) {
+					const BuildingDescr& target_descr = constructionsite->building();
+					if (target_descr.type() == MapObjectType::MILITARYSITE) {
+						++field.enemy_military_sites;
+					}
+				}
+
+				// Warehouses are counted here too as they can host soldiers as well
+				if (upcast(Warehouse const, warehouse, building)) {
+					field.enemy_military_presence +=
+					   warehouse->soldier_control()->stationed_soldiers().size();
+					++field.enemy_military_sites;
+					field.enemy_wh_nearby = true;
+					enemy_warehouses.insert(building->get_position().hash());
+				}
+				continue;
+			} else if (bpn != pn) {  // it is an ally
+				assert(!player_statistics.get_is_enemy(bpn));
+				if (upcast(MilitarySite const, militarysite, building)) {
+					field.ally_military_presence +=
+					   militarysite->soldier_control()->stationed_soldiers().size();
+				}
+				continue;
+			}
+
+			// if we are here, the immovable is ours
+			assert(building->owner().player_number() == pn);
+
+			// connected to a warehouse
 			bool connected = !building->get_economy()->warehouses().empty();
 			if (connected) {
 				any_connected_imm = true;
@@ -1297,7 +1545,7 @@
 					}
 				}
 			} else if (!connected) {
-				// we dont care about unconnected constructionsites
+				// we don't care about unconnected constructionsites
 				any_unconnected_imm = true;
 			}
 
@@ -1308,7 +1556,7 @@
 				if (radius > dist) {
 					field.area_military_capacity +=
 					   militarysite->soldier_control()->max_soldier_capacity();
-					field.area_military_presence +=
+					field.own_military_presence +=
 					   militarysite->soldier_control()->stationed_soldiers().size();
 
 					if (militarysite->soldier_control()->stationed_soldiers().empty()) {
@@ -1321,12 +1569,241 @@
 						field.military_loneliness *= static_cast<double_t>(dist) / radius;
 					}
 				}
+			} else {
+				++field.own_non_military_nearby;
 			}
 		}
 	}
+
+	assert(field.military_loneliness <= 1000);
+
 	if (any_unconnected_imm && any_connected_imm && field.military_in_constr_nearby == 0) {
 		field.unconnected_nearby = true;
 	}
+
+	// if there is a militarysite on the field, we try to walk to enemy
+	field.enemy_accessible_ = false;
+	field.local_soldier_capacity = 0;
+	if (field.is_militarysite) {
+		if (upcast(MilitarySite, ms, field.coords.field->get_immovable())) {
+			if (field.enemy_nearby) {
+				uint32_t unused1 = 0;
+				uint16_t unused2 = 0;
+				field.enemy_accessible_ = other_player_accessible(
+				   actual_enemy_check_area + 3, &unused1, &unused2, field.coords, WalkSearch::kEnemy);
+			}
+			field.local_soldier_capacity = ms->soldier_control()->max_soldier_capacity();
+			field.is_militarysite = true;
+		} else {
+			NEVER_HERE();
+		}
+	}
+
+	// Calculating field score
+	field.military_score_ = 0;
+	field.inland = false;
+
+	if (!(field.enemy_nearby || field.near_border)) {
+		field.inland = true;
+	}
+
+	const uint8_t score_parts_size = 55;
+	int32_t score_parts[score_parts_size] = {0};
+	if (field.enemy_owned_land_nearby) {
+		score_parts[0] = 3 *
+		                 management_data.neuron_pool[73].get_result_safe(
+		                    field.enemy_owned_land_nearby / 5, kAbsValue);
+		score_parts[1] =
+		   3 *
+		   management_data.neuron_pool[76].get_result_safe(field.enemy_owned_land_nearby, kAbsValue);
+		score_parts[2] = 3 *
+		                 management_data.neuron_pool[54].get_result_safe(
+		                    field.enemy_military_presence * 2, kAbsValue);
+		score_parts[3] = 3 *
+		                 management_data.neuron_pool[61].get_result_safe(
+		                    field.enemy_military_presence / 3, kAbsValue);
+		score_parts[4] =
+		   (!field.enemy_accessible_) ? (-100 + management_data.get_military_number_at(55)) : 0;
+		score_parts[5] =
+		   2 *
+		   management_data.neuron_pool[50].get_result_safe(field.enemy_owned_land_nearby, kAbsValue);
+
+		score_parts[6] =
+		   field.enemy_military_sites * std::abs(management_data.get_military_number_at(67) / 2);
+		score_parts[7] =
+		   2 *
+		   management_data.neuron_pool[34].get_result_safe(field.enemy_military_sites * 2, kAbsValue);
+		score_parts[8] = management_data.neuron_pool[56].get_result_safe(
+		   field.enemy_military_presence * 2, kAbsValue);
+
+		score_parts[9] = management_data.neuron_pool[65].get_result_safe(
+		   (field.unowned_land_nearby + field.enemy_owned_land_nearby) / 2, kAbsValue);
+		score_parts[10] = (field.enemy_accessible_) ? management_data.get_military_number_at(80) : 0;
+
+		score_parts[11] =
+		   -3 *
+		   management_data.neuron_pool[8].get_result_safe(
+		      (field.military_in_constr_nearby + field.military_unstationed) * 3, kAbsValue);
+		score_parts[12] =
+		   -3 *
+		   management_data.neuron_pool[74].get_result_safe(
+		      (field.military_in_constr_nearby + field.military_unstationed) * 5, kAbsValue);
+		score_parts[13] = ((field.military_in_constr_nearby + field.military_unstationed) > 0) ?
+		                     -std::abs(management_data.get_military_number_at(32)) :
+		                     0;
+		score_parts[14] = -1 * (field.military_in_constr_nearby + field.military_unstationed) *
+		                  std::abs(management_data.get_military_number_at(12));
+
+		score_parts[15] =
+		   -2 * management_data.neuron_pool[75].get_result_safe(field.own_military_presence);
+		score_parts[16] = -5 * std::min<int16_t>(field.area_military_capacity, 20);
+		score_parts[17] = 3 * management_data.get_military_number_at(28);
+		score_parts[18] =
+		   (field.enemy_nearby) ? 3 * std::abs(management_data.get_military_number_at(68)) : 0;
+		score_parts[19] =
+		   (field.enemy_wh_nearby) ? 3 * std::abs(management_data.get_military_number_at(132)) : 0;
+		score_parts[58] = (field.enemy_wh_nearby) ?
+		                     std::abs(management_data.get_military_number_at(135)) :
+		                     -std::abs(management_data.get_military_number_at(135));
+
+	} else {  // for expansion or inner land
+
+		score_parts[20] = management_data.neuron_pool[22].get_result_safe(
+		   (field.unowned_mines_spots_nearby + 2) / 3, kAbsValue);
+		score_parts[21] = (field.unowned_mines_spots_nearby > 0) ?
+		                     std::abs(management_data.get_military_number_at(58)) :
+		                     0;
+		if (expansion_type.get_expansion_type() == ExpansionMode::kResources) {
+			score_parts[23] = 2 *
+			                  management_data.neuron_pool[78].get_result_safe(
+			                     (field.unowned_mines_spots_nearby + 2) / 3, kAbsValue);
+		}
+
+		score_parts[24] =
+		   (field.unowned_land_nearby) ?
+		      management_data.neuron_pool[25].get_result_safe(field.water_nearby / 2, kAbsValue) :
+		      0;
+		score_parts[25] =
+		   (field.unowned_land_nearby) ?
+		      management_data.neuron_pool[27].get_result_safe(field.trees_nearby / 2, kAbsValue) :
+		      0;
+
+		if (resource_necessity_water_needed_) {
+			score_parts[26] =
+			   (field.unowned_land_nearby) ?
+			      management_data.neuron_pool[15].get_result_safe(field.water_nearby, kAbsValue) :
+			      0;
+			score_parts[27] =
+			   resource_necessity_water_needed_ *
+			   management_data.neuron_pool[17].get_result_safe(field.distant_water, kAbsValue) / 100;
+		}
+		score_parts[28] =
+		   (field.unowned_land_nearby) ?
+		      management_data.neuron_pool[33].get_result_safe(field.water_nearby, kAbsValue) :
+		      0;
+		score_parts[29] =
+		   management_data.neuron_pool[10].get_result_safe(field.military_loneliness / 50, kAbsValue);
+
+		score_parts[30] =
+		   -10 *
+		   management_data.neuron_pool[8].get_result_safe(
+		      3 * (field.military_in_constr_nearby + field.military_unstationed), kAbsValue);
+		score_parts[31] =
+		   -10 *
+		   management_data.neuron_pool[31].get_result_safe(
+		      3 * (field.military_in_constr_nearby + field.military_unstationed), kAbsValue);
+		score_parts[32] = -4 * field.military_in_constr_nearby *
+		                  std::abs(management_data.get_military_number_at(82));
+		score_parts[33] = (field.military_in_constr_nearby > 0) ?
+		                     -5 * management_data.get_military_number_at(85) :
+		                     0;
+
+		score_parts[34] = -1 *
+		                  management_data.neuron_pool[4].get_result_safe(
+		                     (field.area_military_capacity + 4) / 5, kAbsValue);
+		score_parts[35] = 3 * management_data.get_military_number_at(133);
+
+		if (expansion_type.get_expansion_type() == ExpansionMode::kEconomy) {
+			score_parts[36] = -100 - 4 * std::abs(management_data.get_military_number_at(139));
+		} else if (expansion_type.get_expansion_type() == ExpansionMode::kResources ||
+		           expansion_type.get_expansion_type() == ExpansionMode::kSpace) {
+			score_parts[37] =
+			   +100 + 4 * std::abs(management_data.get_military_number_at(139));  // The same as above
+		}
+		if (msites_in_constr() > 0 && field.max_buildcap_nearby == BUILDCAPS_BIG &&
+		    spots_avail.at(BUILDCAPS_BIG) <= 2) {
+			score_parts[57] = -10 * std::abs(management_data.get_military_number_at(54));
+		}
+	}
+
+	// common inputs
+	if (field.unowned_iron_mines_nearby > 0 && ((mines_per_type[iron_ore_id].in_construction +
+	                                             mines_per_type[iron_ore_id].finished) == 0)) {
+		score_parts[40] = field.unowned_iron_mines_nearby *
+		                  std::abs(management_data.get_military_number_at(92)) / 50;
+	}
+	if (field.unowned_iron_mines_nearby && ((mines_per_type[iron_ore_id].in_construction +
+	                                         mines_per_type[iron_ore_id].finished) <= 1)) {
+		score_parts[41] = 3 * std::abs(management_data.get_military_number_at(93));
+	}
+
+	score_parts[42] =
+	   (field.unowned_land_nearby) ?
+	      management_data.neuron_pool[18].get_result_safe(field.own_non_military_nearby, kAbsValue) :
+	      0;
+
+	score_parts[43] = 2 *
+	                  management_data.neuron_pool[11].get_result_safe(
+	                     field.unowned_buildable_spots_nearby, kAbsValue);
+	score_parts[44] =
+	   management_data.neuron_pool[12].get_result_safe(field.unowned_mines_spots_nearby, kAbsValue);
+	score_parts[45] =
+	   (field.unowned_land_nearby) ?
+	      field.military_loneliness * std::abs(management_data.get_military_number_at(53)) / 800 :
+	      0;
+
+	score_parts[46] =
+	   -1 * management_data.neuron_pool[55].get_result_safe(field.ally_military_presence, kAbsValue);
+	score_parts[47] =
+	   -1 *
+	   management_data.neuron_pool[53].get_result_safe(2 * field.ally_military_presence, kAbsValue);
+	score_parts[48] = -2 *
+	                  management_data.neuron_pool[4].get_result_safe(
+	                     (field.area_military_capacity + 4) / 5, kAbsValue);
+	score_parts[49] = ((field.military_in_constr_nearby + field.military_unstationed) > 0) ?
+	                     -std::abs(management_data.get_military_number_at(81)) :
+	                     0;
+	score_parts[55] = (field.military_loneliness < 10) ?
+	                     2 * std::abs(management_data.get_military_number_at(141)) :
+	                     0;
+	score_parts[56] =
+	   (any_unconnected_imm) ? 2 * std::abs(management_data.get_military_number_at(23)) : 0;
+
+	for (uint16_t i = 0; i < score_parts_size; i++) {
+		field.military_score_ += score_parts[i];
+	}
+
+	if (kAITrainingMode) {
+		if (field.military_score_ < -5000 || field.military_score_ > 2000) {
+			log("Warning field.military_score_ %5d, compounds: ", field.military_score_);
+			for (uint16_t i = 0; i < score_parts_size; i++) {
+				log("%d, ", score_parts[i]);
+			}
+			log("\n");
+		}
+	}
+
+	// is new site allowed at all here?
+	field.defense_msite_allowed = false;
+	int16_t multiplicator = 10;
+	if (soldier_status_ == SoldiersStatus::kBadShortage) {
+		multiplicator = 4;
+	} else if (soldier_status_ == SoldiersStatus::kShortage) {
+		multiplicator = 7;
+	}
+	if (field.area_military_capacity < field.enemy_military_presence * multiplicator / 10) {
+		field.defense_msite_allowed = true;
+	}
 }
 
 /// Updates one mineable field
@@ -1378,7 +1855,6 @@
 
 /// Updates the production and MINE sites statistics needed for construction decision.
 void DefaultAI::update_productionsite_stats() {
-	uint16_t fishers_count = 0;  // used for atlanteans only
 
 	// Reset statistics for all buildings
 	for (uint32_t i = 0; i < buildings_.size(); ++i) {
@@ -1400,11 +1876,6 @@
 			productionsites.front().bo->current_stats +=
 			   productionsites.front().site->get_crude_statistics();
 
-			// counting fishers
-			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;
@@ -1418,16 +1889,6 @@
 		productionsites.pop_front();
 	}
 
-	if (resource_necessity_water_needed_) {
-		if (fishers_count == 0) {
-			resource_necessity_water_ = 100;
-		} else if (fishers_count == 1) {
-			resource_necessity_water_ = 50;
-		} else {
-			resource_necessity_water_ = 10;
-		}
-	}
-
 	// for mines_ also
 	// Check all available mines
 	for (uint32_t i = 0; i < mines_.size(); ++i) {
@@ -1467,29 +1928,23 @@
 //   is built.
 // * Buildings are split into categories
 // * The logic is complex but approximately:
-// - buildings producing building material are preferred
-// - buildings identified as basic are preferred
+// - some buildings belong to "basic economy" - these are preferred
+// - some small huts are exempt from basic economy logic
 // - first bulding of a type is preferred
-// - buildings identified as 'direct food supplier' are built after 15 min.
-//   from game start
-// - if a building is upgradeable, second building is also preferred
-//   (there should be no upgrade when there are not two buildings of the same type)
 // - algorithm is trying to take into account actual utlization of buildings
 //   (the one shown in GUI/game is not reliable, it calculates own statistics)
-// * military buildings have own strategy, split into two situations:
-// - there is no enemy
-// - there is an enemy
+// * military buildings use genetic algorithm logic to score fields
 //   Currently more military buildings are built than needed
-//   and "optimization" (dismantling not needed buildings) is done afterwards
+//   so there are always some vacant positions
 bool DefaultAI::construct_building(uint32_t gametime) {
 	if (buildable_fields.empty()) {
 		return false;
 	}
+
 	// Just used for easy checking whether a mine or something else was built.
 	bool mine = false;
 	uint32_t consumers_nearby_count = 0;
-	std::vector<int32_t> spots_avail;
-	spots_avail.resize(4);
+
 	Map& map = game().map();
 
 	for (int32_t i = 0; i < 4; ++i)
@@ -1503,9 +1958,6 @@
 	spots_ += spots_avail.at(BUILDCAPS_MEDIUM);
 	spots_ += spots_avail.at(BUILDCAPS_BIG);
 
-	// here we possible stop building of new buildings
-	new_buildings_stop_ = false;
-
 	// helper variable - we need some proportion of free spots vs productionsites
 	// the proportion depends on size of economy
 	// this proportion defines how dense the buildings will be
@@ -1522,8 +1974,22 @@
 	}
 	const bool has_enough_space = (spots_ > needed_spots);
 
-	// This is a replacement for simple count of mines
-	const int32_t virtual_mines = mines_.size() + mineable_fields.size() / 25;
+	// Do we have basic economy established? Informing that we just left the basic economy mode.
+	if (!basic_economy_established && persistent_data->remaining_basic_buildings.empty()) {
+		log("%2d: Player has achieved the basic economy at %s\n", player_number(),
+		    gamestring_with_leading_zeros(gametime));
+		basic_economy_established = true;
+		assert(persistent_data->remaining_buildings_size == 0);
+	}
+
+	if (!basic_economy_established && player_statistics.any_enemy_seen_lately(gametime) &&
+	    management_data.f_neuron_pool[17].get_position(0)) {
+		log("%2d: Player has not all buildings for basic economy yet (%lu missing), but enemy is "
+		    "nearby, so quitting the mode at %s\n",
+		    player_number(), persistent_data->remaining_basic_buildings.size(),
+		    gamestring_with_leading_zeros(gametime));
+		basic_economy_established = true;
+	}
 
 	// *_military_scores are used as minimal score for a new military building
 	// to be built. As AI does not traverse all building fields at once, these thresholds
@@ -1534,102 +2000,210 @@
 	// score) and quickly falling down until it reaches the least_military_score
 	// this one (=target_military_score) is actually used to decide if building&field is allowed
 	// candidate
-	// least_military_score is allowed to get bellow 100 only if there is no military site in
-	// construction
-	// right now in order to (try to) avoid expansion lockup
-
-	// Bools below are helpers to improve readability of code
-
-	// It is bit complicated balance building militarysites and productionsites so this is small hack
-	// to help
-	// it
-	bool needs_boost_economy = false;
-	if (highest_nonmil_prio_ > 10 && has_enough_space && virtual_mines >= 5) {
-		needs_boost_economy = true;
-	}
+
+	const PlayerNumber pn = player_number();
+
+	// Genetic algorithm is used here
+	bool inputs[2 * kFNeuronBitSize] = {0};
+	inputs[0] = (pow(msites_in_constr(), 2) > militarysites.size() + 2);
+	inputs[1] = !(pow(msites_in_constr(), 2) > militarysites.size() + 2);
+	inputs[2] =
+	   (highest_nonmil_prio_ > 18 + std::abs(management_data.get_military_number_at(29) / 10));
+	inputs[3] =
+	   !(highest_nonmil_prio_ > 18 + std::abs(management_data.get_military_number_at(29) / 10));
+	inputs[4] = (highest_nonmil_prio_ > 18 + std::abs(management_data.get_military_number_at(48)));
+	inputs[5] = !(highest_nonmil_prio_ > 18 + std::abs(management_data.get_military_number_at(49)));
+	inputs[6] = ((numof_psites_in_constr + mines_in_constr()) >
+	             (productionsites.size() + mines_built()) / productionsites_ratio_);
+	inputs[7] = !((numof_psites_in_constr + mines_in_constr()) >
+	              (productionsites.size() + mines_built()) / productionsites_ratio_);
+
+	inputs[8] = (has_enough_space);
+	inputs[9] = !(has_enough_space);
+	inputs[10] = (has_enough_space);
+	inputs[11] = !(has_enough_space);
+
+	inputs[12] = (gametime > 45 * 60 * 1000);
+	inputs[13] = !(gametime > 45 * 60 * 1000);
+
+	inputs[14] = (expansion_type.get_expansion_type() == ExpansionMode::kEconomy);
+	inputs[15] = !(expansion_type.get_expansion_type() == ExpansionMode::kEconomy);
+	inputs[16] = (expansion_type.get_expansion_type() == ExpansionMode::kSpace);
+	inputs[17] = !(expansion_type.get_expansion_type() == ExpansionMode::kSpace);
+
+	inputs[18] = (player_statistics.any_enemy_seen_lately(gametime));
+	inputs[19] = !(player_statistics.any_enemy_seen_lately(gametime));
+	inputs[20] = (player_statistics.get_player_power(pn) >
+	              player_statistics.get_old60_player_power(pn) +
+	                 std::abs(management_data.get_military_number_at(130)) / 10);
+	inputs[21] = !(player_statistics.get_player_power(pn) >
+	               player_statistics.get_old60_player_power(pn) +
+	                  std::abs(management_data.get_military_number_at(131)) / 10);
+	inputs[22] =
+	   (player_statistics.get_player_power(pn) > player_statistics.get_old_player_power(pn));
+	inputs[23] =
+	   !(player_statistics.get_player_power(pn) > player_statistics.get_old_player_power(pn));
+	inputs[24] = (highest_nonmil_prio_ > 18 + management_data.get_military_number_at(65) / 10);
+	inputs[25] = !(highest_nonmil_prio_ > 18 + management_data.get_military_number_at(65) / 10);
+	inputs[26] = (player_statistics.get_modified_player_power(pn) >
+	              player_statistics.get_visible_enemies_power(pn));
+	inputs[27] = (player_statistics.get_modified_player_power(pn) <=
+	              player_statistics.get_visible_enemies_power(pn));
+	inputs[28] =
+	   (player_statistics.get_player_power(pn) > player_statistics.get_enemies_average_power());
+	inputs[29] =
+	   !(player_statistics.get_player_power(pn) > player_statistics.get_enemies_average_power());
+	inputs[30] =
+	   (player_statistics.get_player_power(pn) > player_statistics.get_enemies_max_power());
+	inputs[31] =
+	   !(player_statistics.get_player_power(pn) > player_statistics.get_enemies_max_power());
+
+	inputs[32] = (persistent_data->least_military_score <
+	              persistent_data->ai_personality_mil_upper_limit *
+	                 std::abs(management_data.get_military_number_at(69)) / 100);
+	inputs[33] = !(persistent_data->least_military_score <
+	               persistent_data->ai_personality_mil_upper_limit *
+	                  std::abs(management_data.get_military_number_at(69)) / 100);
+	inputs[34] = player_statistics.strong_enough(pn);
+	inputs[35] = !player_statistics.strong_enough(pn);
+
+	inputs[36] = (player_statistics.get_player_land(pn) < 500);
+	inputs[37] = (player_statistics.get_player_land(pn) < 700);
+	inputs[38] = (player_statistics.get_player_land(pn) < 900);
+	inputs[39] = (player_statistics.get_player_land(pn) < 1100);
+	inputs[40] = (player_statistics.get_player_land(pn) > 500);
+	inputs[41] = (player_statistics.get_player_land(pn) > 700);
+	inputs[42] = (player_statistics.get_player_land(pn) > 900);
+	inputs[43] = (player_statistics.get_player_land(pn) > 1100);
+	inputs[44] = (player_statistics.get_player_power(pn) >
+	              player_statistics.get_old60_player_power(pn) +
+	                 std::abs(management_data.get_military_number_at(130)) / 10);
+	inputs[45] = !(player_statistics.get_player_power(pn) >
+	               player_statistics.get_old60_player_power(pn) +
+	                  std::abs(management_data.get_military_number_at(131)) / 10);
+	inputs[46] =
+	   (player_statistics.get_player_power(pn) > player_statistics.get_old_player_power(pn));
+	inputs[47] =
+	   !(player_statistics.get_player_power(pn) > player_statistics.get_old_player_power(pn));
+	inputs[48] = (bakeries_count_ == 0);
+	inputs[49] = (bakeries_count_ <= 1);
+	inputs[50] = (bakeries_count_ <= 1);
+	inputs[51] = (numof_psites_in_constr > 8);
+	inputs[52] = (numof_psites_in_constr < 8);
+
+	int16_t needs_boost_economy_score = management_data.get_military_number_at(61) / 5;
+	int16_t increase_score_limit_score = 0;
+
+	for (uint8_t i = 0; i < kFNeuronBitSize; ++i) {
+		if (management_data.f_neuron_pool[51].get_position(i)) {
+			needs_boost_economy_score += (inputs[i]) ? 1 : -1;
+		}
+		if (management_data.f_neuron_pool[52].get_position(i)) {
+			increase_score_limit_score += (inputs[i]) ? 1 : -1;
+		}
+		if (management_data.f_neuron_pool[21].get_position(i)) {
+			needs_boost_economy_score += (inputs[kFNeuronBitSize + i]) ? 1 : -1;
+		}
+		if (management_data.f_neuron_pool[22].get_position(i)) {
+			increase_score_limit_score += (inputs[kFNeuronBitSize + i]) ? 1 : -1;
+		}
+	}
+
+	// Finding expansion policy
+	// Do we need basic resources?
+	// This is a replacement for simple count of mines
+	const int32_t virtual_mines = mines_.size() + mineable_fields.size() / 15;
+	const bool needs_fishers = resource_necessity_water_needed_ && fishers_count_ < 1;
+
+	if (virtual_mines < 4 || mines_per_type[iron_ore_id].total_count() < 1 || needs_fishers) {
+		expansion_type.set_expantion_type(ExpansionMode::kResources);
+	} else {
+		// now we must decide if we go after spots or economy boost
+		if (needs_boost_economy_score >= 3) {
+			expansion_type.set_expantion_type(ExpansionMode::kEconomy);
+		} else if (needs_boost_economy_score >= -2) {
+			expansion_type.set_expantion_type(ExpansionMode::kBoth);
+		} else {
+			expansion_type.set_expantion_type(ExpansionMode::kSpace);
+		}
+	}
+
+	const bool increase_least_score_limit =
+	   (increase_score_limit_score > management_data.get_military_number_at(45) / 5);
+
+	uint16_t concurent_ms_in_constr_no_enemy = 1;
+	uint16_t concurent_ms_in_constr_enemy_nearby = 2;
 
 	// resetting highest_nonmil_prio_ so it can be recalculated anew
 	highest_nonmil_prio_ = 0;
 
-	const bool too_many_ms_constructionsites =
-	   (pow(msites_in_constr(), 2) > militarysites.size() + 2);
-	const bool too_many_vacant_mil =
-	   (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
-	if (too_many_ms_constructionsites || too_many_vacant_mil || needs_boost_economy) {
+	if (increase_least_score_limit) {
 		if (persistent_data->least_military_score <
-		    kUpperLimit) {  // No sense in letting it grow too high
+		    persistent_data
+		       ->ai_personality_mil_upper_limit) {  // No sense in letting it grow too high
 			persistent_data->least_military_score += 20;
+			if (persistent_data->least_military_score > persistent_data->target_military_score) {
+				persistent_data->target_military_score = persistent_data->least_military_score;
+			}
+			if (persistent_data->target_military_score >
+			    persistent_data->ai_personality_mil_upper_limit) {
+				persistent_data->ai_personality_mil_upper_limit =
+				   persistent_data->target_military_score;
+			}
 		}
 	} else {
+
+		uint16_t divider = 1;  // this is to slow down decrementing the least military score
+		switch (expansion_type.get_expansion_type()) {
+		case ExpansionMode::kEconomy:
+			divider = 3;
+			break;
+		case ExpansionMode::kBoth:
+			divider = 2;
+			break;
+		default:
+			divider = 1;
+		}
+
 		// least_military_score is decreased, but depending on the size of territory
 		switch (static_cast<uint32_t>(log10(buildable_fields.size()))) {
 		case 0:
-			persistent_data->least_military_score -= 10;
+			persistent_data->least_military_score -= 10 / divider;
 			break;
 		case 1:
-			persistent_data->least_military_score -= 8;
+			persistent_data->least_military_score -= 8 / divider;
 			break;
 		case 2:
-			persistent_data->least_military_score -= 5;
+			persistent_data->least_military_score -= 5 / divider;
 			break;
 		case 3:
-			persistent_data->least_military_score -= 3;
+			persistent_data->least_military_score -= 3 / divider;
 			break;
 		default:
-			persistent_data->least_military_score -= 2;
-		}
-		// do not get bellow kBottomLimit if there is at least one ms in construction
-		if ((msites_in_constr() > 0 || too_many_vacant_mil) &&
-		    persistent_data->least_military_score < kBottomLimit) {
-			persistent_data->least_military_score = kBottomLimit;
+			persistent_data->least_military_score -= 2 / divider;
 		}
 		if (persistent_data->least_military_score < 0) {
 			persistent_data->least_military_score = 0;
 		}
 	}
 
-	// This is effective score, falling down very quickly
-	if (persistent_data->target_military_score > kUpperLimit + 150) {
-		persistent_data->target_military_score = 8 * persistent_data->target_military_score / 10;
-	} else {
-		persistent_data->target_military_score = 9 * persistent_data->target_military_score / 10;
-	}
+	assert(persistent_data->least_military_score <= persistent_data->target_military_score);
+	assert(persistent_data->target_military_score <=
+	       persistent_data->ai_personality_mil_upper_limit);
+	persistent_data->target_military_score = 9 * persistent_data->target_military_score / 10;
 	if (persistent_data->target_military_score < persistent_data->least_military_score) {
 		persistent_data->target_military_score = persistent_data->least_military_score;
 	}
-
-	// there are many reasons why to stop building production buildings
-	// (note there are numerous exceptions)
-	// 1. to not have too many constructionsites
-	if ((num_prod_constructionsites + mines_in_constr()) >
-	    (productionsites.size() + mines_built()) / persistent_data->ai_productionsites_ratio + 2) {
-		new_buildings_stop_ = true;
-	}
-	// 2. to not exhaust all free spots
-	if (!has_enough_space) {
-		new_buildings_stop_ = true;
-	}
-	// 3. too keep some proportions production sites vs military sites
-	if ((num_prod_constructionsites + productionsites.size()) >
-	    (msites_in_constr() + militarysites.size()) * 5) {
-		new_buildings_stop_ = true;
-	}
-	// 4. if we do not have 2 mines at least
-	if (mines_.size() < 2) {
-		new_buildings_stop_ = true;
-	}
+	assert(persistent_data->target_military_score >= persistent_data->least_military_score);
 
 	// we must calculate wood policy
 	const DescriptionIndex wood_index = tribe_->safe_ware_index("log");
 	// stocked wood is to be in some propotion to productionsites and
 	// constructionsites (this proportion is bit artifical, or we can say
 	// it is proportion to the size of economy). Plus some positive 'margin'
-	const int32_t stocked_wood_margin = get_warehoused_stock(wood_index) -
-	                                    productionsites.size() * 2 - num_prod_constructionsites +
-	                                    persistent_data->ai_personality_wood_difference;
+	const int32_t stocked_wood_margin = calculate_stocklevel(wood_index) -
+	                                    productionsites.size() * 2 - numof_psites_in_constr +
+	                                    management_data.get_military_number_at(87) / 5;
 	if (gametime < 15 * 60 * 1000) {
 		wood_policy_ = WoodPolicy::kAllowRangers;
 	} else if (stocked_wood_margin > 80) {
@@ -1640,34 +2214,6 @@
 		wood_policy_ = WoodPolicy::kAllowRangers;
 	}
 
-	// we must consider need for mines
-	// set necessity for mines
-	// we use 'virtual mines', because also mine spots can be changed
-	// to mines when AI decides so
-
-	resource_necessity_mines_ = 100 * (15 - virtual_mines) / 15;
-	resource_necessity_mines_ = (resource_necessity_mines_ > 100) ? 100 : resource_necessity_mines_;
-	resource_necessity_mines_ = (resource_necessity_mines_ < 20) ? 10 : resource_necessity_mines_;
-
-	// here we calculate how badly we need to expand, result is number (0-100)
-	// like a percent
-	if (spots_ == 0) {
-		resource_necessity_territory_ = 100;
-	} else {
-		resource_necessity_territory_ = 100 * 3 * (productionsites.size() + 5) / spots_;
-		resource_necessity_territory_ =
-		   (resource_necessity_territory_ > 100) ? 100 : resource_necessity_territory_;
-		resource_necessity_territory_ =
-		   (resource_necessity_territory_ < 10) ? 10 : resource_necessity_territory_;
-		// alse we need at lest 4 big spots
-		if (spots_avail.at(BUILDCAPS_BIG) < 2) {
-			resource_necessity_territory_ = 100;
-		}
-		if (spots_avail.at(BUILDCAPS_MEDIUM) < 4) {
-			resource_necessity_territory_ = 100;
-		}
-	}
-
 	BuildingObserver* best_building = nullptr;
 	int32_t proposed_priority = 0;
 	Coords proposed_coords;
@@ -1685,7 +2231,8 @@
 
 		// not doing this for non-military buildins
 		if (!(bo.type == BuildingObserver::Type::kMilitarysite ||
-		      bo.type == BuildingObserver::Type::kTrainingsite))
+		      bo.type == BuildingObserver::Type::kTrainingsite ||
+		      bo.type == BuildingObserver::Type::kProductionsite))
 			continue;
 
 		// and neither for small military buildings
@@ -1698,13 +2245,17 @@
 		// checking we have enough critical material on stock
 		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;
+			uint32_t treshold = 7;
 			// generally trainingsites are more important
 			if (bo.type == BuildingObserver::Type::kTrainingsite) {
+				treshold = 4;
+			}
+
+			if (bo.type == BuildingObserver::Type::kProductionsite) {
 				treshold = 2;
 			}
 
-			if (get_warehoused_stock(wt) < treshold) {
+			if (calculate_stocklevel(wt) <= treshold) {
 				bo.build_material_shortage = true;
 				break;
 			}
@@ -1722,6 +2273,11 @@
 
 			bo.new_building = check_building_necessity(bo, PerfEvaluation::kForConstruction, gametime);
 
+			if (bo.is(BuildingAttribute::kShipyard)) {
+				assert(bo.new_building == BuildingNecessity::kAllowed ||
+				       bo.new_building == BuildingNecessity::kForbidden);
+			}
+
 			if (bo.new_building == BuildingNecessity::kAllowed) {
 				bo.new_building_overdue = 0;
 			}
@@ -1732,7 +2288,7 @@
 			     bo.new_building == BuildingNecessity::kForced ||
 			     bo.new_building == BuildingNecessity::kAllowed ||
 			     bo.new_building == BuildingNecessity::kNeededPending) &&
-			    !bo.outputs.empty()) {
+			    (!bo.outputs.empty() || bo.is(BuildingAttribute::kBarracks))) {
 				if (bo.max_needed_preciousness <= 0) {
 					throw wexception("AI: Max presciousness must not be <= 0 for building: %s",
 					                 bo.desc->name().c_str());
@@ -1741,6 +2297,7 @@
 				bo.max_needed_preciousness = 0;
 			} else {
 				// For other situations we make sure max_needed_preciousness is zero
+
 				assert(bo.max_needed_preciousness == 0);
 			}
 
@@ -1763,42 +2320,31 @@
 			// 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;
+					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.primary_priority * bo.new_building_overdue *
+					                       std::abs(management_data.get_military_number_at(120)) / 500;
+					bo.primary_priority += bo.max_needed_preciousness +
+					                       bo.max_needed_preciousness * bo.new_building_overdue *
+					                          std::abs(management_data.get_military_number_at(70)) /
+					                          1000 +
+					                       bo.new_building_overdue *
+					                          std::abs(management_data.get_military_number_at(71)) / 50;
+					if (bo.new_building == BuildingNecessity::kForced) {
+						bo.primary_priority += bo.new_building_overdue *
+						                       std::abs(management_data.get_military_number_at(119)) / 50;
+					}
 				}
 			} else {
 				bo.primary_priority = 0;
 			}
 
-			// Generally we don't start another building if there is some of the same type in
-			// construction
-			// Some types of building allow two buildings in construction though, but not more
-			// Below checks are to guarantee that there is no logical error in previous steps, or
-			// inconsistency in AI data
-			if (bo.new_building == BuildingNecessity::kNeeded ||
-			    bo.new_building == BuildingNecessity::kForced ||
-			    bo.new_building == BuildingNecessity::kAllowed ||
-			    bo.new_building == BuildingNecessity::kNeededPending) {
-				if (bo.plants_trees || bo.need_trees || bo.max_needed_preciousness >= 10) {
-					if (bo.cnt_under_construction + bo.unoccupied_count > 1) {
-						throw wexception("AI inconsistency:  %s: total_count %d > 1, unoccupied: %d",
-						                 bo.name, bo.total_count(), bo.unoccupied_count);
-					}
-				} else {
-					if (bo.cnt_under_construction + bo.unoccupied_count > 0) {
-						throw wexception("AI inconsistency:  %s: total_count %d > 0, unoccupied: %d",
-						                 bo.name, bo.total_count(), bo.unoccupied_count);
-					}
-				}
-			}
-
 		} else if (bo.type == BuildingObserver::Type::kMilitarysite) {
-			bo.new_building = check_building_necessity(bo.desc->get_size(), gametime);
+			bo.new_building = check_building_necessity(bo, gametime);
 		} else if (bo.type == BuildingObserver::Type::kTrainingsite) {
 			bo.new_building = check_building_necessity(bo, PerfEvaluation::kForConstruction, gametime);
+		} else if (bo.type == BuildingObserver::Type::kWarehouse) {
+			bo.new_building = check_warehouse_necessity(bo, gametime);
 		} else if (bo.aimode_limit_status() != AiModeBuildings::kAnotherAllowed) {
 			bo.new_building = BuildingNecessity::kNotNeeded;
 		} else {
@@ -1848,13 +2394,13 @@
 			}
 
 			// testing for reserved ports
-			if (!bo.is_port) {
+			if (!bo.is(BuildingAttribute::kPort)) {
 				if (port_reserved_coords.count(bf->coords.hash()) > 0) {
 					continue;
 				}
 			}
 
-			if (time(nullptr) % 3 == 0 && bo.total_count() > 0) {
+			if (std::rand() % 3 == 0 && bo.total_count() > 0) {
 				continue;
 			}  // add randomnes and ease AI
 
@@ -1864,7 +2410,8 @@
 
 			// 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.is(BuildingAttribute::kLumberjack)) {
 				continue;
 			}
 
@@ -1877,8 +2424,11 @@
 
 			if (bo.type == BuildingObserver::Type::kProductionsite) {
 
+				prio = management_data.neuron_pool[44].get_result_safe(bf->military_score_ / 20) / 5;
+				assert(prio >= -20 && prio <= 20);
+
 				// this can be only a well (as by now)
-				if (bo.mines_water) {
+				if (bo.is(BuildingAttribute::kWell)) {
 
 					if (bo.new_building == BuildingNecessity::kForced) {
 						assert(bo.total_count() - bo.unconnected_count == 0);
@@ -1900,33 +2450,41 @@
 						prio += 200;
 					}
 
-					prio += bf->ground_water - 2;
+					prio += -10 + 2 * bf->ground_water;
 
-				} else if (bo.need_trees) {  // LUMBERJACS
+				} else if (bo.is(BuildingAttribute::kLumberjack)) {
 
 					prio = bo.primary_priority;
 
-					prio += -20 + 200 / (bo.total_count() + 1);
-
 					if (bo.new_building == BuildingNecessity::kForced) {
-						prio *= 2;
-					} else if (bf->trees_nearby < 2 && bf->supporters_nearby.at(bo.outputs.at(0) == 0)) {
+						prio += 5 * std::abs(management_data.get_military_number_at(17));
+					}
+
+					if (bf->trees_nearby < trees_nearby_treshold_ &&
+					    bo.new_building == BuildingNecessity::kAllowed) {
 						continue;
 					}
 
+					prio += std::abs(management_data.get_military_number_at(26)) *
+					        (bf->trees_nearby - trees_nearby_treshold_) / 10;
+
 					// 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 += 2 * bf->supporters_nearby.at(bo.outputs.at(0)) *
+					        std::abs(management_data.get_military_number_at(25));
+					prio -= bf->producers_nearby.at(bo.outputs.at(0)) *
+					        std::abs(management_data.get_military_number_at(36)) * 3;
+
+				} else if (bo.is(BuildingAttribute::kNeedsRocks)) {
 
 					// 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;
 
+					if (bf->rocks_nearby > 0 && bf->near_border) {
+						prio += management_data.get_military_number_at(27) / 2;
+					}
+
 					// value is initialized with 1 but minimal value that can be
 					// calculated is 11
 					if (prio <= 1) {
@@ -1937,19 +2495,14 @@
 						prio += 150;
 					}
 
-					if (bo.stocklevel_time < game().get_gametime() - 5 * 1000) {
-						bo.stocklevel = get_stocklevel(static_cast<size_t>(bo.production_hint));
-						bo.stocklevel_time = game().get_gametime();
-					}
-
-					if (bo.stocklevel == 0) {
+					if (get_stocklevel(bo, gametime) == 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) {
+				} else if (bo.is(BuildingAttribute::kHunter)) {
 
 					if (bf->critters_nearby < 5) {
 						continue;
@@ -1967,26 +2520,31 @@
 					prio +=
 					   (bf->critters_nearby * 3) - 8 - 5 * bf->producers_nearby.at(bo.outputs.at(0));
 
-				} else if (bo.is_fisher) {  // fisher
+				} else if (bo.is(BuildingAttribute::kFisher)) {  // fisher
 
 					if (bf->water_nearby < 2 || bf->fish_nearby < 2) {
 						continue;
 					}
 
 					if (bo.new_building == BuildingNecessity::kForced) {
-						prio += 20;
+						prio += 200;
 					}
 
 					// 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 += bf->supporters_nearby.at(bo.outputs.at(0)) * 20;
 
-					prio += -5 + bf->fish_nearby;
+					prio +=
+					   -5 +
+					   bf->fish_nearby * (1 + std::abs(management_data.get_military_number_at(63) / 15));
+					if (resource_necessity_water_needed_) {
+						prio *= 3;
+					}
 
 				} else if (bo.production_hint >= 0) {
-					if (bo.plants_trees) {
+					if (bo.is(BuildingAttribute::kRanger)) {
 						assert(bo.cnt_target > 0);
 					} else {
 						bo.cnt_target =
@@ -1996,39 +2554,41 @@
 					// They have no own primary priority
 					assert(bo.primary_priority == 0);
 
-					if (bo.plants_trees) {  // RANGERS
+					if (bo.is(BuildingAttribute::kRanger)) {
 
 						assert(bo.new_building == BuildingNecessity::kNeeded);
 
-						// if there are too many trees nearby
-						if (bf->trees_nearby > 25 && bo.total_count() >= 1) {
-							continue;
-						}
-
-						// for small starting spots - to prevent crowding by rangers and trees
-						if (spots_ < (4 * bo.total_count()) && bo.total_count() > 0) {
-							continue;
-						}
+						prio = 0;
 
 						if (bo.total_count() == 0) {
-							prio = 200;
+							prio += 200;
 						} else {
-							prio = 50 / bo.total_count();
+							prio += std::abs(management_data.get_military_number_at(66)) *
+							        (bo.cnt_target - bo.total_count());
 						}
-
-						// considering producers
-						prio += std::min<uint8_t>(bf->producers_nearby.at(bo.production_hint), 4) * 5 -
-						        new_buildings_stop_ * 15 - bf->space_consumers_nearby * 5 -
-						        bf->rocks_nearby / 3 + bf->trees_nearby / 2 +
-						        std::min<uint8_t>(bf->supporters_nearby.at(bo.production_hint), 4) * 3;
+						prio -= bf->water_nearby / 5;
+
+						prio += management_data.neuron_pool[67].get_result_safe(
+						           bf->producers_nearby.at(bo.production_hint) * 5, kAbsValue) /
+						        2;
+
+						prio +=
+						   management_data.neuron_pool[49].get_result_safe(bf->trees_nearby, kAbsValue) /
+						   5;
+
+						prio += bf->producers_nearby.at(bo.production_hint) * 5 -
+						        (expansion_type.get_expansion_type() != ExpansionMode::kEconomy) * 15 -
+						        bf->space_consumers_nearby * 5 - bf->rocks_nearby / 3 +
+						        bf->supporters_nearby.at(bo.production_hint) * 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.is(BuildingAttribute::kNeedsCoast) &&
+						    (bf->water_nearby < 6 || bf->fish_nearby < 6)) {
 							continue;
 						}
-						if (bo.need_water) {
+						if (bo.is(BuildingAttribute::kNeedsCoast)) {
 							prio += (-6 + bf->water_nearby) / 3;
 							prio += (-6 + bf->fish_nearby) / 3;
 						}
@@ -2037,18 +2597,13 @@
 							continue;
 						}
 
-						if (bo.stocklevel_time < game().get_gametime() - 5 * 1000) {
-							bo.stocklevel =
-							   get_stocklevel_by_hint(static_cast<size_t>(bo.production_hint));
-							bo.stocklevel_time = game().get_gametime();
-						}
-						if (bo.stocklevel > 50) {
+						if (get_stocklevel(bo, gametime) > 50) {
 							continue;
 						}
 
 						if (bo.total_count() == 0) {
 							prio += 100;
-						} else if (!bo.need_water) {
+						} else if (!bo.is(BuildingAttribute::kNeedsCoast)) {
 							prio += 10 / bo.total_count();
 						}
 
@@ -2060,21 +2615,18 @@
 						}
 					}
 
-				} 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 &&
-					    // but only if current buildings are utilized enough
-					    (bo.total_count() == 0 || bo.current_stats > 60)) {
-						prio = 10;
-					}
+				} else if (bo.is(BuildingAttribute::kRecruitment)) {
+					prio = bo.primary_priority;
+					prio -= bf->unowned_land_nearby * 2;
+					prio -= (bf->enemy_nearby) * 100;
+					prio -= (expansion_type.get_expansion_type() != ExpansionMode::kEconomy) * 100;
 				} else {  // finally normal productionsites
 					assert(bo.production_hint < 0);
 
 					if (bo.new_building == BuildingNecessity::kForced) {
 						prio += 150;
-					} else if (bo.is_shipyard) {
+						assert(!bo.is(BuildingAttribute::kShipyard));
+					} else if (bo.is(BuildingAttribute::kShipyard)) {
 						assert(bo.new_building == BuildingNecessity::kAllowed);
 						if (!seafaring_economy) {
 							continue;
@@ -2089,33 +2641,43 @@
 					// we check separatelly buildings with no inputs and some inputs
 					if (bo.inputs.empty()) {
 
-						if (bo.space_consumer) {
+						assert(!bo.is(BuildingAttribute::kShipyard));
+
+						if (bo.is(BuildingAttribute::kSpaceConsumer)) {
 							// we dont like trees nearby
 							prio += 1 - bf->trees_nearby / 15;
 							// we attempt to cluster space consumers together
 							prio += bf->space_consumers_nearby * 2;
 							// and be far from rangers
-							prio += 1 - bf->rangers_nearby * 3;
+							prio += 1 -
+							        bf->rangers_nearby *
+							           std::abs(management_data.get_military_number_at(102)) / 5;
 						} else {
 							// leave some free space between them
-							prio -= bf->producers_nearby.at(bo.outputs.at(0)) * 5;
-						}
-
-						if (bo.space_consumer && !bf->water_nearby) {  // not close to water
-							prio += 1;
-						}
-
-						if (bo.space_consumer &&
-						    !bf->unowned_mines_spots_nearby) {  // not close to mountains
-							prio += 1;
+							prio -= bf->producers_nearby.at(bo.outputs.at(0)) *
+							        std::abs(management_data.get_military_number_at(108)) / 5;
+						}
+
+						if (bo.is(BuildingAttribute::kSpaceConsumer) &&
+						    bf->water_nearby) {  // not close to water
+							prio -= std::abs(management_data.get_military_number_at(103)) / 5;
+						}
+
+						if (bo.is(BuildingAttribute::kSpaceConsumer) &&
+						    bf->unowned_mines_spots_nearby) {  // not close to mountains
+							prio -= std::abs(management_data.get_military_number_at(104)) / 5;
 						}
 					}
 
-					else if (bo.is_shipyard) {
+					else if (bo.is(BuildingAttribute::kShipyard)) {
 						// for now AI builds only one shipyard
-						if (bf->open_water_nearby > 1 && (bo.total_count() - bo.unconnected_count) == 0 &&
-						    seafaring_economy) {
-							prio += productionsites.size() * 5 + bf->open_water_nearby;
+						assert(bo.total_count() == 0);
+						if (bf->open_water_nearby > 3 && seafaring_economy) {
+							prio += productionsites.size() * 5 +
+							        bf->open_water_nearby *
+							           std::abs(management_data.get_military_number_at(109)) / 10;
+						} else {
+							continue;
 						}
 					}
 
@@ -2125,11 +2687,11 @@
 
 					// bonus for big buildings if shortage of big fields
 					if (spots_avail.at(BUILDCAPS_BIG) <= 5 && bo.desc->get_size() == 3) {
-						prio += 10;
+						prio += std::abs(management_data.get_military_number_at(105)) / 5;
 					}
 
 					if (spots_avail.at(BUILDCAPS_MEDIUM) <= 5 && bo.desc->get_size() == 2) {
-						prio += 5;
+						prio += std::abs(management_data.get_military_number_at(106)) / 5;
 					}
 
 					// +1 if any consumers_ are nearby
@@ -2139,152 +2701,69 @@
 						consumers_nearby_count += bf->consumers_nearby.at(bo.outputs.at(k));
 
 					if (consumers_nearby_count > 0) {
-						prio += 1;
+						prio += std::abs(management_data.get_military_number_at(107)) / 3;
 					}
 				}
 
 				// Consider border with exemption of some huts
-				if (!(bo.need_trees || bo.need_water || bo.is_fisher)) {
+				if (!(bo.is(BuildingAttribute::kLumberjack) || bo.is(BuildingAttribute::kNeedsCoast) ||
+				      bo.is(BuildingAttribute::kFisher))) {
 					prio = recalc_with_border_range(*bf, prio);
-				} else if (bf->near_border && (bo.need_trees || bo.need_water)) {
+				} else if (bf->near_border && (bo.is(BuildingAttribute::kLumberjack) ||
+				                               bo.is(BuildingAttribute::kNeedsCoast))) {
 					prio /= 2;
 				}
 
 			}  // production sites done
 			else if (bo.type == BuildingObserver::Type::kMilitarysite) {
 
-				if (!(bf->unowned_land_nearby || bf->enemy_nearby)) {
-					continue;
-				}
-
-				if (military_last_build_ > gametime - 15 * 1000) {
-					continue;
-				}
-
-				// This is another restriction of military building - but general
-				if (bf->enemy_nearby && bo.fighting_type) {
-					;
-				}  // it is ok, go on
-				else if (bf->unowned_mines_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;
-					}
-					if (bo.desc->get_size() == 3 && gametime % 4 >= 1) {
-						continue;
-					};
-				} else {
-					continue;
-				}  // the building is not suitable for situation
-
-				// 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;
-				} else {
-					if (bf->near_border) {
-						prio += 50;
-						prio -= bo.build_material_shortage * 150;
-					} else {
-						prio -= bo.build_material_shortage * 500;  // prohibitive
-					}
-					prio -= (bf->military_in_constr_nearby + bf->military_unstationed) * 150;
-					prio += (5 - bf->own_military_sites_nearby_()) * 15;
-				}
-				prio += bf->unconnected_nearby * 50;
-				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) {
-					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) {
-					prio_for_size *= 30;
-				} else {
-					prio_for_size *= 5;
-				}
-				prio += prio_for_size;
+				assert(prio == 0);
+				prio = bo.primary_priority;
+
+				// Two possibilities why to construct militarysite here
+				if (!bf->defense_msite_allowed &&
+				    bf->nearest_buildable_spot_nearby < bo.desc->get_conquers() &&
+				    (bf->military_in_constr_nearby + bf->military_unstationed) <
+				       concurent_ms_in_constr_no_enemy) {
+					// it will conquer new buildable spots for buildings or mines
+					;
+				} else if (bf->defense_msite_allowed &&
+				           (bf->military_in_constr_nearby + bf->military_unstationed) <
+				              concurent_ms_in_constr_enemy_nearby) {
+					// we need it to increase capacity on the field
+					if (bo.fighting_type) {
+						prio += 5;
+					}
+				} else {
+					continue;
+				}
+				if (bf->unowned_mines_spots_nearby > 2 && bo.mountain_conqueror) {
+					prio += 5;
+				}
+				prio += std::abs(management_data.get_military_number_at(35)) / 5 *
+				        (static_cast<int16_t>(bo.desc->get_conquers()) -
+				         static_cast<int16_t>(bf->nearest_buildable_spot_nearby));
+