Merge lp:~widelands-dev/widelands/seafaring-ai into lp:widelands

[TiborB]

Hi, after some time this is ready for review, read the branch info for more info.

Tested a lot as AI-only games, I would welcome a human players tests and feedback.

[TiborB (tiborb95)]

Also I run codecheck over couple of files that I had edited, therefore the diff shows quite a lot of cosmetic changes.

[GunChleoc (gunchleoc)]

I will have to look at this in detail later, my brain's not working properly today.

Codecheck still comes up with an error, could you please always run codecheck over the complete code base before submitting a merge request? This way, we won't have cosmetic changes in the diff in the future.

I also saw that there are commented out lines of code in the diff, they should go before a merge.

[TiborB (tiborb95)]

@GunChleoc - yes, there was one error left unfixed in defaultai.cc - fixed

cosmetic changes happened on files out of ai directory (like ship.cc) that I had not touched before. And were caused by clang-format. Next time somebody will work on them and run clang-format on them, there will be no cosmetic changes, of course.

[TiborB (tiborb95)]

next time just put a comment into diff here whenever you see someting that needs fixing - it will be easier for me to get what you mean

[GunChleoc (gunchleoc)]

Running clang-format is good :) Doesn't work on my system though :(

[GunChleoc (gunchleoc)]

> next time just put a comment into diff here whenever you see someting that
> needs fixing - it will be easier for me to get what you mean

I have used my browser to search for "// " and added diff comments. I hope that I have found them all.

When I temporarily comment something out, I usually add a NOCOM to make sure I won't forget to delete it before a merge request. Otherwise, I would forget all the time.

[GunChleoc (gunchleoc)]

I have added some diff comments. I find the for loops with the iterators hard to read, so I got stuck there at some point - if you change these to range-based loops (example below), I will have another go at this.

[TiborB (tiborb95)]

@GunChleoc - re observers - there is one point why vectors are suitable - they are ordered and have a front member that can be moved to the back. This is used when doing various kinds of check - like check one building every 10 seconds.
Usually a player has couple of ships, but quite a lot of buildings, but most of all - a lot of roads and flags. These would be best candidates for optimization, but these also needs an order, because they are accessed similarly like buildings.

So this is not that straightforward.

BTW, I started to use unordered_set where suitable (as you probably noticed) - exactly for performance point of view.

[TiborB (tiborb95)]

correction: allships is a list, not a vector, as I believed, sorry

[GunChleoc (gunchleoc)]

> @GunChleoc - re observers - there is one point why vectors are suitable - they
> are ordered and have a front member that can be moved to the back. This is
> used when doing various kinds of check - like check one building every 10
> seconds.

That's a valid point, so ignore my comment for that :)

[TiborB (tiborb95)]

This is mystery to me, see two lines:

//ref_cast<ConstructionSite const, Building const>(b).building().name().c_str());
dynamic_cast<const ConstructionSite&>((b).building().name().c_str()));

commented out is before, the second one is what I want to use. Before it used to compile, now it complains:

defaultai.cc:3766:48: error: 'const class Widelands::Building' has no member named 'building'

Can you see any problem here?

[GunChleoc (gunchleoc)]

> //ref_cast<ConstructionSite const, Building const>(b).building().name().c_str());
> dynamic_cast<const ConstructionSite&>((b).building().name().c_str()));
>
> commented out is before, the second one is what I want to use. Before it used to compile, now it complains:
>
> defaultai.cc:3766:48: error: 'const class Widelands::Building' has no member named 'building'
>
> Can you see any problem here?

You are casting everything instead of just the construction site. Try this:

dynamic_cast<const ConstructionSite&>(b).building().name().c_str());

[TiborB (tiborb95)]

So I implemented comments I saw there, merged trunk, resolved conflicts :(

[SirVer (sirver)]

Say, Tibor, are you having fun working on Widelands? You seem unhappy in most of your comments about procedure, overhead or comments.

[TiborB (tiborb95)]

I have, I like the 'productive' work, but all that overhead, cleaning the code.... and what I like the least is conflict resolution - I am never sure if I make it right - all right it will compile, but will the functionality be exactly preserved? It would take further tens of hours of testing to say...

But generally I like it, I would not be 'here' otherwise. :)

[SirVer (sirver)]

I think you can maximize the fun by making smaller branches. They are faster to merge, clean and review.

[TiborB (tiborb95)]

I found it yet :)

No more big branches, this is why I enjoyed these two (or three) small branches I did lately (including this one and tha LUA resource think - though this gone wild from one-line change).

I have 2 fixes for AI in may mind (both military-related) but I will wait till this one is merged. Having too many branches and multitasking between them is another think that I dont like much :)

[GunChleoc (gunchleoc)]

> No more big branches, this is why I enjoyed these two (or three) small
> branches I did lately (including this one and tha LUA resource think - though
> this gone wild from one-line change).

This has happened to me too and will keep happening - one day I will learn that there are no quick fixes. I sometimes find it frustrating at first as well, but when the branch is finished, I am happy, because the code is better.

[GunChleoc (gunchleoc)]

I have done some testing now. I ran into 2 issues:

1. Fellowships: The space is too tight for the AI to manoeuvre the ships. Pathfinding is always tricky though, so I don't think we need to fix it in this branch.

2. Together We're Strong: By the time the AI had build enough military buildings, the port space had already been covered with trees/roads. I think the only good way to solve this would be to let the AI cheat and know where all the port spaces are beforehand. So if an economy has no port yet, building anything else on port spaces (including roads) is blocked. If it is blocked by trees, build a lumberjack nearby.

I have also started working on removing all those iterators (they irk me), but this is something for a separate branch.

[TiborB (tiborb95)]

@GunChleoc

Thanks for testing:)

1. In fact the ship algorithm (I mean not part of AI) sometimes incorectly reports islandcircumnavigated (signal), even though nothing were circumnavigated, only banks are too close. And AI is not able to find out the the signal is errorneous. When I tested seafaring AI I edited all such spots on my maps where ships got stucked - making passages wider.

2. Indeed AI "looks" only on owned spots. So it is not aware of port spots even close beyond border. My approach - few port spaces should be available for every headquarters. If probability of making use of portspace is 50 %, 3-4 portspaces (in reasobale spacing) would be enough.

[GunChleoc (gunchleoc)]

2. Your approach means that mapmakers will have to change their maps so the AI can deal with them.

Check out get_port_spaces() in map.h, this will give you a list of all port spaces on the map, so it could be used to let the AI "cheat". Add them to the list of blocked fields for everything else but building a port until the economy has a portdock.

[TiborB (tiborb95)]

We have handfull of seafaring-ready maps. So reworking them should not be too lot of work.But mainly we needs new ones.

Your suggestion is viable. But this is still not 100% quarantee of a success. Trees can grow there, or roads can be built there (AI does not control exact layout of roads, it uses underlying algorithm)

Let other say what seem the best solution.

Maybe both solutions are to be used - cheating via blocking all port fields, and setting a 'standard' that one headquarters needs multiple ports nearby.

[GunChleoc (gunchleoc)]

I think it is a viable suggestion to work from both ends.

I didn't know about the roads problem - maybe it would help to have some sort of safety margin around the port plots where no flags can be set - or if there's a road there, set the flag and dismantle it, so that the road will disappear? That might leave buildings stranded though - tricky.

[GunChleoc (gunchleoc)]

I have added some code cleanup suggestions. They are all small changes that will make the code easier to read. Otherwise, LGTM.

[SirVer (sirver)]

The reformatting makes it hard to understand what actually changed. Could you do that in trunk and merge this, so that the functional changes stand out more?

I also had some more nits.

review: Needs Fixing

[TiborB (tiborb95)]

Added some answers to the comments.

[GunChleoc (gunchleoc)]

I added a comment to one of your comments :)

[TiborB (tiborb95)]

I cannot see it. What line number?

[GunChleoc (gunchleoc)]

Neither can I, seems to be gone or hiding.

It was about changing the enum to an enum class - the change has the advantage that there is less danger of another enum using the same name and the code jumping on the wrong enum. We are planning to move from enums to enum classes in general. https://bugs.launchpad.net/widelands/+bug/1367725

[TiborB (tiborb95)]

Alright, I merged the trunk once more and resolved conflicts...

There is one NOCOM as a reminder for myself...

I will change that enum (in defaultai.cc), it is defined within a function so it should not be that dangerous however...

[GunChleoc (gunchleoc)]

Thanks, this makes the diff a lot smaller :)

Give us a shout when you're ready again.

[TiborB (tiborb95)]

Alright, I fixed what remained. Yet there is one NOCOM with question :)

[GunChleoc (gunchleoc)]

//NOCOM - how is it, when I added class here I have to cast everything

Because enough_ships isn't of the enum class' type. You will get rid of the cast if you do something like this:

enum class FleetStatus: uint8_t {kNeedShip = 0, kEnoughShips = 1, kDoNothing = 2 };

FleetStatus enough_ships = FleetStatus::kDoNothing;

etc...

Note that I also renamed fleetStatus to FleetStatus, because it's an Object class.

[TiborB (tiborb95)]

Oh, I believed uint8_t is the type. Then 'uint8_t' is not needed at all, is it?

[GunChleoc (gunchleoc)]

Correct, your type is the enum class name now.

If you don't give the enum class itself an explicit type, it will default to int, which would be fine in this case. You also don't need to assign numbers to the members, this is entirely optional and should only be done when you explicitly depend on a member having a specific value. So, get:

enum class FleetStatus {
    kNeedShip,
    kEnoughShips,
    kDoNothing
};

which will do the job nicely :)

[TiborB (tiborb95)]

few words to rev. 7245

I think the crashes of seafaring were due to the command queue, especially when it grows big and it takes too long for a command to be processed. AI does not know whether there is a relevant command in the queue and issues another one based on actual status of the ship. When the first command is executed, the status might have changed and second command might crash the game. So I want to add following check:
http://bazaar.launchpad.net/~widelands-dev/widelands/seafaring-ai/view/head:/src/logic/playercommand.cc#L787 (+ 2 similar test below)

I thinks (based on testing) it does the job, but I would like to limit the test only to computer player - I just dont know how to find out if the current player is an AI player.

I think these tests might interfere with GUI control of ships.

[SirVer (sirver)]

I think these tests should be done for all players - what you describe can happen for a human player too if he presses the same button twice while the command is still distributed to other players in the game. Can easily happen in slow network games. Your code saveguards against that and should not disturb in any other way.

You can doublecheck by running the regression_test.py - it exercises the UI for ships too.

[TiborB (tiborb95)]

"I think these tests should be done for all players" - I am not 100% sure, but this does not bother me now.

I had another crash today - again on the same place in code.

It seems to me that unders some circumstance there can be portdock with no fleet associated to it. I am not sure if the fault is in my changes - might be. But I am going to learn all that object oriented mess related to ports, portdocks and fleets. It will take time...

[TiborB (tiborb95)]

short update:)

I just want to inform you that I am hunting that mysterious bug - so many hours of tests and no crash. I added some printfs for case it crashes, but nothing. I dont know, but I am not sure it is gone...

But I would say this bug was not introduced with my changes.

Also I added some statistics on command line - this is intended for map creators when testing performance with AI players for what resources are missing or where are the botlenecks, the output looks like:

 3: Buildings: Pr: 39, Ml: 9, Mi: 4, Wh: 1, Po: 0. Missing: stone, corn, bread, meat,
 2: Buildings: Pr: 76, Ml: 18, Mi: 6, Wh: 1, Po: 0. Missing: stone, wheat, bread, meat,
 5: Buildings: Pr: 72, Ml: 14, Mi: 5, Wh: 2, Po: 1. Missing: coal, log, marble, stone, wheat, grape, bread, meat,
 4: Buildings: Pr: 63, Ml: 19, Mi: 6, Wh: 2, Po: 1. Missing: marble, stone, wheat, grape, bread, meat,
 7: Buildings: Pr: 68, Ml: 16, Mi: 7, Wh: 1, Po: 0. Missing: coal, marble, stone,
 6: Buildings: Pr: 69, Ml: 16, Mi: 6, Wh: 2, Po: 0. Missing: coal, log, wheat, meat,

now src/ai/defaultai.cc must be edited (there is a variable) to have it printed out (by every 60 minutes now), but if you find it usefull, I can imagine command line switch like '--stats'. By default it will be disabled, of course.

[TiborB (tiborb95)]

So it seems I am done. I failed to invoke the bug again and I think I am just wasting my time.

I removed printfs and nocoms, so it is again ready for your review.

review: Needs Resubmitting

[TiborB (tiborb95)]

So I pushed another small tweak - now it counts mine fields of the same material type in vicinity - when positioning new mines. In other words it pushes mines in the middle of area of the same material. Before, location was more random and mine could be build on the edge of area (it might have been and edge of mountains or so).
I hope no one is just doing the review now...

[GunChleoc (gunchleoc)]

I added a NOCOM - there is also a second NOCOM that I don't have an answer for.

I also did some testing, and got no crashes.

- On the Fellowships map, 1/3 AIs managed to start building a shipyard and port about 30 minutes into the game. The shipyard was correctly stopped until the port got finished, but then never restarted. The other 2 AIs built something else on the port space.

- On the Swamp Island map, 2/3 AIs managed to start building a Port around 30 minutes into the game. On of the ports got overrun by the friendly neighbour, the other AI started building ships in a lake. Maybe we can add a check in the future if the port is reachable from the shipyard's body of water.

- Long, long way: I spotted the first Port construction site around 18 minutes into the game. Ships were successfully built, but there was no gold for the expeditions.

- Twin Lagoons: First port got built around 1:30 into the game. Both started an expedition. One of the AIs was successful. The second AI failed to build a second port, because there were some port spaces that both AIs kept rejecting.

I think we should merge this soon and deal with any remaining issues in new, smaller branches.

[TiborB (tiborb95)]

so to your comments:

The main problem is that seafaring is based on one-water assumption. There is no scanning
and analysis of map to identify individual distinct waters and making decision which one is worth seafaring. This would have to include cheating probably.
I have couple of maps (mine usually) that are one-water-only and used these for testing.

Ai builds strictly one shipyard only.

If there are 2-3 portspaces available for AI nearby, it will succed to use at least one for port.
This can be improved but there are limitations - like AI not in control of layout of roads and so on.

As unfinished ship decays the building of ship starts when shipyard is fully stocked - you mentioned this problem probably.

If AI finds a portspace it scans the vicinity in some radius - if it runs into other player - the spot is ignored - this was probably what you encountered. The idea behind is that expedition would not be succesfull anyway.

But this can be finetuned as well.

The result of this is that last expedition lasts forever. This is inefficiency, because a stock on ship and ship itself could be used for transport. But easy to fix/modify.

I used my maps spider lake, cristobals sea and soutfall islands for testing - I recommend to use one of them to see seafaring at its bests :)

[GunChleoc (gunchleoc)]

My testing was done to see if anything crashes, and to check if behaviour is OK. I think it is OK for now - I just decided to give detailed feedback so we know what can be improved further.

Once the 2 remaining NOCOMS are fixed, I think this branch is ready to be merged :)

[TiborB (tiborb95)]

@GunChleoc
first NOCOM is perhaps a mistake??

and second one was discussed with SirVer and I think this is no problem and I might remove it.

But I will wait for another review and comments

[SirVer (sirver)]

I'll prioritize looking over this tomorrow. There are some changes outside of ai/ that I'd like to think through before they hit trunk.

[TiborB (tiborb95)]

of course

I tested only AI-only games, because I dont have enough time for a real game...

[SirVer (sirver)]

I did a codereview now and I identified one bug in the AI: it will not work properly after loading. See code review comments. I think this is not ideal, but not critical. After the NOCOMs are removed this should be merged and a new branch should deal with the design issue. Maybe a new bug can be opened to track the problem.

All the changes outside of ai/ lgtm.

review: Needs Fixing

[TiborB (tiborb95)]

@SirVer

So I did some simple tests and it is BAD. List of ships is empty after load. So AI will not manage them at all.

But his is analogous to productionsites, militarysites vectors when loading game - so I tested militarysites and these are properly initialized = AI knows about all of them after load. (I tested both single player and mulitiplayer game).

Though, when I removed 'if (player_ == nullptr)' test for NoteImmovable it crashed for netwok game and survived for single player game.

But is seems that there is some mechanism that take care of NoteImmovable messages and is not in effect for NoteShipMessages.

What do you think?

[SirVer (sirver)]

> But is seems that there is some mechanism that take care of NoteImmovable messages and is not in effect for NoteShipMessages.

I do not believe that is correct - if it where late_initialization would not be needed. Loading would then just be a very fast way of gaining tons of map objects. I therefore believe that the original designer of the AI code decided to build late_initialization() to create the invariants that the AI relies on. You can check if the buildings vector is also filled if you skip most work in late_initialization.

[TiborB (tiborb95)]

I found that when a ship is loaded from savefile no note is sent at all. It is send only when ship is initiated.
with playerimmovable it is called from other place. So I will try to find better place to sent a note about new ship from...

[TiborB (tiborb95)]

HEY,
after some painfull debugging I found that on load restored immovables are not sending notes to players, but instead a player is scanning for them as a part of late_initialization, see here:

http://bazaar.launchpad.net/~widelands-dev/widelands/seafaring-ai/view/head:/src/ai/defaultai.cc#L574

So I am working for similar code to scan for ships and will push it to the branch once it is tested and polished ...

[TiborB (tiborb95)]

I fixed most of comments.

And I realized that save/load is quite hurting to AI. A lot of internal info of AI is just lost. Some of them will be restored, but .... I need to do some deeper analysis. But not in this branch.

Would it be possible to save&load some data? Not objects, only f.e. unordered sets of integers? It would help much...

review: Needs Resubmitting

[SirVer (sirver)]

> Would it be possible to save&load some data? Not objects, only f.e. unordered sets of integers? It would help much...

Of course you could save state, but it won't help: We support right now that two humans start playing a game, later one of them loads it and fills the other slot with an AI. You will still have the case of late initialization then.

[TiborB (tiborb95)]

hi just found a small bug that prevents compilation here, I will push a fix tonight. But I can tell you right now if you are just working on it...

I understand... I will try to circumvent it (in next turn), but it is not good...

[TiborB (tiborb95)]

rephrasing :) : I will try to mitigate the hurting effect of save/load cycle, but AI has too many internal variables/data structures...

[GunChleoc (gunchleoc)]

I have moved the ScoutingDirection enum into ship.h and fixed up the code so it won't get used as boolean.

Everything else LGTM.

review: Approve

[SirVer (sirver)]

ship it! (see what I did there :))

review: Approve

[GunChleoc (gunchleoc)]

Houston, we have e problem: test_rip_first_port_with_worker_in_portdock.lua hangs.

review: Needs Fixing

[TiborB (tiborb95)]

Hi, does it makes a sense - to have a worker in a portdock? workers and wares are transfered port <-> ship, portdock is not involved I think....

[TiborB (tiborb95)]

So I looked at your tests - I liked them much, two comments about the issue:

1.) I think this is not AI related - at all
2.) I would say the lua is not correct, and I am not sure what is to be tested. When you extend the sleeps - you can see how the ship picks a worker from port1 and if port2 is destroyed before ships arrives, the worker is returned to port1. But I am not sure if this is what is to be tested.

[TiborB (tiborb95)]

I thought these are brand new tests you just created, nevermind... :)

BUT - I compiled trunk, run the tests and they failed on the very test. So no regression here...

review: Needs Resubmitting

[SirVer (sirver)]

> BUT - I compiled trunk, run the tests and they failed on the very test. So no regression here...

not what I see - the test passes for me on trunk and hangs forever in seafaring-ai. It could be something in the new logic of re-adding the portdock to a warehouse.

[GunChleoc (gunchleoc)]

I see the same as SirVer - tests work in trunk.

[TiborB (tiborb95)]

with me it does not hang, just prints out FAIL for that test.

I dont have a good network here and have only some older trunk (half year old about) on harddisk, but tested this trunk and current seafaring and both have similar behaviour, this is my testing session:

$python2.7 ./regression_test.py -b ./widelands -r test_rip_second_port_with_worker_in_portdock.lua -k
Using './widelands' binary.
test/maps/ship_transportation.wmf/scripting/test_rip_second_port_with_worker_in_portdock.lua ...
  Running Widelands ... FAIL

======================================================================
FAIL: test/maps/ship_transportation.wmf/scripting/test_rip_second_port_with_worker_in_portdock.lua
----------------------------------------------------------------------
Traceback (most recent call last):
  File "./regression_test.py", line 99, in runTest
    self.verify_success(stdout, stdout_filename)
  File "./regression_test.py", line 122, in verify_success
    "Widelands exited abnormally. %s" % common_msg
AssertionError: Widelands exited abnormally. Analyze the files in /tmp/widelands_regression_testbVVt4p to see why this test case failed. Stdout is
  /tmp/widelands_regression_testbVVt4p/stdout_00.txt

----------------------------------------------------------------------
Ran 1 test in 21.740s

FAILED (failures=1)

Content of log file:

$cat /tmp/widelands_regression_testKNpEbT/stdout_00.txt
[.....]
MO(5,portdock): set_need_ship(false)
MO(5,portdock): ... trigger fleet update
# All Tests passed. <= NOTE HERE
WareList: 1 items of 8 left.
widelands: /usr/include/boost/signals2/detail/lwm_pthreads.hpp:60: void boost::signals2::mutex::lock(): Assertion `pthread_mutex_lock(&m_) == 0' failed.

I will double check with actual trunk tonight

[TiborB (tiborb95)]

so I checked on actual trunk - the same problem....

?

[SirVer (sirver)]

Maybe try updating boost? Seems like a boost bug in what you see there.

[GunChleoc (gunchleoc)]

I just grabbed myself a fresh trunk and the tests still go through there.

Is there a way to run test_rip_first_port_with_worker_in_portdock.lua without running the whole testsuite?
./widelands --scenario=test/maps/ship_transportation.wmf doesn't work.

[SirVer (sirver)]

./regression_test.py -r test_rip_first_port_with_worker

-r searches for the given regular expression in the test name (combination of map + lua file).

[TiborB (tiborb95)]

the file is test_rip_second_port_with_worker_in_portdock.lua

After some investigation I found that folowing command will run just particular script:

./widelands --verbose=true --datadir=. --disable_fx=true --disable_music=true --language=en_US --scenario=test/maps/ship_transportation.wmf --script=test/maps/ship_transportation.wmf/scripting/test_rip_second_port_with_worker_in_portdock.lua

and based on this I was able to get backtrace from gdb, here it is:

Program received signal SIGABRT, Aborted.
0xb7fdcbcc in __kernel_vsyscall ()
(gdb) bt
#0 0xb7fdcbcc in __kernel_vsyscall ()
#1 0xb7805f47 in raise () from /usr/lib/lib/libc.so.6
#2 0xb7807589 in abort () from /usr/lib/lib/libc.so.6
#3 0xb77ff027 in __assert_fail_base () from /usr/lib/lib/libc.so.6
#4 0xb77ff0ab in __assert_fail () from /usr/lib/lib/libc.so.6
#5 0x0877261f in boost::signals2::mutex::lock (this=0xa9b3d14) at /usr/include/boost/signals2/detail/lwm_pthreads.hpp:60
#6 0x08775874 in boost::signals2::detail::unique_lock<boost::signals2::mutex>::unique_lock (this=0xbfffefdc, m=...)
    at /usr/include/boost/signals2/detail/unique_lock.hpp:29
#7 0x08888105 in boost::signals2::detail::signal_impl<void (), boost::signals2::optional_last_value<void>, int, std::less<int>, boost::function<void ()>, boost::function<void (boost::signals2::connection const&)>, boost::signals2::mutex>::operator()() (
    this=0xa9b3d08) at /usr/include/boost/signals2/detail/signal_template.hpp:229
#8 0x08886f63 in boost::signals2::signal<void (), boost::signals2::optional_last_value<void>, int, std::less<int>, boost::function<void ()>, boost::function<void (boost::signals2::connection const&)>, boost::signals2::mutex>::operator()() (this=0xa9b3c30)
    at /usr/include/boost/signals2/detail/signal_template.hpp:718
#9 0x088c9690 in Widelands::WareList::remove (this=0xa9b3c30, i=8 '\b', count=1) at ../src/logic/warelist.cc:80
#10 0x08adc7df in Widelands::Economy::remove_workers (this=0xa9b3c08, id=8 '\b', count=1) at ../src/economy/economy.cc:401
#11 0x088cdcdd in Widelands::Worker::set_economy (this=0xa9976c0, economy=0x0) at ../src/logic/worker.cc:1168
#12 0x088cf2cc in Widelands::Worker::shipping_pop (this=0xa9976c0, game=...) at ../src/logic/worker.cc:1644
#13 0x0880ba6e in Widelands::Bob::do_pop_task (this=0xa9976c0, game=...) at ../src/logic/bob.cc:283
#14 0x0880be0c in Widelands::Bob::reset_tasks (this=0xa9976c0, game=...) at ../src/logic/bob.cc:388
#15 0x088cdef2 in Widelands::Worker::cleanup (this=0xa9976c0, egbase=...) at ../src/logic/worker.cc:1220
#16 0x08841ee2 in Widelands::MapObject::remove (this=0xa9976c0, egbase=...) at ../src/logic/instances.cc:369
#17 0x08841514 in Widelands::ObjectManager::cleanup (this=0xbffff490, egbase=...) at ../src/logic/instances.cc:161
#18 0x08772be8 in Widelands::EditorGameBase::cleanup_objects (this=0xbffff47c) at ../src/logic/editor_game_base.h:180
#19 0x0882a7a7 in Widelands::Game::run (this=0xbffff47c, loader_ui=0xbffff2b4, start_game_type=Widelands::Game::NewSPScenario,
script_to_run="test/maps/ship_transportation.wmf/scripting/test_rip_second_port_with_worker_in_portdock.lua", replay=false)

This was trunk...

[TiborB (tiborb95)]

boost version: 1.57.0 (installed, it is arch linux, and also widelands reports this version when compiling)

[Tino (tino79)]

I am not sure if this is related:
https://github.com/boostorg/signals2/pull/8/files

When i was updating my build environment a few days ago i had to apply this patch to boost 1.5.7 to make it work with widelands.

[TiborB (tiborb95)]

Tino,
the patch seems to be aplied...

I can do one test though, insert some printf into warelist.cc and run a test game to see whether that piece of code is used during running of widelands at all.

[GunChleoc (gunchleoc)]

I'm still on Boost 1.54

[GunChleoc (gunchleoc)]

Test won't run at all with ./regression_test.py -r test_rip_first_port_with_worker_in_portdock - I get a file not found. Tibor's method works though, here is the relevant output:

Trying to run: map:scripting/init.lua: done
Trying to run: test/maps/ship_transportation.wmf/scripting/test_rip_first_port_with_worker_in_portdock.lua: done
MO(1,ship): ship_update: No destination anymore.
Forcing flag at (16, 17)
Message: adding (wh) (warehouse) 1
MO(4,port): Setting up port dock fields
MO(4,port): Found 1 fields for the dock
Message: adding (wh) (warehouse) 1
Forcing flag at (13, 17)
Forcing flag at (16, 17)
Clearing for road at (14, 17)
Clearing for road at (15, 17)
Forcing flag at (16, 3)
Message: adding (wh) (warehouse) 1
MO(12,port): Setting up port dock fields
MO(12,port): Found 1 fields for the dock
Forcing flag at (18, 5)
Forcing flag at (18, 5)
Forcing flag at (16, 5)
Clearing for road at (17, 5)
Forcing flag at (16, 5)
Forcing flag at (16, 3)
Clearing for road at (16, 4)
MO(6,fleet): Fleet::act
MO(5,portdock): set_need_ship(true)
MO(5,portdock): ... trigger fleet update
MO(5,portdock): set_need_ship(true)
MO(6,fleet): Fleet::act
MO(6,fleet): Port 5 needs ship
MO(6,fleet): ... ship 1 takes care of it
MO(1,ship): set_destination to 5 (currently 0 items)
MO(1,ship): ship_update: Go to dock 5
Message: removing warehouse (player 1)
MO(23,carrier): init_auto_task: become fugitive
MO(23,carrier): [fugitive]: found a flag connected to warehouse(s)
MO(23,carrier): [fugitive]: try to move to flag
Script requests save to: port1_just_removed
Autosave: save requested : port1_just_removed
Game: Writing Preload Data ... took 7ms
Game: Writing Game Class Data ... took 0ms
Game: Writing Player Info ... took 1ms
Game: Writing Map Data!
Writing Elemental Data ... took 0ms
 Writing Player Names And Tribe Data ... took 0ms
 Writing Port Spaces Data ... took 1ms
 Writing Heights Data ... took 0ms
<snip>
 Writing Players Unseen Data ... took 4ms
 Writing Scripting Data ... took 8ms
 Writing Objective Data ... took 0ms
 MapSaver::save() took 36ms
Game: Writing Map Data took 36ms
Game: Writing Player Economies Info ... took 1ms
Game: Writing Command Queue Data ... took 8ms
Game: Writing Interactive Player Data ... took 0ms
GameSaver::save() took 53ms
SaveHandler::save_game() took 53ms
Autosave: save took 62 ms
MO(23,carrier): [gowarehouse]: Got transfer
MO(23,carrier): [transfer]: starting task [movepath] and setting location to road 9
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.
MO(1,ship): ship_update: No destination anymore.

Looks like the carrier never reaches the warehouse in line 26 of the lua script, so the port isn't built again.

[TiborB (tiborb95)]

Probably boost is involved to some degree, but I started tracking down what is triggering the crash.

It seem this situation is it: when a builder is in shipping state, left on a ship with no ports remaining and following function http://bazaar.launchpad.net/~widelands-dev/widelands/seafaring-ai/view/head:/src/logic/worker.cc#L1644 is used - it crashes.

It need further investigation and also I am not very glad to have to tinker with these parts of code.

[TiborB (tiborb95)]

GunChleoc - I test mainly the script *SECOND* not FIRST port with portdock....

But ....FIRST... behaves as you described.

You are still sure that trunk behaves differently? Both compiled with the same environment...

[GunChleoc (gunchleoc)]

Yes, trunk runs all the tests successfully (I tested twice and did a fresh compile on a fresh branch and tested again and it's OK, and it works for SirVer as well), so the boost problem you're having must be a different problem. Your test explicitly fails, our test just hangs.

[TiborB (tiborb95)]

I spent quite a lot of time on this today, both issues points to workers/carriers. This part of code I am not familiar at all... but I will keep looking at it.

[SirVer (sirver)]

Have you tried (temporarily)reverting the change that recreates port docks? It seems the most likely culprit for me.

> Am 09.02.2015 um 15:57 schrieb TiborB <email address hidden>:
>
> I spent quite a lot of time on this today, both issues points to workers/carriers. This part of code I am not familiar at all... but I will keep looking at it.
> --
> https://code.launchpad.net/~widelands-dev/widelands/seafaring-ai/+merge/242271
> You are reviewing the proposed merge of lp:~widelands-dev/widelands/seafaring-ai into lp:widelands.

[TiborB (tiborb95)]

I will look at this as well of course, but generally I would like to learn and understand how things work there.

Also boost is a complication here, because it is a black box and I am not able to undestand a backtrace from it...

[TiborB (tiborb95)]

OK, I moved forward. I reworked the restoration of portdock, returned a bit to initial design and now test_rip_first_port_with_*_in_portdock.lua passed, but test_rip_second_port_with_ware_in_portdock.lua still crashes with that boost error. (As I said it crashes when game is shutting)

Generally it is not a showstopper as in a normal game this is stable (talking about linux).

I will push the changes tonight or tomorrow for your review.

[TiborB (tiborb95)]

you can run regression tests again. I will look at this one failing test. Also I am testing the game with AI-only players, I will let you know if everything looks alright.

[GunChleoc (gunchleoc)]

All tests now run without problems on my machine, so IMO this branch is good to go now :)

Since the test that's still failing does so only on your machine and for trunk as well, I expect that there's something about your setup that Widelands doesn't like.

review: Approve

[TiborB (tiborb95)]

I just completed tests on my debian PC - all passed - I just dont know....

[SirVer (sirver)]

Time to merge then.

The one issue that concerns me still in this branch is that there is no new test for a warehouse that needs to recreate it's port dock. I feel this corner case can easily regress without a test. But since this branch has been sitting for so long, I think it should be merged now. Maybe you can add a test in a later branch, tibor?

review: Approve

[TiborB (tiborb95)]

SirVer - I added such test: test_rip_portdock_with_worker_and_ware_in_transit.lua

It is bit lost among other tests, because they all uses the word "portdock" when in fact they mean "port"

Though situation when portdock is lost but cannot be restored and port itself has to be destroyed is not tested in any test. I was not sure how to do it - if there was lua interface to remove ownership from field(s) where portdock is - this could be used... or place an enemy military building that would take ownership from fields where portdock is located (and not affect the port building itself) .... so indeed such test would be usefull.

[GunChleoc (gunchleoc)]

Bug report, so we won't forget: https://bugs.launchpad.net/widelands/+bug/1421107

[SirVer (sirver)]

> SirVer - I added such test: test_rip_portdock_with_worker_and_ware_in_transit.lua

My apologize. I did not remember/see it in the branch. I think this is great then.

The other test case you describe is indeed harder to do. You would need to construct a map with military buildings of another player ordered in such a way that as soon as they are all manned, the port has no more space for its dock.

[GunChleoc (gunchleoc)]

Thanks, Tibor. I will take care of the merging :)

=== modified file 'src/ai/ai_help_structs.h'
--- src/ai/ai_help_structs.h	2014-10-30 20:24:57 +0000
+++ src/ai/ai_help_structs.h	2015-02-10 21:28:25 +0000
@@ -21,6 +21,7 @@
 #define WL_AI_AI_HELP_STRUCTS_H
 
 #include <list>
+#include <unordered_set>
 
 #include "economy/flag.h"
 #include "economy/road.h"
@@ -30,6 +31,7 @@
 #include "logic/instances.h"
 #include "logic/map.h"
 #include "logic/player.h"
+#include "logic/ship.h"
 #include "logic/world/terrain_description.h"
 #include "logic/world/world.h"
 
@@ -122,6 +124,22 @@
 	}
 };
 
+// Looking only for mines-capable fields nearby
+// of specific type
+struct FindNodeMineable {
+	bool accept(const Map&, const FCoords& fc) const {
+
+		return (fc.field->nodecaps() & BUILDCAPS_MINE) &&
+			(fc.field->get_resources() == res);
+	}
+
+	Game& game;
+	int32_t res;
+
+	FindNodeMineable(Game& g, int32_t r) : game(g), res(r)  {
+	}
+};
+
 // Fishers and fishbreeders must be built near water
 struct FindNodeWater {
 	FindNodeWater(const World& world) : world_(world) {
@@ -227,10 +245,9 @@
 	int16_t military_stationed_;
 	// stationed (manned) military buildings nearby
 	int16_t military_unstationed_;
-	// some buildings must be postponed bit
-	int32_t prohibited_till_;
-	// and then some must be forced
-	int32_t forced_after_;
+	bool is_portspace_;
+	bool port_nearby_;  // to increase priority if a port is nearby,
+	// especially for new colonies
 
 	std::vector<uint8_t> consumers_nearby_;
 	std::vector<uint8_t> producers_nearby_;
@@ -261,7 +278,9 @@
 	     military_loneliness_(1000),
 	     military_in_constr_nearby_(0),
 	     military_presence_(0),
-	     military_stationed_(0) {
+	     military_stationed_(0),
+	     is_portspace_(false),
+	     port_nearby_(false) {
 	}
 };
 
@@ -273,9 +292,12 @@
 	bool preferred_;
 
 	int32_t mines_nearby_;
+	//this is to provide that a mine is not built on the edge of mine area
+	int32_t same_mine_fields_nearby_;
 
 	MineableField(const Widelands::FCoords& fc)
-	   : coords(fc), next_update_due_(0), preferred_(false), mines_nearby_(0) {
+	   : coords(fc), next_update_due_(0), preferred_(false), mines_nearby_(0),
+	   same_mine_fields_nearby_(0) {
 	}
 };
 
@@ -310,12 +332,14 @@
 	bool plants_trees_;
 	bool recruitment_;  // is "producing" workers?
 	bool is_buildable_;
-	bool need_trees_;          // lumberjack = true
-	bool need_stones_;         // 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 need_trees_;   // lumberjack = true
+	bool need_stones_;  // 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
@@ -327,7 +351,6 @@
 
 	int32_t mines_;           // type of resource it mines_
 	uint16_t mines_percent_;  // % of res it can mine
-
 	uint32_t current_stats_;
 
 	std::vector<int16_t> inputs_;
@@ -372,6 +395,28 @@
 	bool enemies_nearby_;
 };
 
+struct TrainingSiteObserver {
+	Widelands::TrainingSite* site;
+	BuildingObserver* bo;
+};
+
+struct WarehouseSiteObserver {
+	Widelands::Warehouse* site;
+	BuildingObserver* bo;
+};
+
+struct ShipObserver {
+	Widelands::Ship* ship;
+	Widelands::Coords expedition_start_point_;
+	std::unordered_set<uint32_t> visited_spots_;
+
+	// a ship circumvents all islands in the same direction, the value
+	// is assigned only once
+	Widelands::ScoutingDirection island_circ_direction = Widelands::ScoutingDirection::kClockwise;
+	bool waiting_for_command_ = false;
+	int32_t last_command_time = 0;
+};
+
 struct WareObserver {
 	uint8_t producers_;
 	uint8_t consumers_;

=== modified file 'src/ai/defaultai.cc'
--- src/ai/defaultai.cc	2015-01-27 20:35:26 +0000
+++ src/ai/defaultai.cc	2015-02-10 21:28:25 +0000
@@ -31,7 +31,9 @@
 #include "base/macros.h"
 #include "economy/economy.h"
 #include "economy/flag.h"
+#include "economy/portdock.h"
 #include "economy/road.h"
+#include "economy/wares_queue.h"
 #include "logic/constructionsite.h"
 #include "logic/findbob.h"
 #include "logic/findimmovable.h"
@@ -39,7 +41,9 @@
 #include "logic/map.h"
 #include "logic/militarysite.h"
 #include "logic/player.h"
+#include "logic/playercommand.h"
 #include "logic/productionsite.h"
+#include "logic/ship.h"
 #include "logic/trainingsite.h"
 #include "logic/tribe.h"
 #include "logic/warehouse.h"
@@ -59,6 +63,13 @@
 // building of the same building can be started after 25s at earliest
 constexpr int kBuildingMinInterval = 25 * 1000;
 constexpr int kMinBFCheckInterval = 5 * 1000;
+constexpr int kShipCheckInterval = 5 * 1000;
+constexpr int kMarineDecisionInterval = 20 * 1000;
+constexpr int kTrainingSitesCheckInterval = 30 * 1000;
+
+//this is intended for map developers, by default should be off
+constexpr bool kPrintStats = false;
+
 // Some buildings have to be built close to borders and their
 // priority might be decreased below 0, so this is to
 // compensate
@@ -81,6 +92,7 @@
      num_constructionsites_(0),
      num_milit_constructionsites(0),
      num_prod_constructionsites(0),
+     num_ports(0),
      next_road_due_(2000),
      next_stats_update_due_(30000),
      next_construction_due_(1000),
@@ -88,9 +100,13 @@
      next_productionsite_check_due_(0),
      next_mine_check_due_(0),
      next_militarysite_check_due_(0),
+     next_ship_check_due(5 * 60 * 1000),
+     next_marine_decisions_due(5 * 60 * 1000),
      next_attack_consideration_due_(300000),
-     next_helpersites_check_due_(180000),
+     next_trainingsites_check_due_(15 * 60 * 1000),
      next_bf_check_due_(1000),
+     next_wares_review_due_(15 * 60 * 1000),
+     next_statistics_report_(30 * 60 * 1000),
      inhibit_road_building_(0),
      time_of_last_construction_(0),
      enemy_last_seen_(-2 * 60 * 1000),
@@ -107,6 +123,8 @@
 	last_attack_target_(
         std::numeric_limits<uint16_t>::max(), std::numeric_limits<uint16_t>::max()),
      next_attack_waittime_(10),
+     seafaring_economy(false),
+     colony_scan_area_(35),
      spots_(0) {
 
 	// Subscribe to NoteFieldPossession.
@@ -146,6 +164,48 @@
 		   out_of_resources_site(*note.ps);
 
 		});
+
+	// Subscribe to ShipNotes.
+	shipnotes_subscriber_ =
+	   Notifications::subscribe<NoteShipMessage>([this](const NoteShipMessage& note) {
+
+			// in a short time between start and late_initialization the player
+			// can get notes that can not be processed.
+			// It seems that this causes no problem, at least no substantial
+			if (player_ == nullptr) {
+				return;
+			}
+			if (note.ship->get_owner()->player_number() != player_->player_number()) {
+			   return;
+		   }
+
+			switch (note.message) {
+
+			case NoteShipMessage::Message::kGained:
+			   gain_ship(*note.ship, NewShip::kBuilt);
+			   break;
+
+			case NoteShipMessage::Message::kLost:
+				for (std::list<ShipObserver>::iterator i = allships.begin(); i != allships.end(); ++i) {
+					if (i->ship == note.ship) {
+					   allships.erase(i);
+					   break;
+				   }
+			   }
+			   break;
+
+			case NoteShipMessage::Message::kWaitingForCommand:
+			   for (std::list<ShipObserver>::iterator i = allships.begin(); i != allships.end(); ++i) {
+					if (i->ship == note.ship) {
+					   i->waiting_for_command_ = true;
+					   break;
+				   }
+			   }
+			   break;
+		   default:
+				;
+			}
+		});
 }
 
 DefaultAI::~DefaultAI() {
@@ -241,6 +301,14 @@
 		return;
 	}
 
+	if (check_ships(gametime)) {
+		return;
+	}
+
+	if (marine_main_decisions(gametime)) {
+		return;
+	}
+
 	// Check the mines and consider upgrading or destroying one
 	if (check_mines_(gametime)) {
 		return;
@@ -252,6 +320,10 @@
 		return;
 	}
 
+	if (check_trainingsites(gametime)) {
+		return;
+	}
+
 	// improve existing roads!
 	// main part of this improvment is creation 'shortcut roads'
 	// this includes also connection of new buildings
@@ -260,6 +332,18 @@
 		m_mineable_changed = true;
 		return;
 	}
+
+	// once in 15 minutes we increase(or decrease) targets for wares
+	if (next_wares_review_due_ <= gametime) {
+		next_wares_review_due_ = gametime + 15 * 60 * 1000;
+		review_wares_targets(gametime);
+	}
+
+	//print statistics
+	if (kPrintStats && next_statistics_report_ <= gametime) {
+		print_stats();
+		next_statistics_report_ += 60 * 60 * 1000;
+	}
 }
 
 /**
@@ -320,6 +404,7 @@
 		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();
 		if (bh.renews_map_resource()) {
 			bo.production_hint_ = tribe_->safe_ware_index(bh.get_renews_map_resource());
 		}
@@ -333,8 +418,7 @@
 
 		// Read all interesting data from ware producing buildings
 		if (bld.type() == MapObjectType::PRODUCTIONSITE) {
-			const ProductionSiteDescr& prod =
-					dynamic_cast<const ProductionSiteDescr&>(bld);
+			const ProductionSiteDescr& prod = dynamic_cast<const ProductionSiteDescr&>(bld);
 			bo.type = bld.get_ismine() ? BuildingObserver::MINE : BuildingObserver::PRODUCTIONSITE;
 			for (const WareAmount& temp_input : prod.inputs()) {
 				bo.inputs_.push_back(temp_input.first);
@@ -345,7 +429,7 @@
 
 			if (bo.type == BuildingObserver::MINE) {
 				// get the resource needed by the mine
-				if (bh.has_mines()) {
+				if (bh.get_mines()) {
 					bo.mines_ = world.get_resource(bh.get_mines());
 				}
 
@@ -365,6 +449,13 @@
 			} else {
 				bo.is_fisher_ = false;
 			}
+
+			if (building_name == "shipyard") {
+				bo.is_shipyard_ = true;
+			} else {
+				bo.is_shipyard_ = false;
+			}
+
 			continue;
 		}
 
@@ -373,8 +464,7 @@
 		// non critical are excluded (see below)
 		if (bld.type() == MapObjectType::MILITARYSITE) {
 			bo.type = BuildingObserver::MILITARYSITE;
-			const MilitarySiteDescr& milit =
-				dynamic_cast<const MilitarySiteDescr&>(bld);
+			const MilitarySiteDescr& milit = dynamic_cast<const MilitarySiteDescr&>(bld);
 			for (const std::pair<unsigned char, unsigned char>& temp_buildcosts : milit.buildcost()) {
 				// bellow are non-critical wares
 				if (tribe_->ware_index("log") == temp_buildcosts.first ||
@@ -397,6 +487,10 @@
 
 		if (bld.type() == MapObjectType::TRAININGSITE) {
 			bo.type = BuildingObserver::TRAININGSITE;
+			const TrainingSiteDescr& train = dynamic_cast<const TrainingSiteDescr&>(bld);
+			for (const WareAmount& temp_input : train.inputs()) {
+				bo.inputs_.push_back(temp_input.first);
+			}
 			continue;
 		}
 
@@ -419,10 +513,32 @@
 		resource_necessity_water_needed_ = true;
 	}
 
-	// Add all fields that we own
 	Map& map = game().map();
+
+	//here we scan entire map for own ships
+	std::set<OPtr<Ship>> found_ships;
+	for (int16_t y = 0; y < map.get_height(); ++y) {
+		for (int16_t x = 0; x < map.get_width(); ++x) {
+			FCoords f = map.get_fcoords(Coords(x, y));
+			//there are too many bobs on the map so we investigate
+			//only bobs on water
+			if (f.field->nodecaps() & MOVECAPS_SWIM) {
+				for (Bob * bob = f.field->get_first_bob();
+					bob;
+					bob = bob->get_next_on_field()) {
+					if (upcast(Ship, ship, bob)) {
+						if (ship->get_owner() == player_ && !found_ships.count(ship)) {
+							found_ships.insert(ship);
+							gain_ship(*ship, NewShip::kFoundOnLoad);
+						}
+					}
+				}
+			}
+		}
+	}
+
+	//here we scan entire map for owned unused fields and own buildings
 	std::set<OPtr<PlayerImmovable>> found_immovables;
-
 	for (int16_t y = 0; y < map.get_height(); ++y) {
 		for (int16_t x = 0; x < map.get_width(); ++x) {
 			FCoords f = map.get_fcoords(Coords(x, y));
@@ -434,7 +550,6 @@
 			unusable_fields.push_back(f);
 
 			if (upcast(PlayerImmovable, imm, f.field->get_immovable())) {
-
 				//  Guard by a set - immovables might be on several nodes at once.
 				if (&imm->owner() == player_ && !found_immovables.count(imm)) {
 					found_immovables.insert(imm);
@@ -596,6 +711,34 @@
 		}
 	}
 
+	// if curent port is a portspace we need add near fields to a list
+	// of fields prohibited for buildings
+	if (!field.is_portspace_) {  // if we know it, no need to do it once more
+		if (player_->get_buildcaps(field.coords) & BUILDCAPS_PORT) {
+			field.is_portspace_ = true;
+			seafaring_economy = true;
+			// blocking fields in vicinity
+			MapRegion<Area<FCoords>> mr(map, Area<FCoords>(map.get_fcoords(field.coords), 3));
+			do {
+				const int32_t hash = coords_hash(map.get_fcoords(*(mr.location().field)));
+				if (port_reserved_coords.count(hash) == 0)
+					port_reserved_coords.insert(hash);
+			} while (mr.advance(map));
+		}
+	}
+
+	// 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;
+	}
+
 	// collect information about resources in the area
 	std::vector<ImmovableFound> immovables;
 	// Search in a radius of range
@@ -707,7 +850,6 @@
 			field.stones_nearby_ = 0;
 
 			for (uint32_t j = 0; j < immovables.size(); ++j) {
-				// const BaseImmovable & base_immovable = *immovables.at(i).object;
 				if (immovables.at(j).object->has_attribute(stone_attr)) {
 					++field.stones_nearby_;
 				}
@@ -819,6 +961,13 @@
 			}
 		}
 	}
+
+	// 0 is default, and thus indicates that counting must be done
+	if (field.same_mine_fields_nearby_ == 0) {
+		FindNodeMineable find_mines_spots_nearby(game(), field.coords.field->get_resources());
+		field.same_mine_fields_nearby_ =
+		   map.find_fields(Area<FCoords>(field.coords, 4), nullptr, find_mines_spots_nearby);
+	}
 }
 
 /// Updates the production and MINE sites statistics needed for construction decision.
@@ -909,14 +1058,14 @@
 // - there is an enemy
 //   Currently more military buildings are built then needed
 //   and "optimalization" (dismantling not needed buildings) is done afterwards
-bool DefaultAI::construct_building(int32_t gametime) {  // (int32_t gametime)
+bool DefaultAI::construct_building(int32_t gametime) {
 	//  Just used for easy checking whether a mine or something else was built.
 	bool mine = false;
 	bool field_blocked = false;
 	uint32_t consumers_nearby_count = 0;
 	std::vector<int32_t> spots_avail;
 	spots_avail.resize(4);
-	// uint16_t const pn = player_number();
+	Map& map = game().map();
 
 	for (int32_t i = 0; i < 4; ++i)
 		spots_avail.at(i) = 0;
@@ -1022,7 +1171,8 @@
 		}
 
 	// testing big military buildings, whether critical construction
-	// material is (not) needed
+	// material is available (at least in amount of
+	// 2/3 of default target amount)
 	for (uint32_t j = 0; j < buildings_.size(); ++j) {
 
 		BuildingObserver& bo = buildings_.at(j);
@@ -1040,19 +1190,13 @@
 
 		bo.build_material_shortage_ = false;
 
-		for (EconomyObserver* observer : economies) {
-			// Don't check if the economy has no warehouse.
-			if (observer->economy.warehouses().empty()) {
-				continue;
-			}
-
-			for (uint32_t m = 0; m < bo.critical_built_mat_.size(); ++m) {
-				WareIndex wt(static_cast<size_t>(bo.critical_built_mat_.at(m)));
-
-				if (observer->economy.needs_ware(wt)) {
-					bo.build_material_shortage_ = true;
-					continue;
-				}
+		// checking we have enough critical material on stock
+		for (uint32_t m = 0; m < bo.critical_built_mat_.size(); ++m) {
+			WareIndex wt(static_cast<size_t>(bo.critical_built_mat_.at(m)));
+			// using default ware quantity, not the best solution but will do
+			if (get_warehoused_stock(wt) <
+			    tribe_->get_ware_descr(wt)->default_target_quantity() * 2 / 3) {
+				bo.build_material_shortage_ = true;
 			}
 		}
 	}
@@ -1068,10 +1212,6 @@
 	     ++i) {
 		BuildableField* const bf = *i;
 
-		// if 'buildable field' update is overdue for more then 8 seconds
-		// (= bf has not been updated for about 15 seconds)
-		// skip the bf in evaluation, bacause information
-		// contained in bf are too old
 		if (bf->next_update_due_ < gametime - 8000) {
 			continue;
 		}
@@ -1111,6 +1251,13 @@
 				continue;
 			}
 
+			// testing for reserved ports
+			if (!bo.is_port_) {
+				if (port_reserved_coords.count(coords_hash(bf->coords)) > 0) {
+					continue;
+				}
+			}
+
 			if (time(nullptr) % 3 == 0 && bo.total_count() > 0) {
 				continue;
 			}  // add randomnes and ease AI
@@ -1408,6 +1555,10 @@
 					} else if (bo.cnt_built_ == 1 && game().get_gametime() > 40 * 60 * 1000 &&
 					           bo.desc->enhancement() != INVALID_INDEX && !mines_.empty()) {
 						prio += 10;
+					} else if (bo.is_shipyard_) {
+						if (!seafaring_economy) {
+							continue;
+						}
 					} else if (!output_is_needed) {
 						continue;
 					} else if (bo.cnt_built_ == 0 && game().get_gametime() > 40 * 60 * 1000) {
@@ -1447,7 +1598,13 @@
 						prio -= bf->space_consumers_nearby_ * 3;
 					}
 
-					if (!bo.inputs_.empty()) {
+					else if (bo.is_shipyard_) {
+						// for now AI builds only one shipyard
+						if (bf->water_nearby_ > 3 && bo.total_count() == 0 && seafaring_economy) {
+							prio += kDefaultPrioBoost + productionsites.size() * 5 + bf->water_nearby_;
+						}
+
+					} else if (!bo.inputs_.empty()) {
 						if (bo.total_count() == 0) {
 							prio += max_needed_preciousness + kDefaultPrioBoost;
 						}
@@ -1508,10 +1665,10 @@
 					;  // we allow big buildings now
 				} else if (bf->unowned_land_nearby_ &&
 				           bo.expansion_type_) {  // decreasing probability for big buidlings
-					if (bo.desc->get_size() == 2 && gametime % 15 >= 1) {
+					if (bo.desc->get_size() == 2 && gametime % 2 >= 1) {
 						continue;
 					}
-					if (bo.desc->get_size() == 3 && gametime % 40 >= 1) {
+					if (bo.desc->get_size() == 3 && gametime % 3 >= 1) {
 						continue;
 					}
 				}
@@ -1563,9 +1720,19 @@
 			} else if (bo.type == BuildingObserver::WAREHOUSE) {
 
 				// exclude spots on border
-				if (bf->near_border_) {
-					continue;
-				}
+				if (bf->near_border_ && !bo.is_port_) {
+					continue;
+				}
+
+				if (!bf->is_portspace_ && bo.is_port_) {
+					continue;
+				}
+
+				if (bo.cnt_under_construction_ > 0) {
+					continue;
+				}
+
+				bool warehouse_needed = false;
 
 				//  Build one warehouse for ~every 35 productionsites and mines_.
 				//  Militarysites are slightly important as well, to have a bigger
@@ -1575,33 +1742,64 @@
 				       static_cast<int32_t>(numof_warehouses_) &&
 				    bo.cnt_under_construction_ == 0) {
 					prio = 20;
-				}
-
-				// take care about borders and enemies
+					warehouse_needed = true;
+				}
+
+				// but generally we prefer ports
+				if (bo.is_port_) {
+					prio += 10;
+				}
+
+				// special boost for first port
+				if (bo.is_port_ && bo.total_count() == 0 && productionsites.size() > 5 &&
+				    !bf->enemy_nearby_ && bf->is_portspace_ && seafaring_economy) {
+					prio += kDefaultPrioBoost + productionsites.size();
+					warehouse_needed = true;
+				}
+
+				if (!warehouse_needed) {
+					continue;
+				}
+
+				// iterating over current warehouses and testing a distance
+				// getting distance to nearest warehouse and adding it to a score
+				uint16_t nearest_distance = std::numeric_limits<uint16_t>::max();
+				for (const WarehouseSiteObserver& wh_obs : warehousesites) {
+					const uint16_t actual_distance =
+					   map.calc_distance(bf->coords, wh_obs.site->get_position());
+					nearest_distance = std::min(nearest_distance, actual_distance);
+				}
+				// but limit to 15
+				const uint16_t max_distance_considered = 15;
+				nearest_distance = std::min(nearest_distance, max_distance_considered);
+				prio += nearest_distance;
+
+				// take care about and enemies
 				if (bf->enemy_nearby_) {
 					prio /= 2;
 				}
 
-				if (bf->unowned_land_nearby_) {
+				if (bf->unowned_land_nearby_ && !bo.is_port_) {
 					prio /= 2;
 				}
 
-				// TODO(unknown): introduce check that there is no warehouse nearby
-				// to prevent too close placing
-
 			} else if (bo.type == BuildingObserver::TRAININGSITE) {
 
+				if (virtual_mines < 5) {
+					continue;
+				}
+
 				// exclude spots on border
 				if (bf->near_border_) {
 					continue;
 				}
 
-				if (virtual_mines<3) {
+				if (virtual_mines < 3) {
 					continue;
 				}
 
 				// build after 20 production sites and then after each 50 production site
-				if (static_cast<int32_t>((productionsites.size() + 30) / 50) > bo.total_count() &&
+				if (static_cast<int32_t>((productionsites.size() + 40) / 60) > bo.total_count() &&
 				    bo.cnt_under_construction_ == 0) {
 					prio = 4 + kDefaultPrioBoost;
 				}
@@ -1624,11 +1822,23 @@
 				continue;
 			}
 
+			// testing also vicinity
+			if (!bo.is_port_) {
+				if (port_reserved_coords.count(coords_hash(bf->coords)) > 0) {
+					continue;
+				}
+			}
+
 			// Prefer road side fields
 			prio += bf->preferred_ ? 1 : 0;
 			// don't waste good land for small huts
 			prio -= (maxsize - bo.desc->get_size()) * 5;
 
+			// prefer vicinity of ports (with exemption of warehouses)
+			if (bf->port_nearby_ && bo.type == BuildingObserver::MILITARYSITE) {
+				prio *= 2;
+			}
+
 			if (prio > proposed_priority) {
 				best_building = &bo;
 				proposed_priority = prio;
@@ -1708,6 +1918,13 @@
 						continue;
 					}
 
+					// prefer mines in the middle of mine fields of the
+					// same type, so we add a small bonus here
+					// depending on count of same mines nearby,
+					// though this does not reflects how many resources
+					// are (left) in nearby mines
+					prio += (*j)->same_mine_fields_nearby_ / 3;
+
 					// Continue if field is blocked at the moment
 					bool blocked = false;
 
@@ -1765,7 +1982,6 @@
 			block_time = 25 * 1000;
 			block_area = 6;
 		}
-		Map& map = game().map();
 
 		MapRegion<Area<FCoords>> mr(map, Area<FCoords>(map.get_fcoords(proposed_coords), block_area));
 		do {
@@ -1971,7 +2187,38 @@
 	// Increasing the failed_connection_tries counter
 	// At the same time it indicates a time an economy is without a warehouse
 	EconomyObserver* eco = get_economy_observer(flag.economy());
+
+	// there are two special situations which have a bit different treatment
+	bool is_remote_port_csite = false;
+	bool stationed_military = false;
 	if (flag.get_economy()->warehouses().empty()) {
+		// first very special case - lonesome port (in the phase of constructionsite)
+		// obviously it has no warehouse/road network to connect to
+		if (upcast(ConstructionSite const, constructionsite, flag.get_building())) {
+			BuildingObserver& bo = get_building_observer(constructionsite->building().name().c_str());
+			if (bo.is_port_ &&
+			    remote_ports_coords.count(coords_hash(flag.get_building()->get_position())) > 0) {
+				is_remote_port_csite = true;
+			}
+		}
+
+		// second exemption is when a military buiding was conquered, it
+		// might be just too far from near connected building
+		if (Building* b = flag.get_building()) {
+			if (upcast(MilitarySite, militb, b)) {
+				if (militb->present_soldiers().size() > 0) {
+					stationed_military = true;
+					// also increasing checkradius a bit
+					checkradius += 4;
+				}
+			}
+		}
+	}
+
+	if (is_remote_port_csite ||
+	    (stationed_military && game().get_gametime() % 10 > 0)) {  // counter disabled
+		;
+	} else if (flag.get_economy()->warehouses().empty()) {
 		eco->failed_connection_tries += 1;
 	} else {
 		eco->failed_connection_tries = 0;
@@ -2017,7 +2264,7 @@
 
 	for (const Coords& reachable_coords : reachable) {
 
-		// first make sure there is an immovable (shold be, but still)
+		// first make sure there is an immovable (should be, but still)
 		if (upcast(PlayerImmovable const, player_immovable, map[reachable_coords].get_immovable())) {
 
 			// if it is the road, make a flag there
@@ -2037,7 +2284,7 @@
 			}
 
 			// now make sure that this field has not been processed yet
-			const int32_t hash = reachable_coords.x << 16 | reachable_coords.y;
+			const uint32_t hash = coords_hash(reachable_coords);
 			if (lookuptable.count(hash) == 0) {
 				lookuptable.insert(hash);
 
@@ -2119,14 +2366,12 @@
 	for (std::vector<NearFlag>::iterator nf_walk_it = nearflags_tmp.begin();
 	     nf_walk_it != nearflags_tmp.end();
 	     ++nf_walk_it) {
-		int32_t const hash_walk =
-		   nf_walk_it->flag->get_position().x << 16 | nf_walk_it->flag->get_position().y;
+		uint32_t const hash_walk = coords_hash(nf_walk_it->flag->get_position());
 		if (lookuptable.count(hash_walk) > 0) {
-			// iterting over nearflags
+			// iterating over nearflags
 			for (std::vector<NearFlag>::iterator nf_it = nearflags.begin(); nf_it != nearflags.end();
 			     ++nf_it) {
-				int32_t const hash =
-				   nf_it->flag->get_position().x << 16 | nf_it->flag->get_position().y;
+				uint32_t const hash = coords_hash(nf_it->flag->get_position());
 				if (hash == hash_walk) {
 					// decreasing "cost" (of walking via roads)
 					if (nf_it->cost_ > nf_walk_it->cost_) {
@@ -2491,7 +2736,7 @@
 	}
 
 	// remaining buildings without inputs and not supporting ones (fishers only left probably and
-	// huters)
+	// hunters)
 
 	if (site.bo->inputs_.empty() && site.bo->production_hint_ < 0 &&
 	    site.site->can_start_working() && !site.bo->space_consumer_ &&
@@ -2539,6 +2784,217 @@
 	return changed;
 }
 
+// This function scans current situation with shipyards, ports, ships, ongoing expeditions
+// and makes two decisions:
+// - build a ship
+// - start preparation for expedition
+bool DefaultAI::marine_main_decisions(uint32_t const gametime) {
+	if (gametime < next_marine_decisions_due) {
+		return false;
+	}
+	next_marine_decisions_due += kMarineDecisionInterval;
+
+	if (!seafaring_economy) {
+		return false;
+	}
+
+	// getting some base statistics
+	player_ = game().get_player(player_number());
+	uint16_t ports_count = 0;
+	uint16_t shipyards_count = 0;
+	uint16_t working_shipyards_count = 0;
+	uint16_t expeditions_in_prep = 0;
+	uint16_t expeditions_in_progress = 0;
+	uint16_t territories_count = 1;
+	bool idle_shipyard_stocked = false;
+
+	// goes over all warehouses (these includes ports)
+	for (const WarehouseSiteObserver& wh_obs : warehousesites) {
+		if (wh_obs.bo->is_port_) {
+			ports_count += 1;
+			if (Widelands::PortDock* pd = wh_obs.site->get_portdock()) {
+				if (pd->expedition_started()) {
+					expeditions_in_prep += 1;
+				}
+			} else {
+				log("  there is a port without portdock at %3dx%3d?\n",
+				    wh_obs.site->get_position().x,
+				    wh_obs.site->get_position().y);
+			}
+		}
+	}
+
+	// goes over productionsites and gets status of shipyards
+	for (const ProductionSiteObserver& ps_obs : productionsites) {
+		if (ps_obs.bo->is_shipyard_) {
+			shipyards_count += 1;
+			if (!ps_obs.site->is_stopped()) {
+				working_shipyards_count += 1;
+			}
+			// counting stocks
+			uint8_t stocked_wares = 0;
+			std::vector<WaresQueue*> const warequeues = ps_obs.site->warequeues();
+			size_t const nr_warequeues = warequeues.size();
+			for (size_t i = 0; i < nr_warequeues; ++i) {
+				stocked_wares += warequeues[i]->get_filled();
+			}
+			if (stocked_wares == 16 && ps_obs.site->is_stopped()) {
+				idle_shipyard_stocked = true;
+			}
+		}
+	}
+
+	// and now over ships
+	for (std::list<ShipObserver>::iterator sp_iter = allships.begin(); sp_iter != allships.end();
+	     ++sp_iter) {
+		if (sp_iter->ship->state_is_expedition()) {
+			expeditions_in_progress += 1;
+		}
+	}
+
+	// we must verify that all remote ports are still ours (and exists at all)
+	bool still_ours;
+	for (std::unordered_set<uint32_t>::iterator ports_iter = remote_ports_coords.begin();
+	     ports_iter != remote_ports_coords.end();
+	     ++ports_iter) {
+		still_ours = false;
+		FCoords fcoords = game().map().get_fcoords(coords_unhash(*ports_iter));
+		if (fcoords.field->get_owned_by() == player_number()) {
+			if (upcast(PlayerImmovable, imm, fcoords.field->get_immovable())) {
+				still_ours = true;
+			}
+		}
+
+		if (!still_ours) {
+			remote_ports_coords.erase(*ports_iter);
+			break;
+		}
+	}
+	territories_count += remote_ports_coords.size();
+
+	enum class FleetStatus : uint8_t {kNeedShip = 0, kEnoughShips = 1, kDoNothing = 2 };
+
+	// now we must compare ports vs ships to decide if new ship is needed or new expedition can start
+	FleetStatus enough_ships = FleetStatus::kDoNothing;
+	if (static_cast<float>(allships.size()) >
+	    static_cast<float>((territories_count - 1) * 0.6 + ports_count * 0.75)) {
+		enough_ships = FleetStatus::kEnoughShips;
+	} else if (static_cast<float>(allships.size()) <
+	           static_cast<float>((territories_count - 1) * 0.6 + ports_count * 0.75)) {
+		enough_ships = FleetStatus::kNeedShip;
+	}
+
+	// building a ship? if yes, find a shipyard and order it to build a ship
+	if (shipyards_count > 0 && enough_ships == FleetStatus::kNeedShip && idle_shipyard_stocked &&
+	    ports_count > 0) {
+
+		for (const ProductionSiteObserver& ps_obs : productionsites) {
+			if (ps_obs.bo->is_shipyard_ && ps_obs.site->can_start_working() &&
+			    ps_obs.site->is_stopped()) {
+				// make sure it is fully stocked
+				// counting stocks
+				uint8_t stocked_wares = 0;
+				std::vector<WaresQueue*> const warequeues = ps_obs.site->warequeues();
+				size_t const nr_warequeues = warequeues.size();
+				for (size_t i = 0; i < nr_warequeues; ++i) {
+					stocked_wares += warequeues[i]->get_filled();
+				}
+				if (stocked_wares < 16) {
+					continue;
+				}
+
+				game().send_player_start_stop_building(*ps_obs.site);
+				return true;
+			}
+		}
+	}
+
+	// starting an expedition? if yes, find a port and order it to start an expedition
+	if (ports_count > 0 && enough_ships == FleetStatus::kEnoughShips && expeditions_in_prep == 0 &&
+	    expeditions_in_progress == 0) {
+		// we need to find a port
+		for (const WarehouseSiteObserver& wh_obs : warehousesites) {
+
+			if (wh_obs.bo->is_port_) {
+				game().send_player_start_or_cancel_expedition(*wh_obs.site);
+				return true;
+			}
+		}
+	}
+	return true;
+}
+
+// This identifies ships that are waiting for command
+bool DefaultAI::check_ships(uint32_t const gametime) {
+	if (gametime < next_ship_check_due) {
+		return false;
+	}
+
+	next_ship_check_due += kShipCheckInterval;
+
+	if (!seafaring_economy) {
+		return false;
+	}
+
+	if (!allships.empty()) {
+		// iterating over ships and executing what is needed
+		for (std::list<ShipObserver>::iterator i = allships.begin(); i != allships.end(); ++i) {
+
+			// only two states need an attention
+			if ((i->ship->get_ship_state() == Widelands::Ship::EXP_WAITING ||
+			     i->ship->get_ship_state() == Widelands::Ship::EXP_FOUNDPORTSPACE) &&
+			    !i->waiting_for_command_) {
+				if (gametime - i->last_command_time > 180 * 1000) {
+					i->waiting_for_command_ = true;
+					log("  %1d: last command for ship at %3dx%3d was %3d seconds ago, something wrong "
+					    "here?...\n",
+					    player_number(),
+					    i->ship->get_position().x,
+					    i->ship->get_position().y,
+					    (gametime - i->last_command_time) / 1000);
+				}
+			}
+			// if ships is waiting for command
+			if (i->waiting_for_command_) {
+				expedition_management(*i);
+			}
+		}
+	}
+
+	// processing marineTaskQueue_
+	while (!marineTaskQueue_.empty()) {
+		if (marineTaskQueue_.back() == kStopShipyard) {
+			// iterate over all production sites searching for shipyard
+			for (std::list<ProductionSiteObserver>::iterator site = productionsites.begin();
+			     site != productionsites.end();
+			     ++site) {
+				if (site->bo->is_shipyard_) {
+					if (!site->site->is_stopped()) {
+						game().send_player_start_stop_building(*site->site);
+					}
+				}
+			}
+		}
+
+		if (marineTaskQueue_.back() == kReprioritize) {
+			for (std::list<ProductionSiteObserver>::iterator site = productionsites.begin();
+			     site != productionsites.end();
+			     ++site) {
+				if (site->bo->is_shipyard_) {
+					for (uint32_t k = 0; k < site->bo->inputs_.size(); ++k) {
+						game().send_player_set_ware_priority(
+						   *site->site, wwWARE, site->bo->inputs_.at(k), HIGH_PRIORITY);
+					}
+				}
+			}
+		}
+
+		marineTaskQueue_.pop_back();
+	}
+
+	return true;
+}
+
 /**
  * checks the first mine in list, takes care if it runs out of
  * resources and finally reenqueues it at the end of the list.
@@ -2643,7 +3099,7 @@
                                      int16_t* max_preciousness,
                                      int16_t* max_needed_preciousness) {
 
-	// reseting values
+	// resetting values
 	*output_is_needed = false;
 	*max_preciousness = 0;
 	*max_needed_preciousness = 0;
@@ -2712,6 +3168,50 @@
 	return count;
 }
 
+// counts produced output in warehouses (only)
+// perhaps it will be able to replace get_stocklevel
+uint32_t DefaultAI::get_warehoused_stock(WareIndex wt) {
+	uint32_t count = 0;
+
+	for (std::list<WarehouseSiteObserver>::iterator i = warehousesites.begin();
+	     i != warehousesites.end();
+	     ++i) {
+		count += i->site->get_wares().stock(wt);
+	}
+
+	return count;
+}
+
+// this function only manipulates with trainingsites' inputs priority
+// decreases it when too many unoccupied military buildings
+bool DefaultAI::check_trainingsites(int32_t gametime) {
+	if (next_trainingsites_check_due_ > gametime) {
+		return false;
+	}
+	if (!trainingsites.empty()) {
+		next_trainingsites_check_due_ = gametime + kTrainingSitesCheckInterval;
+	} else {
+		next_trainingsites_check_due_ = gametime + 3 * kTrainingSitesCheckInterval;
+	}
+
+	uint8_t new_priority = DEFAULT_PRIORITY;
+	if (unstationed_milit_buildings_ > 2) {
+		new_priority = LOW_PRIORITY;
+	} else {
+		new_priority = DEFAULT_PRIORITY;
+	}
+	for (std::list<TrainingSiteObserver>::iterator site = trainingsites.begin();
+	     site != trainingsites.end();
+	     ++site) {
+
+		for (uint32_t k = 0; k < site->bo->inputs_.size(); ++k) {
+			game().send_player_set_ware_priority(
+			   *site->site, wwWARE, site->bo->inputs_.at(k), new_priority);
+		}
+	}
+	return true;
+}
+
 /**
  * Updates the first military building in list and reenques it at the end of
  * the list afterwards. If a militarysite is in secure area but holds more than
@@ -2726,7 +3226,7 @@
 	}
 
 	// just to be sure the value is reset
-	next_militarysite_check_due_ = gametime + 5 * 1000;  // 10 seconds is really fine
+	next_militarysite_check_due_ = gametime + 4 * 1000;  // 4 seconds is really fine
 	// even if there are no finished & attended military sites, probably there are ones just in
 	// construction
 	unstationed_milit_buildings_ = 0;
@@ -2754,7 +3254,7 @@
 	// look if there are any enemies building
 	FindNodeEnemiesBuilding find_enemy(player_, game());
 
-	// first if there are enemies nearby, check for buildings not land
+	// first we make sure there is no enemy at all
 	if (map.find_fields(Area<FCoords>(f, vision + 4), nullptr, find_enemy) == 0) {
 
 		mso.enemies_nearby_ = false;
@@ -2803,18 +3303,38 @@
 		}
 	} else {
 
+		int32_t unused1 = 0;
+		uint16_t unused2 = 0;
+
 		mso.enemies_nearby_ = true;
 
-		uint32_t const total_capacity = ms->max_soldier_capacity();
-		uint32_t const target_capacity = ms->soldier_capacity();
-
-		game().send_player_change_soldier_capacity(*ms, total_capacity - target_capacity);
-		changed = true;
-
-		// and also set preference to Heroes
-		if (MilitarySite::kPrefersHeroes != ms->get_soldier_preference()) {
-			game().send_player_militarysite_set_soldier_preference(*ms, MilitarySite::kPrefersHeroes);
+		// yes enemy is nearby, but still we must distinguish whether
+		// he is accessible (over the land)
+
+		if (other_player_accessible(
+		       vision + 4, &unused1, &unused2, ms->get_position(), WalkSearch::kOtherPlayers)) {
+
+			uint32_t const total_capacity = ms->max_soldier_capacity();
+			uint32_t const target_capacity = ms->soldier_capacity();
+
+			game().send_player_change_soldier_capacity(*ms, total_capacity - target_capacity);
 			changed = true;
+
+			// and also set preference to Heroes
+			if (MilitarySite::kPrefersHeroes != ms->get_soldier_preference()) {
+				game().send_player_militarysite_set_soldier_preference(
+				   *ms, MilitarySite::kPrefersHeroes);
+				changed = true;
+			}
+		} else {  // otherwise decrease soldiers
+			uint32_t const j = ms->soldier_capacity();
+
+			if (MilitarySite::kPrefersRookies != ms->get_soldier_preference()) {
+				game().send_player_militarysite_set_soldier_preference(
+				   *ms, MilitarySite::kPrefersRookies);
+			} else if (j > 1) {
+				game().send_player_change_soldier_capacity(*ms, (j > 2) ? -2 : -1);
+			}
 		}
 	}
 
@@ -2966,6 +3486,24 @@
 	}
 }
 
+// this is called whenever we gain ownership of a Ship
+void DefaultAI::gain_ship(Ship& ship, NewShip type) {
+
+	if (type == NewShip::kBuilt) {
+		marineTaskQueue_.push_back(kStopShipyard);
+	} else {
+		seafaring_economy = true;
+	}
+
+	allships.push_back(ShipObserver());
+	allships.back().ship = &ship;
+	if (game().get_gametime() % 2 == 0) {
+		allships.back().island_circ_direction = ScoutingDirection::kClockwise;
+	} else {
+		allships.back().island_circ_direction = ScoutingDirection::kCounterClockwise;
+	}
+}
+
 // this is called whenever we lose ownership of a PlayerImmovable
 void DefaultAI::lose_immovable(const PlayerImmovable& pi) {
 	if (upcast(Building const, building, &pi)) {
@@ -3005,13 +3543,242 @@
 		}
 }
 
+// walk and search for teritorry controlled by other player
+// usually scanning radius is enough but sometimes we must walk to
+// verify that an enemy teritory is really accessible by land
+bool DefaultAI::other_player_accessible(const uint32_t max_distance,
+                                        int32_t* tested_fields,
+                                        uint16_t* mineable_fields_count,
+                                        const Widelands::Coords starting_spot,
+                                        const WalkSearch type) {
+	Map& map = game().map();
+	std::list<uint32_t> queue;
+	std::unordered_set<uint32_t> done;
+	queue.push_front(coords_hash(starting_spot));
+	PlayerNumber const pn = player_->player_number();
+
+	while (!queue.empty()) {
+		// if already processed
+		if (done.count(queue.front()) > 0) {
+			queue.pop_front();
+			continue;
+		}
+
+		done.insert(queue.front());
+
+		Coords tmp_coords = coords_unhash(queue.front());
+
+		// if beyond range
+		if (map.calc_distance(starting_spot, tmp_coords) > max_distance) {
+			continue;
+		}
+
+		Field* f = map.get_fcoords(tmp_coords).field;
+
+		// not interested if not walkable (starting spot is an exemption.
+		if (tmp_coords != starting_spot && !(f->nodecaps() & MOVECAPS_WALK)) {
+			continue;
+		}
+
+		// sometimes we search for any owned teritory (f.e. when considering
+		//a port location), but when testing (starting from) own military building
+		//we must ignore own teritory, of course
+		if (f->get_owned_by() > 0) {
+			if (type == WalkSearch::kAnyPlayer ||
+			    (type == WalkSearch::kOtherPlayers && f->get_owned_by() != pn)) {
+				*tested_fields = done.size();
+				return true;
+			}
+		}
+
+		// increase mines counter
+		// (used when testing possible port location)
+		if (f->nodecaps() & BUILDCAPS_MINE) {
+			mineable_fields_count += 1;
+		};
+
+		// add neighbours to a queue (duplicates are no problem)
+		// to relieve AI/CPU we skip every second field in each direction
+		// obstacles are usually wider then one field
+		for (Direction dir = FIRST_DIRECTION; dir <= LAST_DIRECTION; ++dir) {
+			Coords neigh_coords1;
+			map.get_neighbour(tmp_coords, dir, &neigh_coords1);
+			Coords neigh_coords2;
+			map.get_neighbour(neigh_coords1, dir, &neigh_coords2);
+			queue.push_front(coords_hash(neigh_coords2));
+		}
+	}
+	*tested_fields = done.size();
+
+	return false;  // no players found
+}
+
+// this scores spot for potential colony
+uint8_t DefaultAI::spot_scoring(Widelands::Coords candidate_spot) {
+
+	uint8_t score = 0;
+	uint16_t mineable_fields_count = 0;
+	int32_t tested_fields = 0;
+	const bool other_player = other_player_accessible(colony_scan_area_,
+	                                                  &tested_fields,
+	                                                  &mineable_fields_count,
+	                                                  candidate_spot,
+	                                                  WalkSearch::kAnyPlayer);
+
+	// if we run into other player
+	// (maybe we should check for enemies, rather?)
+	if (other_player) {
+		return 0;
+	}
+
+	Map& map = game().map();
+	// if the island is too small
+	if (tested_fields < 50) {
+		return 0;
+	}
+
+	// if we are here we put score
+	score = 1;
+	if (mineable_fields_count > 0) {
+		score += 1;
+	}
+
+	// here we check for surface stones + trees
+	std::vector<ImmovableFound> immovables;
+	// Search in a radius of range
+	map.find_immovables(Area<FCoords>(map.get_fcoords(candidate_spot), 10), &immovables);
+
+	int32_t const stone_attr = MapObjectDescr::get_attribute_id("granite");
+	uint16_t stones = 0;
+	int32_t const tree_attr = MapObjectDescr::get_attribute_id("tree");
+	uint16_t trees = 0;
+
+	for (uint32_t j = 0; j < immovables.size(); ++j) {
+		if (immovables.at(j).object->has_attribute(stone_attr)) {
+			++stones;
+		}
+		if (immovables.at(j).object->has_attribute(tree_attr)) {
+			++trees;
+		}
+	}
+	if (stones > 1) {
+		score += 1;
+	}
+	if (trees > 1) {
+		score += 1;
+	}
+
+	return score;
+}
+
+// this is called whenever ship received a notification that requires
+// navigation decisions (these notifiation are processes not in 'real time')
+void DefaultAI::expedition_management(ShipObserver& so) {
+
+	Map& map = game().map();
+	const int32_t gametime = game().get_gametime();
+
+	// first we put current spot into visited_spots_
+	bool first_time_here = false;
+	if (so.visited_spots_.count(coords_hash(so.ship->get_position())) == 0) {
+		first_time_here = true;
+		so.visited_spots_.insert(coords_hash(so.ship->get_position()));
+	}
+
+	// If we have portspace following options are avaiable:
+	// 1. Build a port there
+	if (so.ship->exp_port_spaces()->size() > 0) {  // making sure we have possible portspaces
+
+		// we score the place
+		const uint8_t spot_score = spot_scoring(so.ship->exp_port_spaces()->front());
+
+		if ((gametime / 10) % 8 < spot_score) {  // we build a port here
+			const Coords last_portspace = so.ship->exp_port_spaces()->front();
+			remote_ports_coords.insert(coords_hash(last_portspace));
+			game().send_player_ship_construct_port(*so.ship, so.ship->exp_port_spaces()->front());
+			so.last_command_time = gametime;
+			so.waiting_for_command_ = false;
+			// blocking the area for some time to save AI from idle attempts to built there
+			// buildings
+			// TODO(TiborB): how long it takes to build a port?
+			// I used 5 minutes
+			MapRegion<Area<FCoords>> mr(
+			   game().map(), Area<FCoords>(map.get_fcoords(so.ship->exp_port_spaces()->front()), 8));
+			do {
+				BlockedField blocked2(
+				   map.get_fcoords(*(mr.location().field)), gametime + 5 * 60 * 1000);
+				blocked_fields.push_back(blocked2);
+			} while (mr.advance(map));
+
+			return;
+		}
+
+		// decreasing colony_scan_area_
+		if (colony_scan_area_ > 15 && gametime % 10 == 0) {
+			colony_scan_area_ -= 1;
+		}
+	}
+
+	// if we are here, port was not ordered above
+	// 2. Go on with expedition
+
+	if (first_time_here) {
+		game().send_player_ship_explore_island(*so.ship, so.island_circ_direction);
+		so.last_command_time = gametime;
+		so.waiting_for_command_ = false;
+
+		// we was here but to add randomnes we might continue with expedition
+	} else if (gametime % 2 == 0) {
+		game().send_player_ship_explore_island(*so.ship, so.island_circ_direction);
+		so.last_command_time = gametime;
+		so.waiting_for_command_ = false;
+	} else {
+		// get swimable directions
+		std::vector<Direction> possible_directions;
+		for (Direction dir = FIRST_DIRECTION; dir <= LAST_DIRECTION; ++dir) {
+
+			// testing distance of 8 fields
+			// this would say there is an 'open sea' there
+			Widelands::FCoords tmp_fcoords = map.get_fcoords(so.ship->get_position());
+			for (int8_t i = 0; i < 8; ++i) {
+				tmp_fcoords = map.get_neighbour(tmp_fcoords, dir);
+				if (tmp_fcoords.field->nodecaps() & MOVECAPS_SWIM) {
+					if (i == 7) {
+						possible_directions.push_back(dir);
+						break;  // not needed but.....
+					}
+				} else {
+					break;
+				}
+			}
+		}
+
+		// we test if there is open sea
+		if (possible_directions.empty()) {
+			// 2.A No there is no open sea
+			game().send_player_ship_explore_island(*so.ship, so.island_circ_direction);
+			so.last_command_time = gametime;
+			so.waiting_for_command_ = false;
+			;
+		} else {
+			// 2.B Yes, pick one of avaiable directions
+			const Direction final_direction =
+			   possible_directions.at(gametime % possible_directions.size());
+			game().send_player_ship_scout_direction(*so.ship, final_direction);
+			so.last_command_time = gametime;
+			so.waiting_for_command_ = false;
+		}
+	}
+	return;
+}
+
 // this is called whenever we gain a new building
 void DefaultAI::gain_building(Building& b) {
 	BuildingObserver& bo = get_building_observer(b.descr().name().c_str());
 
 	if (bo.type == BuildingObserver::CONSTRUCTIONSITE) {
 		BuildingObserver& target_bo =
-		   get_building_observer(dynamic_cast<ConstructionSite&>(b).building().name().c_str());
+		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
 		++target_bo.cnt_under_construction_;
 		++num_constructionsites_;
 		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
@@ -3034,6 +3801,10 @@
 			productionsites.back().unoccupied_till_ = game().get_gametime();
 			productionsites.back().stats_zero_ = 0;
 			productionsites.back().no_resources_count = 0;
+			if (bo.is_shipyard_) {
+				marineTaskQueue_.push_back(kStopShipyard);
+				marineTaskQueue_.push_back(kReprioritize);
+			}
 
 			for (uint32_t i = 0; i < bo.outputs_.size(); ++i)
 				++wares.at(bo.outputs_.at(i)).producers_;
@@ -3058,8 +3829,20 @@
 			militarysites.back().checks = bo.desc->get_size();
 			militarysites.back().enemies_nearby_ = true;
 
+		} else if (bo.type == BuildingObserver::TRAININGSITE) {
+			trainingsites.push_back(TrainingSiteObserver());
+			trainingsites.back().site = &dynamic_cast<TrainingSite&>(b);
+			trainingsites.back().bo = &bo;
+
 		} else if (bo.type == BuildingObserver::WAREHOUSE) {
 			++numof_warehouses_;
+			warehousesites.push_back(WarehouseSiteObserver());
+			warehousesites.back().site = &dynamic_cast<Warehouse&>(b);
+			warehousesites.back().bo = &bo;
+			if (bo.is_port_) {
+				++num_ports;
+				seafaring_economy = true;
+			}
 		}
 	}
 }
@@ -3069,8 +3852,8 @@
 	BuildingObserver& bo = get_building_observer(b.descr().name().c_str());
 
 	if (bo.type == BuildingObserver::CONSTRUCTIONSITE) {
-		BuildingObserver& target_bo = get_building_observer(
-			dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
+		BuildingObserver& target_bo =
+		   get_building_observer(dynamic_cast<const ConstructionSite&>(b).building().name().c_str());
 		--target_bo.cnt_under_construction_;
 		--num_constructionsites_;
 		if (target_bo.type == BuildingObserver::PRODUCTIONSITE) {
@@ -3126,9 +3909,31 @@
 					break;
 				}
 			}
+		} else if (bo.type == BuildingObserver::TRAININGSITE) {
+
+			for (std::list<TrainingSiteObserver>::iterator i = trainingsites.begin();
+			     i != trainingsites.end();
+			     ++i) {
+				if (i->site == &b) {
+					trainingsites.erase(i);
+					break;
+				}
+			}
 		} else if (bo.type == BuildingObserver::WAREHOUSE) {
 			assert(numof_warehouses_ > 0);
 			--numof_warehouses_;
+			if (bo.is_port_) {
+				--num_ports;
+			}
+
+			for (std::list<WarehouseSiteObserver>::iterator i = warehousesites.begin();
+			     i != warehousesites.end();
+			     ++i) {
+				if (i->site == &b) {
+					warehousesites.erase(i);
+					break;
+				}
+			}
 		}
 	}
 
@@ -3137,7 +3942,7 @@
 }
 
 // Checks that supply line exists for given building.
-// Recurcsively verify that all inputs_ have a producer.
+// Recursively verify that all inputs_ have a producer.
 // TODO(unknown): this function leads to periodic freezes of ~1 second on big games on my system.
 // TODO(unknown): It needs profiling and optimization.
 // NOTE: This is not needed anymore and it seems it is not missed neither
@@ -3168,7 +3973,7 @@
 
 bool DefaultAI::consider_attack(int32_t const gametime) {
 
-	// we presume that we are not attacking so we extend waitperiod
+	// we assume that we are not attacking so we extend waitperiod
 	// in case of attack the variable will be decreased below
 	// this is intended to save some CPU and add randomness in attacking
 	// and also differentiate according to type
@@ -3251,13 +4056,13 @@
 			if (genstats.at(j - 1).miltary_strength.empty()) {
 				log("ComputerPlayer(%d): miltary_strength is empty\n", player_number());
 				player_attackable.at(j - 1) = false;
-			// Avoid division by zero
+				// Avoid division by zero
 			} else if (genstats.at(j - 1).miltary_strength.back() == 0) {
 				player_attackable.at(j - 1) = true;
 				any_attackable = true;
-			// Check threshold
+				// Check threshold
 			} else if ((genstats.at(pn - 1).miltary_strength.back() * 100 /
-							genstats.at(j - 1).miltary_strength.back()) > treshold_ratio) {
+			            genstats.at(j - 1).miltary_strength.back()) > treshold_ratio) {
 				player_attackable.at(j - 1) = true;
 				any_attackable = true;
 			} else {
@@ -3265,7 +4070,8 @@
 			}
 		} catch (const std::out_of_range&) {
 			log("ComputerPlayer(%d): genstats entry missing - size :%d\n",
-				 player_number(), static_cast<unsigned int>(genstats.size()));
+			    player_number(),
+			    static_cast<unsigned int>(genstats.size()));
 			player_attackable.at(j - 1) = false;
 		}
 	}
@@ -3291,7 +4097,7 @@
 
 	for (uint32_t position = gametime % test_every; position < militarysites.size();
 	     position += test_every) {
-		// checked_own_ms_tmp += 1;
+
 		std::list<MilitarySiteObserver>::iterator mso = militarysites.begin();
 		std::advance(mso, position);
 
@@ -3311,10 +4117,8 @@
 		for (uint32_t j = 0; j < immovables.size(); ++j) {
 
 			// skip if in irrelevant_immovables
-			const uint32_t hash = immovables.at(j).coords.x << 16 | immovables.at(j).coords.y;
-			if (irrelevant_immovables.count(hash) > 0) {
-				continue;
-			} else {
+			const uint32_t hash = coords_hash(immovables.at(j).coords);
+			if (irrelevant_immovables.count(hash) == 0) {
 				irrelevant_immovables.insert(hash);
 			}
 
@@ -3337,7 +4141,6 @@
 						continue;
 					}
 
-					// target_buildings.push_back(immovables.at(j));
 					const int32_t soldiers_difference =
 					   player_->find_attack_soldiers(bld->base_flag()) - bld->present_soldiers().size();
 
@@ -3382,7 +4185,7 @@
 		}
 	}
 
-	// we allways try to attack warehouse first
+	// we always try to attack warehouse first
 	if (best_wh_target != nullptr && gametime % 2 == 0) {
 		// attacking with all attack-ready soldiers
 		int32_t attackers = player_->find_attack_soldiers(best_wh_target->base_flag());
@@ -3416,31 +4219,65 @@
 	}
 }
 
-// This is used for profiling, so usually this is not used :)
-void DefaultAI::print_land_stats() {
-	// this will just print statistics of land size
-	// intended for AI development only
-	uint32_t plr_in_game = 0;
-	uint32_t sum_l = 0;
-	uint32_t count_l = 0;
-	uint32_t sum_m = 0;
-	uint32_t count_m = 0;
-	PlayerNumber const nr_players = game().map().get_nrplayers();
-	iterate_players_existing_novar(p, nr_players, game())++ plr_in_game;
-	const Game::GeneralStatsVector& genstats = game().get_general_statistics();
-
-	for (uint8_t j = 1; j <= plr_in_game; ++j) {
-		log(" player: %1d, landsize: %5d, military strength: %3d\n",
-		    j,
-		    genstats[j - 1].land_size.back(),
-		    genstats[j - 1].miltary_strength.back());
-
-		sum_l += genstats[j - 1].land_size.back();
-		count_l += 1;
-		sum_m += genstats[j - 1].miltary_strength.back();
-		count_m += 1;
-	}
-
-	assert(count_l > 0 && count_m > 0);
-	log(" Average: Landsize: %5d, military strength: %3d\n", sum_l / count_l, sum_m / count_m);
+// This runs once in 15 minutes, and adjust wares targets based on number of
+// productionsites and ports
+void DefaultAI::review_wares_targets(int32_t const gametime) {
+
+	player_ = game().get_player(player_number());
+	tribe_ = &player_->tribe();
+
+	// to avoid floats real multiplicator is multiplicator/10
+	uint16_t multiplicator = 10;
+	if ((productionsites.size() + num_ports * 5) > 50) {
+		multiplicator = (productionsites.size() + num_ports * 5) / 5;
+	}
+
+	for (EconomyObserver* observer : economies) {
+		WareIndex nritems = observer->economy.owner().tribe().get_nrwares();
+		for (Widelands::WareIndex id = 0; id < nritems; ++id) {
+			const uint16_t default_target = tribe_->get_ware_descr(id)->default_target_quantity();
+
+			game().send_player_command(*new Widelands::CmdSetWareTargetQuantity(
+			                              gametime,
+			                              player_number(),
+			                              player_->get_economy_number(&observer->economy),
+			                              id,
+			                              default_target * multiplicator / 10));
+		}
+	}
+}
+
+// This prints some basic statistics during a game to the command line -
+// missing materials and counts of different types of buildings.
+// The main purpose of this is when a game creator needs to finetune a map
+// and needs to know what resourcess are missing for which player and so on.
+// By default it is off (see kPrintStats)
+// TODO(tiborb ?): - it would be nice to have this activated by a command line switch
+void DefaultAI::print_stats() {
+
+	PlayerNumber const pn = player_number();
+
+	//we test following materials
+	const std::vector <std::string> materials = {"coal", "log", "ironore", "marble",
+		 "plank", "water", "goldore", "granite", "fish", "diamond", "stone", "corn",
+		 "wheat", "grape", "quartz", "bread", "meat" };
+	std::string summary = "";
+	for (uint32_t j = 0; j < materials.size(); ++j) {
+		WareIndex const index = tribe_->ware_index(materials.at(j));
+		if (index == INVALID_INDEX) {
+			continue;
+		}
+		if (get_warehoused_stock(index) > 0) {
+			continue;
+		}
+		summary = summary + materials.at(j) + ", ";
+	}
+	log (" %1d: Buildings: Pr:%3d, Ml:%3d, Mi:%2d, Wh:%2d, Po:%2d. Missing: %s\n",
+		pn,
+		productionsites.size(),
+		militarysites.size(),
+		mines_.size(),
+		warehousesites.size() - num_ports,
+		num_ports,
+		summary.c_str());
 }

=== modified file 'src/ai/defaultai.h'
--- src/ai/defaultai.h	2014-10-17 19:13:39 +0000
+++ src/ai/defaultai.h	2015-02-10 21:28:25 +0000
@@ -22,11 +22,13 @@
 
 #include <map>
 #include <memory>
+#include <unordered_set>
 
 #include "ai/ai_help_structs.h"
 #include "ai/computer_player.h"
 #include "base/i18n.h"
 #include "logic/immovable.h"
+#include "logic/ship.h"
 
 namespace Widelands {
 struct Road;
@@ -76,6 +78,9 @@
 		DEFENSIVE = 0,
 	};
 
+	enum class WalkSearch : uint8_t {kAnyPlayer, kOtherPlayers };
+	enum class NewShip : uint8_t {kBuilt, kFoundOnLoad };
+
 	/// Implementation for Aggressive
 	struct AggressiveImpl : public ComputerPlayer::Implementation {
 		AggressiveImpl() {
@@ -130,6 +135,18 @@
 
 	bool construct_building(int32_t);
 
+	uint32_t coords_hash(Widelands::Coords coords) {
+		uint32_t hash = coords.x << 16 | coords.y;
+		return hash;
+	}
+
+	Widelands::Coords coords_unhash(uint32_t hash) {
+		Widelands::Coords coords;
+		coords.x = hash >> 16;  // is cast needed here???
+		coords.y = hash;
+		return coords;
+	}
+
 	// all road management is invoked by function improve_roads()
 	// if needed it calls create_shortcut_road() with a flag from which
 	// new road should be considered (or is needed)
@@ -139,18 +156,35 @@
 	bool dispensable_road_test(const Widelands::Road&);
 	bool check_economies();
 	bool check_productionsites(int32_t);
+	bool check_trainingsites(int32_t);
 	bool check_mines_(int32_t);
 	bool check_militarysites(int32_t);
+	bool marine_main_decisions(uint32_t);
+	bool check_ships(uint32_t);
+	void print_stats();
 	uint32_t get_stocklevel_by_hint(size_t);
 	uint32_t get_stocklevel(BuildingObserver&);
+	uint32_t get_warehoused_stock(Widelands::WareIndex wt);
 	uint32_t get_stocklevel(Widelands::WareIndex);  // count all direct outputs_
 	void check_helpersites(int32_t);
+	void review_wares_targets(int32_t);
+
+	// sometimes scanning an area in radius gives inappropriate results, so this is to verify that
+	// other player is accessible
+	// via walking
+	bool other_player_accessible(uint32_t max_distance,
+	                             int32_t* tested_fields,
+	                             uint16_t* mineable_fields_count,
+	                             const Widelands::Coords starting_spot,
+	                             const WalkSearch type);
 
 	int32_t recalc_with_border_range(const BuildableField&, int32_t);
 	int32_t calculate_need_for_ps(BuildingObserver&, int32_t);
 
 	void
 	consider_productionsite_influence(BuildableField&, Widelands::Coords, const BuildingObserver&);
+	// considering wood, stones, mines, water, fishes for candidate for colonization (new port)
+	uint8_t spot_scoring(Widelands::Coords candidate_spot);
 
 	EconomyObserver* get_economy_observer(Widelands::Economy&);
 	BuildingObserver& get_building_observer(char const*);
@@ -159,6 +193,8 @@
 	void lose_immovable(const Widelands::PlayerImmovable&);
 	void gain_building(Widelands::Building&);
 	void lose_building(const Widelands::Building&);
+	void gain_ship(Widelands::Ship&, NewShip);
+	void expedition_management(ShipObserver&);
 	void out_of_resources_site(const Widelands::ProductionSite&);
 
 	bool check_supply(const BuildingObserver&);
@@ -181,10 +217,14 @@
 	uint32_t num_constructionsites_;
 	uint32_t num_milit_constructionsites;
 	uint32_t num_prod_constructionsites;
+	uint32_t num_ports;
 
 	std::list<Widelands::FCoords> unusable_fields;
 	std::list<BuildableField*> buildable_fields;
 	std::list<BlockedField> blocked_fields;
+	std::unordered_set<uint32_t> port_reserved_coords;
+	// to distinquish which ports are on home teritory and which one are remote
+	std::unordered_set<uint32_t> remote_ports_coords;
 	std::list<MineableField*> mineable_fields;
 	std::list<Widelands::Flag const*> new_flags;
 	std::list<Widelands::Coords> flags_to_be_removed;
@@ -193,6 +233,9 @@
 	std::list<ProductionSiteObserver> productionsites;
 	std::list<ProductionSiteObserver> mines_;
 	std::list<MilitarySiteObserver> militarysites;
+	std::list<WarehouseSiteObserver> warehousesites;
+	std::list<TrainingSiteObserver> trainingsites;
+	std::list<ShipObserver> allships;
 
 	std::vector<WareObserver> wares;
 
@@ -203,9 +246,13 @@
 	int32_t next_productionsite_check_due_;
 	int32_t next_mine_check_due_;
 	int32_t next_militarysite_check_due_;
+	uint32_t next_ship_check_due;
+	uint32_t next_marine_decisions_due;
 	int32_t next_attack_consideration_due_;
-	int32_t next_helpersites_check_due_;
+	int32_t next_trainingsites_check_due_;
 	int32_t next_bf_check_due_;
+	int32_t next_wares_review_due_;
+	int32_t next_statistics_report_;
 	int32_t inhibit_road_building_;
 	int32_t time_of_last_construction_;
 	int32_t enemy_last_seen_;
@@ -232,13 +279,21 @@
 	Widelands::Coords
 	   last_attack_target_;         // flag to abuilding (position) that was attacked last time
 	int32_t next_attack_waittime_;  // second till the next attack consideration
-	int32_t spots_;                 // sum of buildable fields
+	bool seafaring_economy;         // false by default, until first port space is found
+	uint32_t colony_scan_area_;  // distance from a possible port that is scanned for owned territory
+	// it decreases with failed scans
+	int32_t spots_;  // sum of buildable fields
+
+	enum {kReprioritize, kStopShipyard, kStapShipyard };
+
+	std::vector<int16_t> marineTaskQueue_;
 
 	std::unique_ptr<Notifications::Subscriber<Widelands::NoteFieldPossession>>
 	   field_possession_subscriber_;
 	std::unique_ptr<Notifications::Subscriber<Widelands::NoteImmovable>> immovable_subscriber_;
 	std::unique_ptr<Notifications::Subscriber<Widelands::NoteProductionSiteOutOfResources>>
 	   outofresource_subscriber_;
+	std::unique_ptr<Notifications::Subscriber<Widelands::NoteShipMessage>> shipnotes_subscriber_;
 };
 
 #endif  // end of include guard: WL_AI_DEFAULTAI_H

=== modified file 'src/economy/fleet.cc'
--- src/economy/fleet.cc	2014-11-28 16:40:55 +0000
+++ src/economy/fleet.cc	2015-02-10 21:28:25 +0000
@@ -162,6 +162,13 @@
 		if (BaseImmovable * imm = cur.field->get_immovable()) {
 			if (imm->descr().type() == MapObjectType::PORTDOCK) {
 				if (upcast(PortDock, dock, imm)) {
+					// here might be a problem so I (tiborb) put here
+					// this test, might be removed after some time
+					if (dock->get_fleet() == nullptr) {
+						log ("The dock on %3dx%3d withouth a fleet!\n",
+						dock->m_dockpoints.front().x,
+						dock->m_dockpoints.front().y);
+					}
 					if (dock->get_fleet() != this && dock->get_owner() == get_owner()) {
 						dock->get_fleet()->merge(egbase, this);
 						return;

=== modified file 'src/economy/portdock.cc'
--- src/economy/portdock.cc	2014-12-11 21:32:41 +0000
+++ src/economy/portdock.cc	2015-02-10 21:28:25 +0000
@@ -21,6 +21,8 @@
 
 #include <memory>
 
+#include <boost/format.hpp>
+
 #include "base/log.h"
 #include "base/macros.h"
 #include "economy/fleet.h"
@@ -165,7 +167,14 @@
 }
 
 void PortDock::cleanup(EditorGameBase& egbase) {
+
+	Warehouse* wh = nullptr;
+
 	if (egbase.objects().object_still_available(m_warehouse)) {
+
+		//we need to remember this for possible recreation of portdock
+		wh = m_warehouse;
+
 		// Transfer all our wares into the warehouse.
 		if (upcast(Game, game, &egbase)) {
 			for (ShippingItem& shipping_item : m_waiting) {
@@ -203,6 +212,17 @@
 	}
 
 	PlayerImmovable::cleanup(egbase);
+
+	//now let attempt to recreate the portdock
+	if (!wh->m_cleanup_in_progress){
+		if (upcast(Game, game, &egbase)) {
+			if (game->is_loaded()) { //do not attempt when shutting down
+				Player& player = owner();
+				wh->restore_portdock_or_destroy(egbase);
+			}
+		}
+	}
+
 }
 
 /**

=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2015-01-31 16:03:59 +0000
+++ src/logic/game.cc	2015-02-10 21:28:25 +0000
@@ -888,11 +888,11 @@
 			(get_gametime(), ship.get_owner()->player_number(), ship.serial(), coords));
 }
 
-void Game::send_player_ship_explore_island(Ship & ship, bool cw)
+void Game::send_player_ship_explore_island(Ship & ship, ScoutingDirection direction)
 {
 	send_player_command
 		(*new CmdShipExploreIsland
-			(get_gametime(), ship.get_owner()->player_number(), ship.serial(), cw));
+			(get_gametime(), ship.get_owner()->player_number(), ship.serial(), direction));
 }
 
 void Game::send_player_sink_ship(Ship & ship) {

=== modified file 'src/logic/game.h'
--- src/logic/game.h	2015-01-31 16:03:59 +0000
+++ src/logic/game.h	2015-02-10 21:28:25 +0000
@@ -41,6 +41,7 @@
 struct Flag;
 struct Path;
 struct PlayerImmovable;
+enum class ScoutingDirection;
 struct Ship;
 struct PlayerEndStatus;
 class TrainingSite;
@@ -182,7 +183,7 @@
 
 	void send_player_ship_scout_direction(Ship &, uint8_t);
 	void send_player_ship_construct_port(Ship &, Coords);
-	void send_player_ship_explore_island(Ship &, bool);
+	void send_player_ship_explore_island(Ship &, ScoutingDirection);
 	void send_player_sink_ship(Ship &);
 	void send_player_cancel_expedition_ship(Ship &);
 

=== modified file 'src/logic/playercommand.cc'
--- src/logic/playercommand.cc	2014-09-30 07:55:22 +0000
+++ src/logic/playercommand.cc	2015-02-10 21:28:25 +0000
@@ -784,6 +784,16 @@
 {
 	upcast(Ship, ship, game.objects().get_object(serial));
 	if (ship && ship->get_owner()->player_number() == sender()) {
+		if (!(ship->get_ship_state() == Widelands::Ship::EXP_WAITING ||
+			ship->get_ship_state() == Widelands::Ship::EXP_FOUNDPORTSPACE)) {
+			log (" %1d:ship on %3dx%3d received scout command but not in "
+				"EXP_WAITING or PORTSPACE_FOUND status (expedition: %s), ignoring...\n",
+				ship->get_owner()->player_number(),
+				ship->get_position().x,
+				ship->get_position().y,
+				(ship->state_is_expedition())?"Y":"N");
+			return;
+		}
 		ship->exp_scout_direction(game, dir);
 	}
 }
@@ -841,6 +851,15 @@
 {
 	upcast(Ship, ship, game.objects().get_object(serial));
 	if (ship && ship->get_owner()->player_number() == sender()) {
+		if (ship->get_ship_state() != Widelands::Ship::EXP_FOUNDPORTSPACE) {
+			log (" %1d:ship on %3dx%3d received build port command but "
+			"not in PORTSPACE_FOUND status (expedition: %s), ignoring...\n",
+				ship->get_owner()->player_number(),
+				ship->get_position().x,
+				ship->get_position().y,
+				(ship->state_is_expedition())?"Y":"N");
+			return;
+		}
 		ship->exp_construct_port(game, coords);
 	}
 }
@@ -891,14 +910,24 @@
 	PlayerCommand (0, des.unsigned_8())
 {
 	serial = des.unsigned_32();
-	clockwise = des.unsigned_8() == 1;
+	scouting_direction = ScoutingDirection::kClockwise;
 }
 
 void CmdShipExploreIsland::execute (Game & game)
 {
 	upcast(Ship, ship, game.objects().get_object(serial));
 	if (ship && ship->get_owner()->player_number() == sender()) {
-		ship->exp_explore_island(game, clockwise);
+		if (!(ship->get_ship_state() == Widelands::Ship::EXP_WAITING ||
+			ship->get_ship_state() == Widelands::Ship::EXP_FOUNDPORTSPACE)) {
+			log (" %1d:ship on %3dx%3d received explore island command "
+			"but not in EXP_WAITING or PORTSPACE_FOUND status (expedition: %s), ignoring...\n",
+				ship->get_owner()->player_number(),
+				ship->get_position().x,
+				ship->get_position().y,
+				(ship->state_is_expedition())?"Y":"N");
+			return;
+		}
+		ship->exp_explore_island(game, scouting_direction);
 	}
 }
 
@@ -907,7 +936,7 @@
 	ser.unsigned_8 (PLCMD_SHIP_EXPLORE);
 	ser.unsigned_8 (sender());
 	ser.unsigned_32(serial);
-	ser.unsigned_8 (clockwise ? 1 : 0);
+	ser.unsigned_8 (static_cast<uint8_t>(scouting_direction));
 }
 
 #define PLAYER_CMD_SHIP_EXPLORE_ISLAND_VERSION 1
@@ -919,7 +948,7 @@
 		if (packet_version == PLAYER_CMD_SHIP_EXPLORE_ISLAND_VERSION) {
 			PlayerCommand::read(fr, egbase, mol);
 			serial = get_object_serial_or_zero<Ship>(fr.unsigned_32(), mol);
-			clockwise = fr.unsigned_8() == 1;
+			scouting_direction = static_cast<ScoutingDirection>(fr.unsigned_8());
 		} else
 			throw GameDataError("unknown/unhandled version %u", packet_version);
 	} catch (const WException & e) {
@@ -938,7 +967,7 @@
 	fw.unsigned_32(mos.get_object_file_index_or_zero(egbase.objects().get_object(serial)));
 
 	// Direction of exploration
-	fw.unsigned_8 (clockwise ? 1 : 0);
+	fw.unsigned_8(static_cast<uint8_t>(scouting_direction));
 }
 
 

=== modified file 'src/logic/playercommand.h'
--- src/logic/playercommand.h	2014-09-19 12:54:54 +0000
+++ src/logic/playercommand.h	2015-02-10 21:28:25 +0000
@@ -26,6 +26,7 @@
 #include "economy/flag.h"
 #include "logic/message_id.h"
 #include "logic/path.h"
+#include "logic/ship.h"
 #include "logic/trainingsite.h"
 #include "logic/warehouse.h"
 #include "logic/worker.h"
@@ -356,8 +357,8 @@
 struct CmdShipExploreIsland : public PlayerCommand {
 	CmdShipExploreIsland() : PlayerCommand(), serial(0) {} // For savegame loading
 	CmdShipExploreIsland
-		(int32_t const t, PlayerNumber const p, Serial s, bool cw)
-		: PlayerCommand(t, p), serial(s), clockwise(cw)
+		(int32_t const t, PlayerNumber const p, Serial s, ScoutingDirection direction)
+		: PlayerCommand(t, p), serial(s), scouting_direction(direction)
 	{}
 
 	void write(FileWrite &, EditorGameBase &, MapObjectSaver  &) override;
@@ -372,7 +373,7 @@
 
 private:
 	Serial serial;
-	bool clockwise;
+	ScoutingDirection scouting_direction;
 };
 
 struct CmdShipSink : public PlayerCommand {

=== modified file 'src/logic/productionsite.cc'
--- src/logic/productionsite.cc	2015-01-28 07:35:51 +0000
+++ src/logic/productionsite.cc	2015-02-10 21:28:25 +0000
@@ -212,7 +212,7 @@
 	delete[] m_working_positions;
 }
 
-void ProductionSite::load_finish(EditorGameBase & egbase){
+void ProductionSite::load_finish(EditorGameBase & egbase) {
 	Building::load_finish(egbase);
 	calc_statistics();
 }

=== modified file 'src/logic/ship.cc'
--- src/logic/ship.cc	2014-12-28 16:45:37 +0000
+++ src/logic/ship.cc	2015-02-10 21:28:25 +0000
@@ -49,24 +49,24 @@
 
 namespace Widelands {
 
-ShipDescr::ShipDescr
-	(const char * given_name, const char * gdescname,
-	 const std::string & directory, Profile & prof, Section & global_s,
-	 const TribeDescr & gtribe)
-	:
-	BobDescr(MapObjectType::SHIP, given_name, gdescname, &gtribe)
-{
-	{ //  global options
-		Section & idle_s = prof.get_safe_section("idle");
+ShipDescr::ShipDescr(const char* given_name,
+                     const char* gdescname,
+                     const std::string& directory,
+                     Profile& prof,
+                     Section& global_s,
+                     const TribeDescr& gtribe)
+   : BobDescr(MapObjectType::SHIP, given_name, gdescname, &gtribe) {
+	{  //  global options
+		Section& idle_s = prof.get_safe_section("idle");
 		add_animation("idle", g_gr->animations().load(directory, idle_s));
 	}
 	m_sail_anims.parse(*this, directory, prof, "sail");
 
-	Section * sinking_s = prof.get_section("sinking");
+	Section* sinking_s = prof.get_section("sinking");
 	if (sinking_s)
 		add_animation("sinking", g_gr->animations().load(directory, *sinking_s));
 
-	m_capacity     = global_s.get_natural("capacity", 20);
+	m_capacity = global_s.get_natural("capacity", 20);
 	m_vision_range = global_s.get_natural("vision_range", 7);
 }
 
@@ -74,18 +74,12 @@
 	return MOVECAPS_SWIM;
 }
 
-Bob & ShipDescr::create_object() const {
+Bob& ShipDescr::create_object() const {
 	return *new Ship(*this);
 }
 
-
-Ship::Ship(const ShipDescr & gdescr) :
-	Bob(gdescr),
-	m_window(nullptr),
-	m_fleet(nullptr),
-	m_economy(nullptr),
-	m_ship_state(TRANSPORT)
-{
+Ship::Ship(const ShipDescr& gdescr)
+   : Bob(gdescr), m_window(nullptr), m_fleet(nullptr), m_economy(nullptr), m_ship_state(TRANSPORT) {
 }
 
 Ship::~Ship() {
@@ -104,13 +98,14 @@
 	return m_fleet;
 }
 
-void Ship::init_auto_task(Game & game) {
+void Ship::init_auto_task(Game& game) {
 	start_task_ship(game);
 }
 
-void Ship::init(EditorGameBase & egbase) {
+void Ship::init(EditorGameBase& egbase) {
 	Bob::init(egbase);
 	init_fleet(egbase);
+	Notifications::publish(NoteShipMessage(this, NoteShipMessage::Message::kGained));
 }
 
 /**
@@ -118,15 +113,15 @@
  * The fleet code will automatically merge us into a larger
  * fleet, if one is reachable.
  */
-void Ship::init_fleet(EditorGameBase & egbase) {
+void Ship::init_fleet(EditorGameBase& egbase) {
 	assert(get_owner() != nullptr);
-	Fleet * fleet = new Fleet(*get_owner());
+	Fleet* fleet = new Fleet(*get_owner());
 	fleet->add_ship(this);
 	fleet->init(egbase);
 	// fleet calls the set_fleet function appropriately
 }
 
-void Ship::cleanup(EditorGameBase & egbase) {
+void Ship::cleanup(EditorGameBase& egbase) {
 	if (m_fleet) {
 		m_fleet->remove_ship(egbase, this);
 	}
@@ -136,58 +131,56 @@
 		m_items.pop_back();
 	}
 
+	Notifications::publish(NoteShipMessage(this, NoteShipMessage::Message::kLost));
+
 	Bob::cleanup(egbase);
 }
 
 /**
  * This function is to be called only by @ref Fleet.
  */
-void Ship::set_fleet(Fleet * fleet) {
+void Ship::set_fleet(Fleet* fleet) {
 	m_fleet = fleet;
 }
 
-void Ship::wakeup_neighbours(Game & game) {
+void Ship::wakeup_neighbours(Game& game) {
 	FCoords position = get_position();
 	Area<FCoords> area(position, 1);
-	std::vector<Bob *> ships;
+	std::vector<Bob*> ships;
 	game.map().find_bobs(area, &ships, FindBobShip());
 
-	for
-		(std::vector<Bob *>::const_iterator it = ships.begin();
-		 it != ships.end(); ++it)
-	{
+	for (std::vector<Bob*>::const_iterator it = ships.begin(); it != ships.end(); ++it) {
 		if (*it == this)
 			continue;
 
-		static_cast<Ship *>(*it)->ship_wakeup(game);
+		static_cast<Ship*>(*it)->ship_wakeup(game);
 	}
 }
 
-
 /**
  * Standard behaviour of ships.
  *
  * ivar1 = helper flag for coordination of mutual evasion of ships
  */
 const Bob::Task Ship::taskShip = {
-	"ship",
-	static_cast<Bob::Ptr>(&Ship::ship_update),
-	nullptr,
-	nullptr,
-	true // unique task
+   "ship",
+   static_cast<Bob::Ptr>(&Ship::ship_update),
+   nullptr,
+   nullptr,
+	true  // unique task
 };
 
-void Ship::start_task_ship(Game & game) {
+void Ship::start_task_ship(Game& game) {
 	push_task(game, taskShip);
 	top_state().ivar1 = 0;
 }
 
-void Ship::ship_wakeup(Game & game) {
+void Ship::ship_wakeup(Game& game) {
 	if (get_state(taskShip))
 		send_signal(game, "wakeup");
 }
 
-void Ship::ship_update(Game & game, Bob::State & state) {
+void Ship::ship_update(Game& game, Bob::State& state) {
 	// Handle signals
 	std::string signal = get_signal();
 	if (!signal.empty()) {
@@ -211,44 +204,43 @@
 	}
 
 	switch (m_ship_state) {
-		case TRANSPORT:
-			if (ship_update_transport(game, state))
-				return;
-			break;
-		case EXP_FOUNDPORTSPACE:
-		case EXP_SCOUTING:
-		case EXP_WAITING:
-			ship_update_expedition(game, state);
-			break;
-		case EXP_COLONIZING:
-			break;
-		case SINK_REQUEST:
-			if (descr().is_animation_known("sinking")) {
-				m_ship_state = SINK_ANIMATION;
-				start_task_idle(game, descr().get_animation("sinking"), 3000);
-				return;
-			}
-			log("Oh no... this ship has no sinking animation :(!\n");
-			// fall trough
-		case SINK_ANIMATION:
-			// The sink animation has been played, so finally remove the ship from the map
-			pop_task(game);
-			remove(game);
-			return;
-		default:
-			assert(false); // never here
+	case TRANSPORT:
+		if (ship_update_transport(game, state))
+			return;
+		break;
+	case EXP_FOUNDPORTSPACE:
+	case EXP_SCOUTING:
+	case EXP_WAITING:
+		ship_update_expedition(game, state);
+		break;
+	case EXP_COLONIZING:
+		break;
+	case SINK_REQUEST:
+		if (descr().is_animation_known("sinking")) {
+			m_ship_state = SINK_ANIMATION;
+			start_task_idle(game, descr().get_animation("sinking"), 3000);
+			return;
+		}
+		log("Oh no... this ship has no sinking animation :(!\n");
+	// fall trough
+	case SINK_ANIMATION:
+		// The sink animation has been played, so finally remove the ship from the map
+		pop_task(game);
+		remove(game);
+		return;
+	default:
+		assert(false);  // never here
 	}
 
 	// if the real update function failed (e.g. nothing to transport), the ship goes idle
 	ship_update_idle(game, state);
 }
 
-
 /// updates a ships tasks in transport mode \returns false if failed to update tasks
-bool Ship::ship_update_transport(Game & game, Bob::State &) {
-	Map & map = game.map();
+bool Ship::ship_update_transport(Game& game, Bob::State&) {
+	Map& map = game.map();
 
-	PortDock * dst = get_destination(game);
+	PortDock* dst = get_destination(game);
 	if (!dst) {
 		molog("ship_update: No destination anymore.\n");
 		if (m_items.empty())
@@ -277,7 +269,7 @@
 
 	molog("ship_update: Go to dock %u\n", dst->serial());
 
-	PortDock * lastdock = m_lastdock.get(game);
+	PortDock* lastdock = m_lastdock.get(game);
 	if (lastdock && lastdock != dst) {
 		molog("ship_update: Have lastdock %u\n", lastdock->serial());
 
@@ -332,10 +324,9 @@
 	return true;
 }
 
-
 /// updates a ships tasks in expedition mode
-void Ship::ship_update_expedition(Game & game, Bob::State &) {
-	Map & map = game.map();
+void Ship::ship_update_expedition(Game& game, Bob::State&) {
+	Map& map = game.map();
 
 	assert(m_expedition);
 
@@ -343,30 +334,30 @@
 	FCoords position = get_position();
 	for (Direction dir = FIRST_DIRECTION; dir <= LAST_DIRECTION; ++dir) {
 		m_expedition->swimable[dir - 1] =
-			map.get_neighbour(position, dir).field->nodecaps() & MOVECAPS_SWIM;
+		   map.get_neighbour(position, dir).field->nodecaps() & MOVECAPS_SWIM;
 	}
 
 	if (m_ship_state == EXP_SCOUTING) {
 		// Check surrounding fields for port buildspaces
-		std::unique_ptr<std::list<Coords> > temp_port_buildspaces(new std::list<Coords>());
-		MapRegion<Area<Coords> > mr(map, Area<Coords>(position, descr().vision_range()));
+		std::unique_ptr<std::list<Coords>> temp_port_buildspaces(new std::list<Coords>());
+		MapRegion<Area<Coords>> mr(map, Area<Coords>(position, descr().vision_range()));
 		bool new_port_space = false;
 		do {
 			if (map.is_port_space(mr.location())) {
 				FCoords fc = map.get_fcoords(mr.location());
 
-				// Check whether the maximum theoretical possible NodeCap of the field is of the size big
+				// Check whether the maximum theoretical possible NodeCap of the field is of the size
+				// big
 				// and whether it can theoretically be a port space
-				if
-					((map.get_max_nodecaps(game.world(), fc) & BUILDCAPS_SIZEMASK) != BUILDCAPS_BIG
-					 ||
-					 map.find_portdock(fc).empty())
-				{
+				if ((map.get_max_nodecaps(game.world(), fc) & BUILDCAPS_SIZEMASK) != BUILDCAPS_BIG ||
+				    map.find_portdock(fc).empty()) {
 					continue;
 				}
 
-				// NOTE This is the place to handle enemy territory and "clearing a port space from the enemy".
-				// NOTE There is a simple check for the current land owner to avoid placement of ports into enemy
+				// NOTE This is the place to handle enemy territory and "clearing a port space from the
+				// enemy".
+				// NOTE There is a simple check for the current land owner to avoid placement of ports
+				// into enemy
 				// NOTE territory, as "clearing" is not yet implemented.
 				// NOTE further it checks, whether there is a Player_immovable on one of the fields.
 				// TODO(unknown): handle this more gracefully concering opposing players
@@ -378,7 +369,7 @@
 						invalid = true;
 						continue;
 					}
-					BaseImmovable * baim = coord.field->get_immovable();
+					BaseImmovable* baim = coord.field->get_immovable();
 					if (baim)
 						if (is_a(PlayerImmovable, baim)) {
 							invalid = true;
@@ -387,60 +378,60 @@
 
 					// Check all neighboured fields that will be used by the port
 					switch (step) {
-						case 0:
-							map.get_ln(fc, &coord);
-							break;
-						case 1:
-							map.get_tln(fc, &coord);
-							break;
-						case 2:
-							map.get_trn(fc, &coord);
-							break;
-						case 3:
-							// Flag coordinate
-							map.get_brn(fc, &coord);
-							break;
-						default:
-							break;
+					case 0:
+						map.get_ln(fc, &coord);
+						break;
+					case 1:
+						map.get_tln(fc, &coord);
+						break;
+					case 2:
+						map.get_trn(fc, &coord);
+						break;
+					case 3:
+						// Flag coordinate
+						map.get_brn(fc, &coord);
+						break;
+					default:
+						break;
 					}
 				}
 				// Now check whether there is a flag in the surroundings of the flag position
 				FCoords neighb;
 				map.get_ln(coord, &neighb);
 				for (uint8_t step = 0; !invalid && step < 5; ++step) {
-					BaseImmovable * baim = neighb.field->get_immovable();
+					BaseImmovable* baim = neighb.field->get_immovable();
 					if (baim)
 						if (is_a(Flag, baim)) {
 							invalid = true;
 							continue;
 						}
-					// Check all neighboured fields but not the one already checked for a PlayerImmovable.
+					// Check all neighboured fields but not the one already checked for a
+					// PlayerImmovable.
 					switch (step) {
-						case 0:
-							map.get_bln(coord, &neighb);
-							break;
-						case 1:
-							map.get_brn(coord, &neighb);
-							break;
-						case 2:
-							map.get_rn(coord, &neighb);
-							break;
-						case 3:
-							map.get_trn(coord, &neighb);
-							break;
-						default:
-							break;
+					case 0:
+						map.get_bln(coord, &neighb);
+						break;
+					case 1:
+						map.get_brn(coord, &neighb);
+						break;
+					case 2:
+						map.get_rn(coord, &neighb);
+						break;
+					case 3:
+						map.get_trn(coord, &neighb);
+						break;
+					default:
+						break;
 					}
 				}
 				if (invalid)
 					continue;
 
 				bool pbs_saved = false;
-				for
-					(std::list<Coords>::const_iterator it = m_expedition->seen_port_buildspaces->begin();
-					 it != m_expedition->seen_port_buildspaces->end() && !pbs_saved;
-					 ++it)
-				{
+				for (std::list<Coords>::const_iterator it =
+				        m_expedition->seen_port_buildspaces->begin();
+				     it != m_expedition->seen_port_buildspaces->end() && !pbs_saved;
+				     ++it) {
 					// Check if the ship knows this port space already from its last check
 					if (*it == mr.location()) {
 						temp_port_buildspaces->push_back(mr.location());
@@ -462,10 +453,14 @@
 			send_message(game, msg_head, msg_body, "port.png");
 		}
 		m_expedition->seen_port_buildspaces.swap(temp_port_buildspaces);
+		if (new_port_space) {
+			Notifications::publish(
+			   NoteShipMessage(this, NoteShipMessage::Message::kWaitingForCommand));
+		}
 	}
 }
 
-void Ship::ship_update_idle(Game & game, Bob::State & state) {
+void Ship::ship_update_idle(Game& game, Bob::State& state) {
 	if (state.ivar1) {
 		// We've just completed one step, so give neighbours
 		// a chance to move away first
@@ -475,172 +470,187 @@
 		return;
 	}
 
-	// If we are waiting for the next transport job, check if we should move away from ships and shores
+	// If we are waiting for the next transport job, check if we should move away from ships and
+	// shores
 	switch (m_ship_state) {
-		case TRANSPORT: {
-			FCoords position = get_position();
-			Map & map = game.map();
-			unsigned int dirs[LAST_DIRECTION + 1];
-			unsigned int dirmax = 0;
-
+	case TRANSPORT: {
+		FCoords position = get_position();
+		Map& map = game.map();
+		unsigned int dirs[LAST_DIRECTION + 1];
+		unsigned int dirmax = 0;
+
+		for (Direction dir = 0; dir <= LAST_DIRECTION; ++dir) {
+			FCoords node = dir ? map.get_neighbour(position, dir) : position;
+			dirs[dir] = node.field->nodecaps() & MOVECAPS_WALK ? 10 : 0;
+
+			Area<FCoords> area(node, 0);
+			std::vector<Bob*> ships;
+			map.find_bobs(area, &ships, FindBobShip());
+
+			for (std::vector<Bob*>::const_iterator it = ships.begin(); it != ships.end(); ++it) {
+				if (*it == this)
+					continue;
+
+				dirs[dir] += 3;
+			}
+
+			dirmax = std::max(dirmax, dirs[dir]);
+		}
+
+		if (dirmax) {
+			unsigned int prob[LAST_DIRECTION + 1];
+			unsigned int totalprob = 0;
+
+			// The probability for moving into a given direction is also
+			// affected by the "close" directions.
 			for (Direction dir = 0; dir <= LAST_DIRECTION; ++dir) {
-				FCoords node = dir ? map.get_neighbour(position, dir) : position;
-				dirs[dir] = node.field->nodecaps() & MOVECAPS_WALK ? 10 : 0;
-
-				Area<FCoords> area(node, 0);
-				std::vector<Bob *> ships;
-				map.find_bobs(area, &ships, FindBobShip());
-
-				for (std::vector<Bob *>::const_iterator it = ships.begin(); it != ships.end(); ++it) {
-					if (*it == this)
-						continue;
-
-					dirs[dir] += 3;
-				}
-
-				dirmax = std::max(dirmax, dirs[dir]);
-			}
-
-			if (dirmax) {
-				unsigned int prob[LAST_DIRECTION + 1];
-				unsigned int totalprob = 0;
-
-				// The probability for moving into a given direction is also
-				// affected by the "close" directions.
-				for (Direction dir = 0; dir <= LAST_DIRECTION; ++dir) {
-					prob[dir] = 10 * dirmax - 10 * dirs[dir];
-
-					if (dir > 0) {
-						unsigned int delta = std::min(prob[dir], dirs[(dir % 6) + 1] + dirs[1 + ((dir - 1) % 6)]);
-						prob[dir] -= delta;
-					}
-
-					totalprob += prob[dir];
-				}
-
-				if (totalprob == 0) {
-					start_task_idle(game, descr().main_animation(), 1500);
-					return;
-				}
-
-				unsigned int rnd = game.logic_rand() % totalprob;
-				Direction dir = 0;
-				while (rnd >= prob[dir]) {
-					rnd -= prob[dir];
-					++dir;
-				}
-
-				if (dir == 0 || dir > LAST_DIRECTION) {
-					start_task_idle(game, descr().main_animation(), 1500);
-					return;
-				}
-
-				FCoords neighbour = map.get_neighbour(position, dir);
-				if (!(neighbour.field->nodecaps() & MOVECAPS_SWIM)) {
-					start_task_idle(game, descr().main_animation(), 1500);
-					return;
-				}
-
-				state.ivar1 = 1;
-				start_task_move(game, dir, descr().get_sail_anims(), false);
-				return;
-			}
-			// No desire to move around, so sleep
-			start_task_idle(game, descr().main_animation(), -1);
+				prob[dir] = 10 * dirmax - 10 * dirs[dir];
+
+				if (dir > 0) {
+					unsigned int delta =
+					   std::min(prob[dir], dirs[(dir % 6) + 1] + dirs[1 + ((dir - 1) % 6)]);
+					prob[dir] -= delta;
+				}
+
+				totalprob += prob[dir];
+			}
+
+			if (totalprob == 0) {
+				start_task_idle(game, descr().main_animation(), 1500);
+				return;
+			}
+
+			unsigned int rnd = game.logic_rand() % totalprob;
+			Direction dir = 0;
+			while (rnd >= prob[dir]) {
+				rnd -= prob[dir];
+				++dir;
+			}
+
+			if (dir == 0 || dir > LAST_DIRECTION) {
+				start_task_idle(game, descr().main_animation(), 1500);
+				return;
+			}
+
+			FCoords neighbour = map.get_neighbour(position, dir);
+			if (!(neighbour.field->nodecaps() & MOVECAPS_SWIM)) {
+				start_task_idle(game, descr().main_animation(), 1500);
+				return;
+			}
+
+			state.ivar1 = 1;
+			start_task_move(game, dir, descr().get_sail_anims(), false);
 			return;
 		}
-		case EXP_SCOUTING: {
-			if (m_expedition->island_exploration) { // Exploration of the island
-				if (exp_close_to_coast()) {
-					if (m_expedition->direction == 0) {
-						// Make sure we know the location of the coast and use it as initial direction we come from
-						m_expedition->direction = WALK_SE;
-						for (uint8_t secure = 0; exp_dir_swimable(m_expedition->direction); ++secure) {
-							assert(secure < 6);
-							m_expedition->direction = get_cw_neighbour(m_expedition->direction);
-						}
-						m_expedition->direction = get_backward_dir(m_expedition->direction);
-						// Save the position - this is where we start
-						m_expedition->exploration_start = get_position();
-					} else {
-						// Check whether the island was completely surrounded
-						if (get_position() == m_expedition->exploration_start) {
-							std::string msg_head = _("Island Circumnavigated");
-							std::string msg_body = _("An expedition ship sailed around its"
-										 " island without any events.");
-							send_message(game, msg_head, msg_body,
-								"ship_explore_island_cw.png");
-							m_ship_state = EXP_WAITING;
-							return start_task_idle(game, descr().main_animation(), 1500);
-						}
+		// No desire to move around, so sleep
+		start_task_idle(game, descr().main_animation(), -1);
+		return;
+	}
+
+	case EXP_SCOUTING: {
+		if (m_expedition->island_exploration) {  // Exploration of the island
+			if (exp_close_to_coast()) {
+				if (m_expedition->direction == 0) {
+					// Make sure we know the location of the coast and use it as initial direction we
+					// come from
+					m_expedition->direction = WALK_SE;
+					for (uint8_t secure = 0; exp_dir_swimable(m_expedition->direction); ++secure) {
+						assert(secure < 6);
+						m_expedition->direction = get_cw_neighbour(m_expedition->direction);
 					}
-					// The ship is supposed to follow the coast as close as possible, therefore the check for
-					// a swimable field begins at the neighbour field of the direction we came from.
 					m_expedition->direction = get_backward_dir(m_expedition->direction);
-					if (m_expedition->clockwise) {
-						do {
-							m_expedition->direction = get_ccw_neighbour(m_expedition->direction);
-						} while (!exp_dir_swimable(m_expedition->direction));
-					} else {
-						do {
-							m_expedition->direction = get_cw_neighbour(m_expedition->direction);
-						} while (!exp_dir_swimable(m_expedition->direction));
-					}
-					state.ivar1 = 1;
-					return start_task_move(game, m_expedition->direction, descr().get_sail_anims(), false);
-				} else {
-					// The ship got the command to scout around an island, but is not close to any island
-					// Most likely the command was send as the ship was on an exploration and just leaving
-					// the island - therefore we try to find the island again.
-					FCoords position = get_position();
-					Map & map = game.map();
-					for (uint8_t dir = FIRST_DIRECTION; dir <= LAST_DIRECTION; ++dir) {
-						FCoords neighbour = map.get_neighbour(position, dir);
-						for (uint8_t sur = FIRST_DIRECTION; sur <= LAST_DIRECTION; ++sur)
-							if (!(map.get_neighbour(neighbour, sur).field->nodecaps() & MOVECAPS_SWIM)) {
-								// Okay we found the next coast, so now the ship should go there.
-								// However, we do neither save the position as starting position, nor do we save
-								// the direction we currently go. So the ship can start exploring normally
-								state.ivar1 = 1;
-								return start_task_move(game, dir, descr().get_sail_anims(), false);
-							}
-					}
-					// if we are here, it seems something really strange happend.
-					log("WARNING: ship was not able to start exploration. Entering WAIT mode.");
-					m_ship_state = EXP_WAITING;
-					return start_task_idle(game, descr().main_animation(), 1500);
-				}
-			} else { // scouting towards a specific direction
-				if (exp_dir_swimable(m_expedition->direction)) {
-					// the scouting direction is still free to move
-					state.ivar1 = 1;
-					start_task_move(game, m_expedition->direction, descr().get_sail_anims(), false);
-					return;
-				}
-				// coast reached
+					// Save the position - this is where we start
+					m_expedition->exploration_start = get_position();
+				} else {
+					// Check whether the island was completely surrounded
+					if (get_position() == m_expedition->exploration_start) {
+						std::string msg_head = _("Island Circumnavigated");
+						std::string msg_body = _("An expedition ship sailed around its"
+						                         " island without any events.");
+						send_message(game, msg_head, msg_body, "ship_explore_island_cw.png");
+						m_ship_state = EXP_WAITING;
+
+						Notifications::publish(
+						   NoteShipMessage(this, NoteShipMessage::Message::kWaitingForCommand));
+
+						return start_task_idle(game, descr().main_animation(), 1500);
+					}
+				}
+				// The ship is supposed to follow the coast as close as possible, therefore the check
+				// for
+				// a swimable field begins at the neighbour field of the direction we came from.
+				m_expedition->direction = get_backward_dir(m_expedition->direction);
+				if (m_expedition->scouting_direction == ScoutingDirection::kClockwise) {
+					do {
+						m_expedition->direction = get_ccw_neighbour(m_expedition->direction);
+					} while (!exp_dir_swimable(m_expedition->direction));
+				} else {
+					do {
+						m_expedition->direction = get_cw_neighbour(m_expedition->direction);
+					} while (!exp_dir_swimable(m_expedition->direction));
+				}
+				state.ivar1 = 1;
+				return start_task_move(game, m_expedition->direction, descr().get_sail_anims(), false);
+			} else {
+				// The ship got the command to scout around an island, but is not close to any island
+				// Most likely the command was send as the ship was on an exploration and just leaving
+				// the island - therefore we try to find the island again.
+				FCoords position = get_position();
+				Map& map = game.map();
+				for (uint8_t dir = FIRST_DIRECTION; dir <= LAST_DIRECTION; ++dir) {
+					FCoords neighbour = map.get_neighbour(position, dir);
+					for (uint8_t sur = FIRST_DIRECTION; sur <= LAST_DIRECTION; ++sur)
+						if (!(map.get_neighbour(neighbour, sur).field->nodecaps() & MOVECAPS_SWIM)) {
+							// Okay we found the next coast, so now the ship should go there.
+							// However, we do neither save the position as starting position, nor do we
+							// save
+							// the direction we currently go. So the ship can start exploring normally
+							state.ivar1 = 1;
+							return start_task_move(game, dir, descr().get_sail_anims(), false);
+						}
+				}
+				// if we are here, it seems something really strange happend.
+				log("WARNING: ship was not able to start exploration. Entering WAIT mode.");
 				m_ship_state = EXP_WAITING;
-				start_task_idle(game, descr().main_animation(), 1500);
-				// Send a message to the player, that a new coast was reached
-				std::string msg_head = _("Coast Reached");
-				std::string msg_body =
-					_("An expedition ship reached a coast and is waiting for further commands.");
-				send_message(game, msg_head, msg_body, "ship_explore_island_cw.png");
+				return start_task_idle(game, descr().main_animation(), 1500);
+			}
+		} else {  // scouting towards a specific direction
+			if (exp_dir_swimable(m_expedition->direction)) {
+				// the scouting direction is still free to move
+				state.ivar1 = 1;
+				start_task_move(game, m_expedition->direction, descr().get_sail_anims(), false);
 				return;
 			}
+			// coast reached
+			m_ship_state = EXP_WAITING;
+			start_task_idle(game, descr().main_animation(), 1500);
+			// Send a message to the player, that a new coast was reached
+			std::string msg_head = _("Coast Reached");
+			std::string msg_body =
+			   _("An expedition ship reached a coast and is waiting for further commands.");
+			send_message(game, msg_head, msg_body, "ship_explore_island_cw.png");
+
+			Notifications::publish(
+			   NoteShipMessage(this, NoteShipMessage::Message::kWaitingForCommand));
+
+			return;
 		}
-		case EXP_COLONIZING: {
-			assert(m_expedition->seen_port_buildspaces && !m_expedition->seen_port_buildspaces->empty());
-			BaseImmovable * baim = game.map()[m_expedition->seen_port_buildspaces->front()].get_immovable();
-			assert(baim);
+	}
+	case EXP_COLONIZING: {
+		assert(m_expedition->seen_port_buildspaces && !m_expedition->seen_port_buildspaces->empty());
+		BaseImmovable* baim =
+		   game.map()[m_expedition->seen_port_buildspaces->front()].get_immovable();
+		if (baim) {
 			upcast(ConstructionSite, cs, baim);
 
 			for (int i = m_items.size() - 1; i >= 0; --i) {
-				WareInstance * ware;
-				Worker * worker;
+				WareInstance* ware;
+				Worker* worker;
 				m_items.at(i).get(game, &ware, &worker);
 				if (ware) {
-					// no, we don't transfer the wares, we create new ones out of air and remove the old ones ;)
-					WaresQueue & wq = cs->waresqueue(ware->descr_index());
+					// no, we don't transfer the wares, we create new ones out of air and remove the old
+					// ones ;)
+					WaresQueue& wq = cs->waresqueue(ware->descr_index());
 					const uint32_t max = wq.get_max_fill();
 					const uint32_t cur = wq.get_filled();
 					assert(max > cur);
@@ -654,35 +664,56 @@
 					worker->set_location(cs);
 					worker->set_position(game, cs->get_position());
 					worker->reset_tasks(game);
-					PartiallyFinishedBuilding::request_builder_callback
-						(game, *cs->get_builder_request(), worker->descr().worker_index(), worker, *cs);
+					PartiallyFinishedBuilding::request_builder_callback(
+					   game, *cs->get_builder_request(), worker->descr().worker_index(), worker, *cs);
 					m_items.resize(i);
 				}
 			}
-			if (m_items.empty()) {
-				m_ship_state = TRANSPORT; // That's it, expedition finished
-
-				init_fleet(game);
-				m_expedition.reset(nullptr);
-
-				if (upcast(InteractiveGameBase, igb, game.get_ibase()))
-					refresh_window(*igb);
+		} else {  // it seems that port constructionsite has dissapeared
+			// Send a message to the player, that a port constructionsite is gone
+			std::string msg_head = _("New port constructionsite is gone");
+			std::string msg_body = _("Unloading of wares failed, expedition is cancelled now.");
+			send_message(game, msg_head, msg_body, "port.png");
+			send_signal(game, "cancel_expedition");
+		}
+
+		if (m_items.empty() || !baim) {  // we are done, either way
+			m_ship_state = TRANSPORT;     // That's it, expedition finished
+
+			// Bring us back into a fleet and a economy.
+			init_fleet(game);
+
+			// for case that there are any workers left on board
+			// (applicable when port construction space is kLost)
+			Worker* worker;
+			for (ShippingItem& item : m_items) {
+				item.get(game, nullptr, &worker);
+				if (worker) {
+					worker->reset_tasks(game);
+					worker->start_task_shipping(game, nullptr);
+				}
 			}
-			return start_task_idle(game, descr().main_animation(), 1500); // unload the next item
-		}
-
-		default: {
-			// wait for input
-			start_task_idle(game, descr().main_animation(), 1500);
-			return;
-		}
+
+			m_expedition.reset(nullptr);
+
+			if (upcast(InteractiveGameBase, igb, game.get_ibase()))
+				refresh_window(*igb);
+			return start_task_idle(game, descr().main_animation(), 1500);
+		}
+	}
+
+	default: {
+		// wait for input
+		start_task_idle(game, descr().main_animation(), 1500);
+		return;
+	}
 	}
 
 	// never here
-	assert (false);
+	assert(false);
 }
 
-void Ship::set_economy(Game & game, Economy * e) {
+void Ship::set_economy(Game& game, Economy* e) {
 	// Do not check here that the economy actually changed, because on loading
 	// we rely that wares really get reassigned our economy.
 
@@ -697,23 +728,23 @@
  *
  * @note This is supposed to be called only from the scheduling code of @ref Fleet.
  */
-void Ship::set_destination(Game & game, PortDock & pd) {
+void Ship::set_destination(Game& game, PortDock& pd) {
 	molog("set_destination to %u (currently %" PRIuS " items)\n", pd.serial(), m_items.size());
 	m_destination = &pd;
 	send_signal(game, "wakeup");
 }
 
-void Ship::add_item(Game & game, const ShippingItem & item) {
+void Ship::add_item(Game& game, const ShippingItem& item) {
 	assert(m_items.size() < descr().get_capacity());
 
 	m_items.push_back(item);
 	m_items.back().set_location(game, this);
 }
 
-void Ship::withdraw_items(Game & game, PortDock & pd, std::vector<ShippingItem> & items) {
+void Ship::withdraw_items(Game& game, PortDock& pd, std::vector<ShippingItem>& items) {
 	uint32_t dst = 0;
 	for (uint32_t src = 0; src < m_items.size(); ++src) {
-		PortDock * destination = m_items[src].get_destination(game);
+		PortDock* destination = m_items[src].get_destination(game);
 		if (!destination || destination == &pd) {
 			items.push_back(m_items[src]);
 		} else {
@@ -726,8 +757,8 @@
 /**
  * Find a path to the dock @p pd and follow it without using precomputed paths.
  */
-void Ship::start_task_movetodock(Game & game, PortDock & pd) {
-	Map & map = game.map();
+void Ship::start_task_movetodock(Game& game, PortDock& pd) {
+	Map& map = game.map();
 	StepEvalAStar se(pd.get_warehouse()->get_position());
 	se.m_swim = true;
 	se.m_conservative = false;
@@ -753,7 +784,7 @@
 }
 
 /// Prepare everything for the coming exploration
-void Ship::start_task_expedition(Game & game) {
+void Ship::start_task_expedition(Game& game) {
 	// Now we are waiting
 	m_ship_state = EXP_WAITING;
 	// Initialize a new, yet empty expedition
@@ -762,7 +793,7 @@
 	m_expedition->island_exploration = false;
 	m_expedition->direction = 0;
 	m_expedition->exploration_start = Coords(0, 0);
-	m_expedition->clockwise = false;
+	m_expedition->scouting_direction = ScoutingDirection::kClockwise;
 	m_expedition->economy.reset(new Economy(*get_owner()));
 
 	// We are no longer in any other economy, but instead are an economy of our
@@ -773,8 +804,8 @@
 	set_economy(game, m_expedition->economy.get());
 
 	for (int i = m_items.size() - 1; i >= 0; --i) {
-		WareInstance * ware;
-		Worker * worker;
+		WareInstance* ware;
+		Worker* worker;
 		m_items.at(i).get(game, &ware, &worker);
 		if (worker) {
 			worker->reset_tasks(game);
@@ -788,11 +819,12 @@
 	const std::string msg_head = _("Expedition Ready");
 	const std::string msg_body = _("An expedition ship is waiting for your commands.");
 	send_message(game, msg_head, msg_body, "start_expedition.png");
+	Notifications::publish(NoteShipMessage(this, NoteShipMessage::Message::kWaitingForCommand));
 }
 
 /// Initializes / changes the direction of scouting to @arg direction
 /// @note only called via player command
-void Ship::exp_scout_direction(Game &, uint8_t direction) {
+void Ship::exp_scout_direction(Game&, uint8_t direction) {
 	assert(m_expedition);
 	m_ship_state = EXP_SCOUTING;
 	m_expedition->direction = direction;
@@ -801,28 +833,29 @@
 
 /// Initializes the construction of a port at @arg c
 /// @note only called via player command
-void Ship::exp_construct_port (Game &, const Coords& c) {
+void Ship::exp_construct_port(Game&, const Coords& c) {
 	assert(m_expedition);
 	BuildingIndex port_idx = get_owner()->tribe().safe_building_index("port");
 	get_owner()->force_csite(c, port_idx);
 	m_ship_state = EXP_COLONIZING;
 }
 
-/// Initializes / changes the direction the island exploration in @arg clockwise direction
+/// Initializes / changes the direction the island exploration in @arg scouting_direction direction
 /// @note only called via player command
-void Ship::exp_explore_island (Game &, bool clockwise) {
+void Ship::exp_explore_island(Game&, ScoutingDirection scouting_direction) {
 	assert(m_expedition);
 	m_ship_state = EXP_SCOUTING;
-	m_expedition->clockwise = clockwise;
+	m_expedition->scouting_direction = scouting_direction;
 	m_expedition->direction = 0;
 	m_expedition->island_exploration = true;
 }
 
 /// Cancels a currently running expedition
 /// @note only called via player command
-void Ship::exp_cancel (Game & game) {
+void Ship::exp_cancel(Game& game) {
 	// Running colonization has the highest priority before cancelation
 	// + cancelation only works if an expedition is actually running
+
 	if ((m_ship_state == EXP_COLONIZING) || !state_is_expedition())
 		return;
 	send_signal(game, "cancel_expedition");
@@ -834,7 +867,7 @@
 	// Theres nothing to be done for wares - they already changed
 	// economy with us and the warehouse will make sure that they are
 	// getting used.
-	Worker * worker;
+	Worker* worker;
 	for (ShippingItem& item : m_items) {
 		item.get(game, nullptr, &worker);
 		if (worker) {
@@ -859,7 +892,7 @@
 
 /// Sinks the ship
 /// @note only called via player command
-void Ship::sink_ship (Game & game) {
+void Ship::sink_ship(Game& game) {
 	// Running colonization has the highest priority + a sink request is only valid once
 	if (!state_is_sinkable())
 		return;
@@ -869,25 +902,22 @@
 	close_window();
 }
 
-void Ship::log_general_info(const EditorGameBase & egbase)
-{
+void Ship::log_general_info(const EditorGameBase& egbase) {
 	Bob::log_general_info(egbase);
 
-	molog
-		("Fleet: %u, destination: %u, lastdock: %u, carrying: %" PRIuS "\n",
-		 m_fleet? m_fleet->serial() : 0,
-		 m_destination.serial(), m_lastdock.serial(),
-		 m_items.size());
+	molog("Fleet: %u, destination: %u, lastdock: %u, carrying: %" PRIuS "\n",
+	      m_fleet ? m_fleet->serial() : 0,
+	      m_destination.serial(),
+	      m_lastdock.serial(),
+	      m_items.size());
 
 	for (const ShippingItem& shipping_item : m_items) {
-		molog
-			("  IT %u, destination %u\n",
-			 shipping_item.m_object.serial(),
-			 shipping_item.m_destination_dock.serial());
+		molog("  IT %u, destination %u\n",
+		      shipping_item.m_object.serial(),
+		      shipping_item.m_destination_dock.serial());
 	}
 }
 
-
 /**
  * Send a message to the owning player.
  *
@@ -895,29 +925,34 @@
  *
  * \param msgsender a computer-readable description of why the message was sent
  * \param title user-visible title of the message
- * \param description user-visible message body, will be placed in an appropriate rich-text paragraph
+ * \param description user-visible message body, will be placed in an appropriate rich-text
+ *paragraph
  * \param picture picture name relative to the pics directory
  */
-void Ship::send_message
-	(Game & game, const std::string & title, const std::string & description, const std::string & picture)
-{
+void Ship::send_message(Game& game,
+                        const std::string& title,
+                        const std::string& description,
+                        const std::string& picture) {
 	std::string rt_description;
 	if (picture.size() > 3) {
-		rt_description  = "<rt image=pics/";
+		rt_description = "<rt image=pics/";
 		rt_description += picture;
 		rt_description += "><p font-size=14 font-face=DejaVuSerif>";
 	} else
-		rt_description  = "<rt><p font-size=14 font-face=DejaVuSerif>";
+		rt_description = "<rt><p font-size=14 font-face=DejaVuSerif>";
 	rt_description += description;
 	rt_description += "</p></rt>";
 
-	Message * msg = new Message
-		(Message::Type::kSeafaring, game.get_gametime(), title, rt_description, get_position(), m_serial);
+	Message* msg = new Message(Message::Type::kSeafaring,
+	                           game.get_gametime(),
+	                           title,
+	                           rt_description,
+	                           get_position(),
+	                           m_serial);
 
 	get_owner()->add_message(game, *msg);
 }
 
-
 /*
 ==============================
 
@@ -928,20 +963,16 @@
 
 #define SHIP_SAVEGAME_VERSION 4
 
-Ship::Loader::Loader() :
-	m_lastdock(0),
-	m_destination(0)
-{
+Ship::Loader::Loader() : m_lastdock(0), m_destination(0) {
 }
 
-const Bob::Task * Ship::Loader::get_task(const std::string & name)
-{
-	if (name == "shipidle" || name == "ship") return &taskShip;
+const Bob::Task* Ship::Loader::get_task(const std::string& name) {
+	if (name == "shipidle" || name == "ship")
+		return &taskShip;
 	return Bob::Loader::get_task(name);
 }
 
-void Ship::Loader::load(FileRead & fr, uint8_t version)
-{
+void Ship::Loader::load(FileRead& fr, uint8_t version) {
 	Bob::Loader::load(fr);
 
 	if (version >= 2) {
@@ -950,15 +981,8 @@
 			m_ship_state = fr.unsigned_8();
 
 			// Expedition specific data
-			if
-				(m_ship_state == EXP_SCOUTING
-				 ||
-				 m_ship_state == EXP_WAITING
-				 ||
-				 m_ship_state == EXP_FOUNDPORTSPACE
-				 ||
-				 m_ship_state == EXP_COLONIZING)
-			{
+			if (m_ship_state == EXP_SCOUTING || m_ship_state == EXP_WAITING ||
+			    m_ship_state == EXP_FOUNDPORTSPACE || m_ship_state == EXP_COLONIZING) {
 				m_expedition.reset(new Expedition());
 				// Currently seen port build spaces
 				m_expedition->seen_port_buildspaces.reset(new std::list<Coords>());
@@ -975,7 +999,7 @@
 				// Start coordinates of an island exploration
 				m_expedition->exploration_start = read_coords_32(&fr);
 				// Whether the exploration is done clockwise or counter clockwise
-				m_expedition->clockwise = fr.unsigned_8() == 1;
+				m_expedition->scouting_direction = static_cast<ScoutingDirection>(fr.unsigned_8());
 			}
 		} else
 			m_ship_state = TRANSPORT;
@@ -990,11 +1014,10 @@
 	}
 }
 
-void Ship::Loader::load_pointers()
-{
+void Ship::Loader::load_pointers() {
 	Bob::Loader::load_pointers();
 
-	Ship & ship = get<Ship>();
+	Ship& ship = get<Ship>();
 
 	if (m_lastdock)
 		ship.m_lastdock = &mol().get<PortDock>(m_lastdock);
@@ -1007,11 +1030,10 @@
 	}
 }
 
-void Ship::Loader::load_finish()
-{
+void Ship::Loader::load_finish() {
 	Bob::Loader::load_finish();
 
-	Ship & ship = get<Ship>();
+	Ship& ship = get<Ship>();
 
 	// restore the state the ship is in
 	ship.m_ship_state = m_ship_state;
@@ -1021,7 +1043,8 @@
 		ship.m_expedition.swap(m_expedition);
 		ship.m_expedition->economy.reset(new Economy(*ship.get_owner()));
 		ship.m_economy = ship.m_expedition->economy.get();
-	} else assert(m_ship_state == TRANSPORT);
+	} else
+		assert(m_ship_state == TRANSPORT);
 
 	// Workers load code set their economy to the economy of their location
 	// (which is a PlayerImmovable), that means that workers on ships do not get
@@ -1032,10 +1055,7 @@
 	ship.set_economy(dynamic_cast<Game&>(egbase()), ship.m_economy);
 }
 
-
-MapObject::Loader * Ship::load
-	(EditorGameBase & egbase, MapObjectLoader & mol, FileRead & fr)
-{
+MapObject::Loader* Ship::load(EditorGameBase& egbase, MapObjectLoader& mol, FileRead& fr) {
 	std::unique_ptr<Loader> loader(new Loader);
 
 	try {
@@ -1045,32 +1065,28 @@
 		if (1 <= version && version <= SHIP_SAVEGAME_VERSION) {
 			std::string owner = fr.c_string();
 			std::string name = fr.c_string();
-			const ShipDescr * descr = nullptr;
+			const ShipDescr* descr = nullptr;
 
 			egbase.manually_load_tribe(owner);
 
-			if (const TribeDescr * tribe = egbase.get_tribe(owner))
-				descr = dynamic_cast<const ShipDescr *>
-					(tribe->get_bob_descr(name));
+			if (const TribeDescr* tribe = egbase.get_tribe(owner))
+				descr = dynamic_cast<const ShipDescr*>(tribe->get_bob_descr(name));
 
 			if (!descr)
-				throw GameDataError
-					("undefined ship %s/%s", owner.c_str(), name.c_str());
+				throw GameDataError("undefined ship %s/%s", owner.c_str(), name.c_str());
 
 			loader->init(egbase, mol, descr->create_object());
 			loader->load(fr, version);
 		} else
 			throw GameDataError("unknown/unhandled version %u", version);
-	} catch (const std::exception & e) {
+	} catch (const std::exception& e) {
 		throw wexception("loading ship: %s", e.what());
 	}
 
 	return loader.release();
 }
 
-void Ship::save
-	(EditorGameBase & egbase, MapObjectSaver & mos, FileWrite & fw)
-{
+void Ship::save(EditorGameBase& egbase, MapObjectSaver& mos, FileWrite& fw) {
 	fw.unsigned_8(HeaderShip);
 	fw.unsigned_8(SHIP_SAVEGAME_VERSION);
 
@@ -1087,11 +1103,9 @@
 		// currently seen port buildspaces
 		assert(m_expedition->seen_port_buildspaces);
 		fw.unsigned_8(m_expedition->seen_port_buildspaces->size());
-		for
-			(std::list<Coords>::const_iterator it = m_expedition->seen_port_buildspaces->begin();
-			 it != m_expedition->seen_port_buildspaces->end();
-			 ++it)
-		{
+		for (std::list<Coords>::const_iterator it = m_expedition->seen_port_buildspaces->begin();
+		     it != m_expedition->seen_port_buildspaces->end();
+		     ++it) {
 			write_coords_32(&fw, *it);
 		}
 		// swimability of the directions
@@ -1104,7 +1118,7 @@
 		// Start coordinates of an island exploration
 		write_coords_32(&fw, m_expedition->exploration_start);
 		// Whether the exploration is done clockwise or counter clockwise
-		fw.unsigned_8(m_expedition->clockwise ? 1 : 0);
+		fw.unsigned_8(static_cast<uint8_t>(m_expedition->scouting_direction));
 	}
 
 	fw.unsigned_32(mos.get_object_file_index_or_zero(m_lastdock.get(egbase)));
@@ -1116,4 +1130,4 @@
 	}
 }
 
-} // namespace Widelands
+}  // namespace Widelands

=== modified file 'src/logic/ship.h'
--- src/logic/ship.h	2014-09-29 12:37:07 +0000
+++ src/logic/ship.h	2015-02-10 21:28:25 +0000
@@ -37,6 +37,25 @@
 struct Fleet;
 class PortDock;
 
+// This can't be part of the Ship class because of forward declaration in game.h
+enum class ScoutingDirection {
+	kCounterClockwise = 0, // This comes first for savegame compatibility (used to be = 0)
+	kClockwise = 1
+};
+
+struct NoteShipMessage {
+	CAN_BE_SEND_AS_NOTE(NoteId::ShipMessage)
+
+	Ship* ship;
+
+	enum class Message {kLost, kGained, kWaitingForCommand};
+	Message message;
+
+	NoteShipMessage(Ship* const init_ship, Message const init_message)
+	   : ship(init_ship), message(init_message) {
+	}
+};
+
 struct ShipDescr : BobDescr {
 	ShipDescr
 		(char const * name, char const * descname,
@@ -185,7 +204,7 @@
 
 	void exp_scout_direction(Game &, uint8_t);
 	void exp_construct_port (Game &, const Coords&);
-	void exp_explore_island (Game &, bool);
+	void exp_explore_island (Game &, ScoutingDirection);
 
 	void exp_cancel (Game &);
 	void sink_ship  (Game &);
@@ -225,7 +244,7 @@
 		bool island_exploration;
 		uint8_t direction;
 		Coords exploration_start;
-		bool clockwise;
+		ScoutingDirection scouting_direction;
 		std::unique_ptr<Economy> economy;
 	};
 	std::unique_ptr<Expedition> m_expedition;

=== modified file 'src/logic/warehouse.cc'
--- src/logic/warehouse.cc	2014-12-28 16:45:37 +0000
+++ src/logic/warehouse.cc	2015-02-10 21:28:25 +0000
@@ -478,8 +478,20 @@
 			 	 Area<FCoords>
 			 	 	(egbase.map().get_fcoords(get_position()), conquer_radius)));
 
-	if (descr().get_isport())
+	if (descr().get_isport()) {
 		init_portdock(egbase);
+		PortDock* pd = m_portdock;
+		// should help diagnose problems with marine
+		if (!pd->get_fleet()) {
+			log(" Warning: portdock without a fleet created (%3dx%3d)\n",
+			get_position().x,
+			get_position().y);
+		}
+	}
+
+	//this is default
+	m_cleanup_in_progress = false;
+
 }
 
 /**
@@ -493,7 +505,9 @@
 	Map & map = egbase.map();
 	std::vector<Coords> dock = map.find_portdock(get_position());
 	if (dock.empty()) {
-		log("Attempting to setup port without neighboring water.\n");
+		log("Attempting to setup port without neighboring water (coords: %3dx%3d).\n",
+		    get_position().x,
+		    get_position().y);
 		return;
 	}
 
@@ -509,6 +523,16 @@
 
 	if (get_economy() != nullptr)
 		m_portdock->set_economy(get_economy());
+
+	// this is just to indicate something wrong is going on
+	//(tiborb)
+	PortDock* pd_tmp = m_portdock;
+	if (!pd_tmp->get_fleet()) {
+		log (" portdock for port at %3dx%3d created but without a fleet!\n",
+		    get_position().x,
+		    get_position().y);
+	}
+
 }
 
 void Warehouse::destroy(EditorGameBase & egbase)
@@ -516,11 +540,36 @@
 	Building::destroy(egbase);
 }
 
+// if the port still exists and we are in game we first try to restore the portdock
+void Warehouse::restore_portdock_or_destroy(EditorGameBase& egbase) {
+	Warehouse::init_portdock(egbase);
+	if (!m_portdock) {
+		log(" Portdock could not be restored, removing the port now (coords: %3dx%3d)\n",
+		    get_position().x,
+		    get_position().y);
+		Building::destroy(egbase);
+	} else {
+		molog ("Message: portdock restored\n");
+		PortDock* pd_tmp = m_portdock;
+		if (!pd_tmp->get_fleet()) {
+			log (" Portdock restored but without a fleet!\n");
+		}
+	}
+}
+
+
 /// Destroy the warehouse.
-void Warehouse::cleanup(EditorGameBase & egbase)
-{
+void Warehouse::cleanup(EditorGameBase& egbase) {
+
+	// if this is a port, it will remove also portdock.
+	// But portdock must know that it should not try to recreate itself
+	m_cleanup_in_progress = true;
+
 	if (egbase.objects().object_still_available(m_portdock)) {
 		m_portdock->remove(egbase);
+	}
+
+	if (!egbase.objects().object_still_available(m_portdock)) {
 		m_portdock = nullptr;
 	}
 

=== modified file 'src/logic/warehouse.h'
--- src/logic/warehouse.h	2015-02-08 18:16:41 +0000
+++ src/logic/warehouse.h	2015-02-10 21:28:25 +0000
@@ -136,6 +136,8 @@
 
 	void destroy(EditorGameBase &) override;
 
+	void restore_portdock_or_destroy(EditorGameBase &);
+
 	void act(Game & game, uint32_t data) override;
 
 	void set_economy(Economy *) override;
@@ -272,6 +274,11 @@
 	std::vector<PlannedWorkers> m_planned_workers;
 
 	PortDock * m_portdock;
+
+	//this is information for portdock,to know whether it should
+	//try to recreate itself
+	bool m_cleanup_in_progress;
+
 };
 
 }

=== modified file 'src/notifications/note_ids.h'
--- src/notifications/note_ids.h	2014-11-23 14:34:38 +0000
+++ src/notifications/note_ids.h	2015-02-10 21:28:25 +0000
@@ -32,8 +32,9 @@
 	FieldPossession,
 	FieldTransformed,
 	ProductionSiteOutOfResources,
-
+	ShipMessage,
 	GraphicResolutionChanged,
+
 };
 
 #endif  // end of include guard: WL_NOTIFICATIONS_NOTE_IDS_H

=== modified file 'src/wui/shipwindow.cc'
--- src/wui/shipwindow.cc	2014-11-30 18:49:38 +0000
+++ src/wui/shipwindow.cc	2015-02-10 21:28:25 +0000
@@ -70,7 +70,7 @@
 	void act_cancel_expedition();
 	void act_scout_towards(uint8_t);
 	void act_construct_port();
-	void act_explore_island(bool);
+	void act_explore_island(ScoutingDirection);
 
 private:
 	InteractiveGameBase & m_igbase;
@@ -120,7 +120,7 @@
 		m_btn_explore_island_cw =
 			make_button
 				(exp_top, "expcw", _("Explore the island’s coast clockwise"), pic_explore_cw,
-				 boost::bind(&ShipWindow::act_explore_island, this, true));
+				 boost::bind(&ShipWindow::act_explore_island, this, ScoutingDirection::kClockwise));
 		exp_top->add(m_btn_explore_island_cw, 0, false);
 
 		m_btn_scout[WALK_NE - 1] =
@@ -156,7 +156,7 @@
 		m_btn_explore_island_ccw =
 			make_button
 				(exp_bot, "expccw", _("Explore the island’s coast counter clockwise"), pic_explore_ccw,
-				 boost::bind(&ShipWindow::act_explore_island, this, false));
+				 boost::bind(&ShipWindow::act_explore_island, this, ScoutingDirection::kCounterClockwise));
 		exp_bot->add(m_btn_explore_island_ccw, 0, false);
 
 		m_btn_scout[WALK_SE - 1] =
@@ -327,7 +327,7 @@
 }
 
 /// Explores the island cw or ccw
-void ShipWindow::act_explore_island(bool cw) {
+void ShipWindow::act_explore_island(ScoutingDirection direction) {
 	bool coast_nearby = false;
 	bool moveable = false;
 	for (Direction dir = 1; (dir <= LAST_DIRECTION) && (!coast_nearby || !moveable); ++dir) {
@@ -338,7 +338,7 @@
 	}
 	if (!coast_nearby || !moveable)
 		return;
-	m_igbase.game().send_player_ship_explore_island(m_ship, cw);
+	m_igbase.game().send_player_ship_explore_island(m_ship, direction);
 }
 
 

=== modified file 'test/maps/ship_transportation.wmf/scripting/init.lua'
--- test/maps/ship_transportation.wmf/scripting/init.lua	2014-08-01 15:30:12 +0000
+++ test/maps/ship_transportation.wmf/scripting/init.lua	2015-02-10 21:28:25 +0000
@@ -37,6 +37,23 @@
    return nil
 end
 
+function portdock2()
+	local portdock = map:get_field(15, 4).immovable
+	if portdock then
+		return portdock
+	end
+	local portdock = map:get_field(14, 5).immovable
+	if portdock then
+		return portdock
+	end
+	local portdock = map:get_field(14, 4).immovable
+	if portdock then
+		return portdock
+	end
+	print ("portdock not found")
+	return nill
+end
+
 function start_building_farm()
    p1:place_building("farm", map:get_field(18, 4), true, true)
    connected_road(p1, map:get_field(18,5).immovable, "l,l|tl,tr|", true)

=== added file 'test/maps/ship_transportation.wmf/scripting/test_rip_portdock_with_worker_and_ware_in_transit.lua'
--- test/maps/ship_transportation.wmf/scripting/test_rip_portdock_with_worker_and_ware_in_transit.lua	1970-01-01 00:00:00 +0000
+++ test/maps/ship_transportation.wmf/scripting/test_rip_portdock_with_worker_and_ware_in_transit.lua	2015-02-10 21:28:25 +0000
@@ -0,0 +1,54 @@
+run(function()
+   sleep(100)
+   game.desired_speed = 10 * 1000
+
+   create_first_port()
+   create_second_port()
+   
+   --removing builder from port2
+    port2():set_workers{
+      builder = 0,
+   }  
+
+   assert_equal(port2():get_workers("builder"), 0)
+
+   start_building_farm()
+   port1():set_workers{
+      builder = 1,
+   }
+   port1():set_wares{
+      blackwood = 1,
+   }
+
+   assert_equal(port1():get_workers("builder"), 1)
+   assert_equal(port1():get_wares("blackwood"), 1)
+   
+   while ship:get_workers() == 0 or ship:get_wares() == 0  do
+      sleep(500) 
+   end
+
+   local flag_oversea = port2().flag   
+
+ 	stable_save("restored_port")
+   
+   -- remove the portdock while the blackwood is in transit.
+   portdock2():remove()
+   
+   sleep(5000)
+
+   assert_equal(p1:get_workers("builder"), 1)
+   assert_equal(p1:get_wares("blackwood"), 1)
+   assert_equal(ship.debug_economy, port1().debug_economy)
+   assert_equal(ship.debug_economy, flag_oversea.debug_economy)
+
+   sleep(5000)
+   
+   --just wait till everything is gone to port2
+   while ship:get_workers() > 0 or ship:get_wares() > 0 or
+    port1():get_workers("builder") > 0 or  port1():get_wares("blackwood") > 0 do
+      sleep(50)
+   end
+
+   print("# All Tests passed.")
+   wl.ui.MapView():close()
+end)

=== modified file 'tribes/atlanteans/bread/conf'
--- tribes/atlanteans/bread/conf	2014-07-28 14:04:36 +0000
+++ tribes/atlanteans/bread/conf	2015-02-10 21:28:25 +0000
@@ -1,7 +1,7 @@
 help=_This tasty bread is made in bakeries out of cornflour, blackroot flour and water. It is appreciated as basic food for miners, scouts and soldiers in training sites (labyrinth and dungeon).
 
 default_target_quantity=20
-preciousness=2
+preciousness=5
 
 # No description yet
 [idle]

=== modified file 'tribes/empire/bread/conf'
--- tribes/empire/bread/conf	2014-07-28 14:04:36 +0000
+++ tribes/empire/bread/conf	2015-02-10 21:28:25 +0000
@@ -1,7 +1,7 @@
 help=_The bakers of the Empire make really tasty bread out of flour and water. It is used in taverns and inns to prepare rations and meals. Bread is also consumed at the training sites (arena, colosseum, training camp).
 
 default_target_quantity=20
-preciousness=4
+preciousness=5
 
 [idle]
 pics=bread_idle.png

=== modified file 'tribes/empire/meal/conf'
--- tribes/empire/meal/conf	2013-07-23 19:04:12 +0000
+++ tribes/empire/meal/conf	2015-02-10 21:28:25 +0000
@@ -1,7 +1,7 @@
 help=_A real meal is made in inns out of bread and fish/meat. It satisfies the needs of miners in deep mines.
 
 default_target_quantity=20
-preciousness=5
+preciousness=4
 
 [idle]
 pics=idle.png

=== modified file 'tribes/empire/ration/conf'
--- tribes/empire/ration/conf	2014-07-28 14:04:36 +0000
+++ tribes/empire/ration/conf	2015-02-10 21:28:25 +0000
@@ -1,7 +1,7 @@
 help=_A small bite to keep miners strong and working. Rations are also consumed by the scout on his scouting trips. They are produced in a tavern out of fish or meat or bread.
 
 default_target_quantity=20
-preciousness=5
+preciousness=4
 
 [idle]
 pics=idle.png