Merge lp:~widelands-dev/widelands/bug-987510 into lp:widelands

[GunChleoc]

Messages can be filtered by category now. Added new buttons for 5 categories and an icon on the bottom right of each message to show its message type. Added keyboard shortcuts and tooltips.

[TiborB (tiborb95)]

I understand the design was discussed under bug report, but still 2 comments:

1. Current design is "one category only" - what about enabling and disabling freely? I mean you could be able to enable any number of categories.

2 mode "0: show all messages" shows a flag on the bottom and it is symbol of economy messages. I think "all messages" should have own icon, or no icon, or icons of all categories.

But generally it works as supposed....

[TiborB (tiborb95)]

question about shortcuts - numbers before categories (in tooltips) indicate shortcuts? I could not make them work. Is it '$number' or 'ctrl+$number'?

[GunChleoc (gunchleoc)]

Hotkeys work just fine with me, the toggle on/off. Is it '$number'.

1. That would make the filter harder to implement - I just went with the easy option.

2. The flag on the bottom is not the currently selected category, but the category of the current message. Maybe the tooltip should be clearer - "Type of this message: " maybe?

[Hans Joachim Desserud (hjd)]

Speaking of the hotkeys, how do they work together with the "area bookmarks" we have currently? At the moment I can use Ctrl+number to store a location, then later go back to it by pressing the number. How will we tell whether the user wish to toggle filtering in the news window or go to another place on the map? (Might be a question discussed in the bug report rather than the review)

Please resolve the conflicts mentioned at the top.

[TiborB (tiborb95)]

Probably hotkey does not work on my (linux) at all - but no problem now

> The flag on the bottom is not the currently selected category, but the category of the current message.

Oh yes, I did not got it, now it makes sense

Also you can consider "Type of selected message" or "Type of highlighted message"

Or even better, but probably more work for you - remove that flag on the bottom and add new column that would contain a particular flag for the message.

And yet another comment - will users understand that number on the beginning of tip is a shortcut?

[GunChleoc (gunchleoc)]

I overlooked that we already have the hotkeys 1-9 in use. I willcome up with different hotkeys.

> Or even better, but probably more work for you - remove that flag on the
> bottom and add new column that would contain a particular flag for the
> message.

This column would need a header and eat up space - we are already tight on width there. The translations need more space than the English strings. The message titles also need a lot of space-

> And yet another comment - will users understand that number on the beginning
> of tip is a shortcut?

I thought this would be nice for the user, but if you think it is confusing, I can remove these easily without messing up translations.

[TiborB (tiborb95)]

if the hotkeys will be like Ctrl+1, then it will be obvious that they are hotkeys and no confusion for user

[wl-zocker (wl-zocker)]

I have not tested it in the game, but some ideas based on these comments:
- I imagined that when the news window is open, 1-5 would act on it (6-0 should do nothing). When it is not open, they work as location marker. Ctrl+number is also already used. I do not know if Widelands currently supports this. The problem is that many keys are already used (g = geologist/GoTo, s = seafaring/statistics) and that they would make no sense in translation.
- Why not simply write "Hotkey: %s"? That should avoid any confusion.

[GunChleoc (gunchleoc)]

I found some letters that are included somewhere in the English strings for the hotkeys. Since we don't have localizable hotkeys, we will have to live with other languages not matching. But we have thet problem anyway with all hotkeys that are letters.

> - Why not simply write "Hotkey: %s"? That should avoid any confusion.

Good idea, done.

[SirVer (sirver)]

Using the same keys is fine: the mail window will have the focus for the keyboard when it is clicked or just opened, so the keys will do what the user expects.

[TiborB (tiborb95)]

Looks good now, and shortcuts works on my PC now :)

[GunChleoc (gunchleoc)]

So, what are the preferred hotkeys for you guys: 0-5, or the letters I'm using right now?

[TiborB (tiborb95)]

As letters does not match first letter of particular world, perhaps numbers could be better ( 0 for all), but personally I dont care much...
I think users might live happily with both approaches...

[SirVer (sirver)]

+1 for numbers.

[GunChleoc (gunchleoc)]

Will do the numbers then.

The discinct message types are needed elsewhere, see the diff comment for details.

[GunChleoc (gunchleoc)]

All done. Hotkeys work as SirVer described.

review: Needs Resubmitting

=== modified file 'pics/message_archive.png'
Binary files pics/message_archive.png	2010-01-14 18:22:23 +0000 and pics/message_archive.png	2014-12-28 17:03:29 +0000 differ
=== modified file 'pics/message_archived.png'
Binary files pics/message_archived.png	2010-01-14 18:22:23 +0000 and pics/message_archived.png	2014-12-28 17:03:29 +0000 differ
=== added file 'pics/message_clear_selection.png'
Binary files pics/message_clear_selection.png	1970-01-01 00:00:00 +0000 and pics/message_clear_selection.png	2014-12-28 17:03:29 +0000 differ
=== modified file 'pics/message_restore.png'
Binary files pics/message_restore.png	2010-01-14 18:22:23 +0000 and pics/message_restore.png	2014-12-28 17:03:29 +0000 differ
=== added file 'pics/message_selection_invert.png'
Binary files pics/message_selection_invert.png	1970-01-01 00:00:00 +0000 and pics/message_selection_invert.png	2014-12-28 17:03:29 +0000 differ
=== added file 'pics/messages_warfare.png'
Binary files pics/messages_warfare.png	1970-01-01 00:00:00 +0000 and pics/messages_warfare.png	2014-12-28 17:03:29 +0000 differ
=== modified file 'src/logic/building.cc'
--- src/logic/building.cc	2014-12-11 12:38:10 +0000
+++ src/logic/building.cc	2014-12-28 17:03:29 +0000
@@ -880,7 +880,7 @@
  */
 void Building::send_message
 	(Game & game,
-	 const std::string & msgsender,
+	 const Message::Type msgtype,
 	 const std::string & title,
 	 const std::string & description,
 	 bool link_to_building_lifetime,
@@ -910,7 +910,7 @@
 			% rt_description % description).str();
 
 	Message * msg = new Message
-		(msgsender, game.get_gametime(), title, rt_description,
+		(msgtype, game.get_gametime(), title, rt_description,
 		 get_position(), (link_to_building_lifetime ? m_serial : 0));
 
 	if (throttle_time)

=== modified file 'src/logic/building.h'
--- src/logic/building.h	2014-09-14 11:31:58 +0000
+++ src/logic/building.h	2014-12-28 17:03:29 +0000
@@ -31,6 +31,7 @@
 #include "logic/bill_of_materials.h"
 #include "logic/buildcost.h"
 #include "logic/immovable.h"
+#include "logic/message.h"
 #include "logic/soldier_counts.h"
 #include "logic/wareworker.h"
 #include "logic/widelands.h"
@@ -259,7 +260,7 @@
 
 	void send_message
 		(Game & game,
-		 const std::string & msgsender,
+		 const Message::Type msgtype,
 		 const std::string & title,
 		 const std::string & description,
 		 bool link_to_building_lifetime = true,

=== modified file 'src/logic/cmd_luacoroutine.cc'
--- src/logic/cmd_luacoroutine.cc	2014-09-20 09:37:47 +0000
+++ src/logic/cmd_luacoroutine.cc	2014-12-28 17:03:29 +0000
@@ -50,7 +50,7 @@
 		for (int i = 1; i <= game.map().get_nrplayers(); i++) {
 			Widelands::Message & msg =
 				*new Widelands::Message
-				("Game Logic", game.get_gametime(), "Lua Coroutine Failed", e.what());
+				(Message::Type::kGameLogic, game.get_gametime(), "Lua Coroutine Failed", e.what());
 			game.player(i).add_message(game, msg, true);
 		}
 		game.game_controller()->set_desired_speed(0);

=== modified file 'src/logic/message.h'
--- src/logic/message.h	2014-09-19 12:54:54 +0000
+++ src/logic/message.h	2014-12-28 17:03:29 +0000
@@ -29,10 +29,30 @@
 namespace Widelands {
 
 struct Message {
-	enum Status {New, Read, Archived};
+	enum class Status: uint8_t {kNew, kRead, kArchived};
+	enum class Type: uint8_t {
+		kNoMessages,
+		kAllMessages,
+		kGameLogic,
+		kGeologists,
+		kGeologistsCoal,
+		kGeologistsGold,
+		kGeologistsGranite,
+		kGeologistsIron,
+		kGeologistsWater,
+		kScenario,
+		kSeafaring,
+		kEconomy,      // economy
+		kEconomySiteOccupied, // economy
+		kWarfare,     // everything starting from here is warfare
+		kWarfareSiteDefeated,
+		kWarfareSiteLost,
+		kWarfareUnderAttack
+	};
+
 	/**
 	 * A new message to be displayed to the player
-	 * \param msgsender The message sender
+	 * \param msgtype The type of message (economy, geologists, etc.)
 	 * \param sent_time The (game) time at which the message is sent
 	 * \param t The message title
 	 * \param b The message body
@@ -43,16 +63,16 @@
 	 * \param s The message status. Defaults to Status::New
 	 */
 	Message
-		(const std::string &       msgsender,
+		(Message::Type             msgtype,
 		 uint32_t                  sent_time,
 		 const std::string &       t,
 		 const std::string &       b,
 		 Widelands::Coords   const c = Coords::null(),
 		 Widelands::Serial         ser = 0,
-		 Status                    s = New)
+		 Status                    s = Status::kNew)
 		:
-		m_sender(msgsender),
-		m_title(t),
+		m_type    (msgtype),
+		m_title   (t),
 		m_body    (b),
 		m_sent    (sent_time),
 		m_position(c),
@@ -60,18 +80,35 @@
 		m_status  (s)
 	{}
 
-	const std::string & sender() const     {return m_sender;}
-	uint32_t            sent    () const            {return m_sent;}
-	const std::string & title() const      {return m_title;}
-	const std::string & body () const               {return m_body;}
-	Widelands::Coords   position() const            {return m_position;}
-	Widelands::Serial   serial() const              {return m_serial;}
-	Status              status  () const {return m_status;}
-	Status set_status(Status const s) {return m_status = s;}
+	Message::Type         type    () const   {return m_type;}
+	uint32_t              sent    () const   {return m_sent;}
+	const std::string &   title   () const   {return m_title;}
+	const std::string &   body    () const   {return m_body;}
+	Widelands::Coords     position() const   {return m_position;}
+	Widelands::Serial     serial  () const   {return m_serial;}
+	Status                status  () const   {return m_status;}
+	Status set_status(Status const s)        {return m_status = s;}
+
+	/**
+	 * Returns the main type for the message's sub type
+	 */
+	Message::Type message_type_category() const {
+		if (m_type >=  Widelands::Message::Type::kWarfare) {
+			return Widelands::Message::Type::kWarfare;
+
+		} else if (m_type >= Widelands::Message::Type::kEconomy &&
+					  m_type <= Widelands::Message::Type::kEconomySiteOccupied) {
+			return Widelands::Message::Type::kEconomy;
+		} else if (m_type >= Widelands::Message::Type::kGeologists &&
+					 m_type <= Widelands::Message::Type::kGeologistsWater) {
+		  return Widelands::Message::Type::kGeologists;
+	  }
+		return m_type;
+	}
 
 private:
-	std::string m_sender;
-	std::string m_title;
+	Message::Type     m_type;
+	std::string       m_title;
 	std::string       m_body;
 	uint32_t          m_sent;
 	Widelands::Coords m_position;

=== modified file 'src/logic/message_queue.h'
--- src/logic/message_queue.h	2014-09-19 12:54:54 +0000
+++ src/logic/message_queue.h	2014-12-28 17:03:29 +0000
@@ -33,9 +33,9 @@
 	friend class MapPlayersMessagesPacket;
 
 	MessageQueue() {
-		m_counts[Message::New]      = 0; //  C++0x:
-		m_counts[Message::Read]     = 0; //  C++0x:
-		m_counts[Message::Archived] = 0; //  C++0x:
+		m_counts[static_cast<int>(Message::Status::kNew)]      = 0; //  C++0x:
+		m_counts[static_cast<int>(Message::Status::kRead)]     = 0; //  C++0x:
+		m_counts[static_cast<int>(Message::Status::kArchived)] = 0; //  C++0x:
 	}                                   //  C++0x:
 
 	~MessageQueue() {
@@ -67,8 +67,8 @@
 	/// \returns the number of messages with the given status.
 	uint32_t nr_messages(Message::Status const status) const {
 		assert_counts();
-		assert(status < 3);
-		return m_counts[status];
+		assert(static_cast<int>(status) < 3);
+		return m_counts[static_cast<int>(status)];
 	}
 
 	/// Adds the message. Takes ownership of the message. Assumes that it has
@@ -81,8 +81,8 @@
 	/// The loading code calls this function to add messages form the map file.
 	MessageId add_message(Message & message) {
 		assert_counts();
-		assert(message.status() < 3);
-		++m_counts[message.status()];
+		assert(static_cast<int>(message.status()) < 3);
+		++m_counts[static_cast<int>(message.status())];
 		insert
 			(std::map<MessageId, Message *>::end(),
 			 std::pair<MessageId, Message *>(++m_current_message_id, &message));
@@ -93,14 +93,14 @@
 	/// Sets the status of the message with the given id, if it exists.
 	void set_message_status(const MessageId& id, Message::Status const status) {
 		assert_counts();
-		assert(status < 3);
+		assert(static_cast<int>(status) < 3);
 		MessageQueue::iterator const it = find(id);
 		if (it != end()) {
 			Message & message = *it->second;
-			assert(it->second->status() < 3);
-			assert(m_counts[message.status()]);
-			--m_counts[message.status    ()];
-			++m_counts[message.set_status(status)];
+			assert(static_cast<int>(it->second->status()) < 3);
+			assert(m_counts[static_cast<int>(message.status())]);
+			--m_counts[static_cast<int>(message.status())];
+			++m_counts[static_cast<int>(message.set_status(status))];
 		}
 		assert_counts();
 	}
@@ -117,9 +117,9 @@
 			return;
 		}
 		Message & message = *it->second;
-		assert(message.status() < 3);
-		assert(m_counts[message.status()]);
-		--m_counts[message.status()];
+		assert(static_cast<int>(message.status()) < 3);
+		assert(m_counts[static_cast<int>(message.status())]);
+		--m_counts[static_cast<int>(message.status())];
 		delete &message;
 		erase(it);
 		assert_counts();
@@ -143,9 +143,9 @@
 	void clear() {
 		assert_counts();
 		m_current_message_id        = MessageId::null();
-		m_counts[Message::New]      = 0;
-		m_counts[Message::Read]     = 0;
-		m_counts[Message::Archived] = 0;
+		m_counts[static_cast<int>(Message::Status::kNew)]      = 0;
+		m_counts[static_cast<int>(Message::Status::kRead)]     = 0;
+		m_counts[static_cast<int>(Message::Status::kArchived)] = 0;
 		std::map<MessageId, Message *>::clear();
 		assert_counts();
 	}
@@ -161,9 +161,9 @@
 	void assert_counts() const {
 		assert
 			(size() ==
-			 m_counts[Message::New]  +
-			 m_counts[Message::Read] +
-			 m_counts[Message::Archived]);
+			 m_counts[static_cast<int>(Message::Status::kNew)]  +
+			 m_counts[static_cast<int>(Message::Status::kRead)] +
+			 m_counts[static_cast<int>(Message::Status::kArchived)]);
 	}
 
 	DISALLOW_COPY_AND_ASSIGN(MessageQueue);

=== modified file 'src/logic/militarysite.cc'
--- src/logic/militarysite.cc	2014-11-30 18:49:38 +0000
+++ src/logic/militarysite.cc	2014-12-28 17:03:29 +0000
@@ -248,7 +248,7 @@
 		if (upcast(Game, game, &egbase)) {
 			send_message
 				(*game,
-				 "site_occupied",
+				 Message::Type::kEconomySiteOccupied,
 				 descr().descname(),
 				 descr().m_occupied_str,
 				 true);
@@ -845,7 +845,7 @@
 		{
 			send_message
 				(game,
-				 "site_lost",
+				 Message::Type::kWarfareSiteLost,
 				 _("Militarysite lost!"),
 				 descr().m_defeated_enemy_str,
 				 false);
@@ -899,7 +899,7 @@
 		// Of course we should inform the victorious player as well
 		newsite->send_message
 			(game,
-			 "site_defeated",
+			 Message::Type::kWarfareSiteDefeated,
 			 _("Enemy at site defeated!"),
 			 newsite->descr().m_defeated_you_str,
 			 true);
@@ -949,7 +949,7 @@
 	// radius <= 5 near the current location in the last 60 seconds
 	send_message
 		(game,
-		 "under_attack",
+		 Message::Type::kWarfareUnderAttack,
 		 _("You are under attack"),
 		 discovered ? descr().m_aggressor_str : descr().m_attack_str,
 		 false,

=== modified file 'src/logic/player.cc'
--- src/logic/player.cc	2014-12-16 21:39:00 +0000
+++ src/logic/player.cc	2014-12-28 17:03:29 +0000
@@ -292,15 +292,15 @@
  * Plays the corresponding sound when a message is received and if sound is
  * enabled.
  */
-void Player::play_message_sound(const std::string & sender) {
-#define MAYBE_PLAY(a, b) if (sender == a) { \
-	g_sound_handler.play_fx(b, 200, PRIO_ALWAYS_PLAY); \
+void Player::play_message_sound(const Message::Type & msgtype) {
+#define MAYBE_PLAY(type, file) if (msgtype == type) { \
+	g_sound_handler.play_fx(file, 200, PRIO_ALWAYS_PLAY); \
 	return; \
 	}
 
 	if (g_options.pull_section("global").get_bool("sound_at_message", true)) {
-		MAYBE_PLAY("site_occupied", "sound/military/site_occupied");
-		MAYBE_PLAY("under_attack", "sound/military/under_attack");
+		MAYBE_PLAY(Message::Type::kEconomySiteOccupied, "sound/military/site_occupied");
+		MAYBE_PLAY(Message::Type::kWarfareUnderAttack, "sound/military/under_attack");
 
 		g_sound_handler.play_fx("sound/message", 200, PRIO_ALWAYS_PLAY);
 	}
@@ -321,7 +321,7 @@
 	// Sound & popup
 	if (InteractivePlayer * const iplayer = game.get_ipl()) {
 		if (&iplayer->player() == this) {
-			play_message_sound(message.sender());
+			play_message_sound(message.type());
 			if (popup)
 				iplayer->popup_message(id, message);
 		}
@@ -339,7 +339,7 @@
 	Coords      const position = m   .position    ();
 	for (std::pair<MessageId, Message *>  tmp_message : messages()) {
 		if
-			(tmp_message.second->sender() == m.sender()      &&
+			(tmp_message.second->type() == m.type()      &&
 			 gametime < tmp_message.second->sent() + timeout &&
 			 map.calc_distance(tmp_message.second->position(), position) <= radius)
 		{

=== modified file 'src/logic/player.h'
--- src/logic/player.h	2014-12-16 21:39:00 +0000
+++ src/logic/player.h	2014-12-28 17:03:29 +0000
@@ -521,7 +521,7 @@
 	BuildingStatsVector* get_mutable_building_statistics(const BuildingIndex& i);
 	void update_building_statistics(Building &, NoteImmovable::Ownership ownership);
 	void update_team_players();
-	void play_message_sound(const std::string & sender);
+	void play_message_sound(const Message::Type & msgtype);
 	void _enhance_or_dismantle
 		(Building *, BuildingIndex const index_of_new_building);
 

=== modified file 'src/logic/playercommand.cc'
--- src/logic/playercommand.cc	2014-09-20 09:37:47 +0000
+++ src/logic/playercommand.cc	2014-12-28 17:03:29 +0000
@@ -1784,7 +1784,7 @@
 void CmdMessageSetStatusRead::execute (Game & game)
 {
 	game.player(sender()).messages().set_message_status
-		(message_id(), Message::Read);
+		(message_id(), Message::Status::kRead);
 }
 
 void CmdMessageSetStatusRead::serialize (StreamWrite & ser)
@@ -1800,7 +1800,7 @@
 void CmdMessageSetStatusArchived::execute (Game & game)
 {
 	game.player(sender()).messages().set_message_status
-		(message_id(), Message::Archived);
+		(message_id(), Message::Status::kArchived);
 }
 
 void CmdMessageSetStatusArchived::serialize (StreamWrite & ser)

=== modified file 'src/logic/productionsite.cc'
--- src/logic/productionsite.cc	2014-12-06 12:22:35 +0000
+++ src/logic/productionsite.cc	2014-12-28 17:03:29 +0000
@@ -925,7 +925,7 @@
 			assert(!descr().out_of_resource_message().empty());
 			send_message
 				(game,
-					  "produce",
+				 Message::Type::kEconomy,
 				 descr().out_of_resource_title(),
 				 descr().out_of_resource_message(),
 				 true,

=== modified file 'src/logic/ship.cc'
--- src/logic/ship.cc	2014-12-12 22:59:39 +0000
+++ src/logic/ship.cc	2014-12-28 17:03:29 +0000
@@ -21,8 +21,6 @@
 
 #include <memory>
 
-#include <boost/format.hpp>
-
 #include "base/macros.h"
 #include "economy/economy.h"
 #include "economy/flag.h"
@@ -51,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);
 }
 
@@ -76,12 +74,18 @@
 	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() {
@@ -100,11 +104,11 @@
 	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);
 }
@@ -114,15 +118,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);
 	}
@@ -138,48 +142,52 @@
 /**
  * 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()) {
@@ -203,43 +211,44 @@
 	}
 
 	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())
@@ -268,7 +277,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());
 
@@ -323,9 +332,10 @@
 	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);
 
@@ -333,30 +343,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
@@ -368,7 +378,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;
@@ -377,60 +387,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());
@@ -449,13 +459,13 @@
 			// Send a message to the player, that a new port space was found
 			std::string msg_head = _("Port Space Found");
 			std::string msg_body = _("An expedition ship found a new port build space.");
-			send_message(game, "exp_port_space", msg_head, msg_body, "port.png");
+			send_message(game, msg_head, msg_body, "port.png");
 		}
 		m_expedition->seen_port_buildspaces.swap(temp_port_buildspaces);
 	}
 }
 
-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
@@ -465,221 +475,214 @@
 		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;
-
-		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.
+		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) {
-				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);
+				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);
 			return;
 		}
-		// 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);
+		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);
+						}
 					}
+					// 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);
-					// 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, "exp_island", msg_head, msg_body, "ship_explore_island_cw.png");
-						m_ship_state = EXP_WAITING;
-						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->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.");
+					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
 				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);
+				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;
 			}
-			// coast reached
-			m_ship_state = EXP_WAITING;
+		}
+		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);
+			upcast(ConstructionSite, cs, baim);
+
+			for (int i = m_items.size() - 1; i >= 0; --i) {
+				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());
+					const uint32_t max = wq.get_max_fill();
+					const uint32_t cur = wq.get_filled();
+					assert(max > cur);
+					wq.set_filled(cur + 1);
+					m_items.at(i).remove(game);
+					m_items.resize(i);
+					break;
+				} else {
+					assert(worker);
+					worker->set_economy(nullptr);
+					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);
+					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);
+			}
+			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);
-			// 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, "exp_coast", msg_head, msg_body, "ship_explore_island_cw.png");
 			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);
-		upcast(ConstructionSite, cs, baim);
-
-		for (int i = m_items.size() - 1; i >= 0; --i) {
-			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());
-				const uint32_t max = wq.get_max_fill();
-				const uint32_t cur = wq.get_filled();
-				assert(max > cur);
-				wq.set_filled(cur + 1);
-				m_items.at(i).remove(game);
-				m_items.resize(i);
-				break;
-			} else {
-				assert(worker);
-				worker->set_economy(nullptr);
-				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);
-				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);
-		}
-		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;
-	}
-	}
 
 	// 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.
 
@@ -694,23 +697,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 {
@@ -723,8 +726,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;
@@ -750,7 +753,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
@@ -770,8 +773,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);
@@ -784,12 +787,12 @@
 	// Send a message to the player, that an expedition is ready to go
 	const std::string msg_head = _("Expedition Ready");
 	const std::string msg_body = _("An expedition ship is waiting for your commands.");
-	send_message(game, "exp_ready", msg_head, msg_body, "start_expedition.png");
+	send_message(game, msg_head, msg_body, "start_expedition.png");
 }
 
 /// 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;
@@ -798,7 +801,7 @@
 
 /// 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);
@@ -807,7 +810,7 @@
 
 /// Initializes / changes the direction the island exploration in @arg clockwise direction
 /// @note only called via player command
-void Ship::exp_explore_island(Game&, bool clockwise) {
+void Ship::exp_explore_island (Game &, bool clockwise) {
 	assert(m_expedition);
 	m_ship_state = EXP_SCOUTING;
 	m_expedition->clockwise = clockwise;
@@ -817,7 +820,7 @@
 
 /// 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())
@@ -831,7 +834,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) {
@@ -856,7 +859,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;
@@ -866,22 +869,25 @@
 	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.
  *
@@ -889,31 +895,29 @@
  *
  * \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& msgsender,
-                        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 = (boost::format("<rt image=pics/%s><p font-face=serif font-size=14>")
-								% picture).str();
-	} else {
-		rt_description = "<rt><p font-face=serif font-size=14>";
-	}
+		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 += description;
 	rt_description += "</p></rt>";
 
-	Message* msg =
-	   new Message(msgsender, 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);
 }
 
+
 /*
 ==============================
 
@@ -924,16 +928,20 @@
 
 #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) {
@@ -942,8 +950,15 @@
 			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,10 +990,11 @@
 	}
 }
 
-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);
@@ -991,10 +1007,11 @@
 	}
 }
 
-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;
@@ -1004,8 +1021,7 @@
 		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
@@ -1016,7 +1032,10 @@
 	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 {
@@ -1026,28 +1045,32 @@
 		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);
 
@@ -1064,9 +1087,11 @@
 		// 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
@@ -1091,4 +1116,4 @@
 	}
 }
 
-}  // namespace Widelands
+} // namespace Widelands

=== modified file 'src/logic/ship.h'
--- src/logic/ship.h	2014-09-10 08:55:04 +0000
+++ src/logic/ship.h	2014-12-28 17:03:29 +0000
@@ -208,8 +208,7 @@
 	void init_fleet(EditorGameBase &);
 	void set_fleet(Fleet * fleet);
 
-	void send_message
-		(Game &, const std::string &, const std::string &, const std::string &, const std::string &);
+	void send_message(Game &, const std::string &, const std::string &, const std::string &);
 
 	UI::Window * m_window;
 

=== modified file 'src/logic/soldier.cc'
--- src/logic/soldier.cc	2014-11-30 18:49:38 +0000
+++ src/logic/soldier.cc	2014-12-28 17:03:29 +0000
@@ -1571,7 +1571,7 @@
 					owner().add_message
 						(game,
 						 *new Message
-						 	("game engine",
+							(Message::Type::kGameLogic,
 							 game.get_gametime(),
 						 	 _("Logic error"),
 							 messagetext,
@@ -1580,7 +1580,7 @@
 					opponent.owner().add_message
 						(game,
 						 *new Message
-						 	("game engine",
+							(Message::Type::kGameLogic,
 							 game.get_gametime(),
 						 	 _("Logic error"),
 							 messagetext,

=== modified file 'src/logic/warehouse.cc'
--- src/logic/warehouse.cc	2014-12-12 22:59:39 +0000
+++ src/logic/warehouse.cc	2014-12-28 17:03:29 +0000
@@ -50,7 +50,7 @@
 
 namespace Widelands {
 
-namespace {
+namespace  {
 
 static const uint32_t WORKER_WITHOUT_COST_SPAWN_INTERVAL = 2500;
 
@@ -68,17 +68,19 @@
 
 }  // namespace
 
-WarehouseSupply::~WarehouseSupply() {
+WarehouseSupply::~WarehouseSupply()
+{
 	if (m_economy) {
-		log("WarehouseSupply::~WarehouseSupply: Warehouse %u still belongs to "
-		    "an economy",
-		    m_warehouse->serial());
+		log
+			("WarehouseSupply::~WarehouseSupply: Warehouse %u still belongs to "
+			 "an economy",
+			 m_warehouse->serial());
 		set_economy(nullptr);
 	}
 
 	// We're removed from the Economy. Therefore, the wares can simply
 	// be cleared out. The global inventory will be okay.
-	m_wares.clear();
+	m_wares  .clear();
 	m_workers.clear();
 }
 
@@ -94,8 +96,10 @@
 	m_workers.set_nrwares(i);
 }
 
+
 /// Add and remove our wares and the Supply to the economies as necessary.
-void WarehouseSupply::set_economy(Economy* const e) {
+void WarehouseSupply::set_economy(Economy * const e)
+{
 	if (e == m_economy)
 		return;
 
@@ -122,74 +126,87 @@
 	}
 }
 
+
 /// Add wares and update the economy.
-void WarehouseSupply::add_wares(WareIndex const id, uint32_t const count) {
+void WarehouseSupply::add_wares(WareIndex const id, uint32_t const count)
+{
 	if (!count)
 		return;
 
-	if (m_economy)  // No economies in the editor
+	if (m_economy) // No economies in the editor
 		m_economy->add_wares(id, count);
 	m_wares.add(id, count);
 }
 
+
 /// Remove wares and update the economy.
-void WarehouseSupply::remove_wares(WareIndex const id, uint32_t const count) {
+void WarehouseSupply::remove_wares(WareIndex const id, uint32_t const count)
+{
 	if (!count)
 		return;
 
 	m_wares.remove(id, count);
-	if (m_economy)  // No economies in the editor
+	if (m_economy) // No economies in the editor
 		m_economy->remove_wares(id, count);
 }
 
+
 /// Add workers and update the economy.
-void WarehouseSupply::add_workers(WareIndex const id, uint32_t const count) {
+void WarehouseSupply::add_workers(WareIndex const id, uint32_t const count)
+{
 	if (!count)
 		return;
 
-	if (m_economy)  // No economies in the editor
+	if (m_economy) // No economies in the editor
 		m_economy->add_workers(id, count);
 	m_workers.add(id, count);
 }
 
+
 /**
  * Remove workers and update the economy.
  * Comments see add_workers
  */
-void WarehouseSupply::remove_workers(WareIndex const id, uint32_t const count) {
+void WarehouseSupply::remove_workers(WareIndex const id, uint32_t const count)
+{
 	if (!count)
 		return;
 
 	m_workers.remove(id, count);
-	if (m_economy)  // No economies in the editor
+	if (m_economy) // No economies in the editor
 		m_economy->remove_workers(id, count);
 }
 
 /// Return the position of the Supply, i.e. the owning Warehouse.
-PlayerImmovable* WarehouseSupply::get_position(Game&) {
-	return m_warehouse;
-}
+PlayerImmovable * WarehouseSupply::get_position(Game &) {return m_warehouse;}
+
 
 /// Warehouse supplies are never active.
-bool WarehouseSupply::is_active() const {
-	return false;
-}
+bool WarehouseSupply::is_active() const {return false;}
 
-bool WarehouseSupply::has_storage() const {
+bool WarehouseSupply::has_storage() const
+{
 	return true;
 }
 
-void WarehouseSupply::get_ware_type(WareWorker& /* type */, WareIndex& /* ware */) const {
-	throw wexception("WarehouseSupply::get_ware_type: calling this is nonsensical");
+void WarehouseSupply::get_ware_type(WareWorker & /* type */, WareIndex & /* ware */) const
+{
+	throw wexception
+		("WarehouseSupply::get_ware_type: calling this is nonsensical");
 }
 
-void WarehouseSupply::send_to_storage(Game&, Warehouse* /* wh */) {
+void WarehouseSupply::send_to_storage(Game &, Warehouse * /* wh */)
+{
 	throw wexception("WarehouseSupply::send_to_storage: should never be called");
 }
 
-uint32_t WarehouseSupply::nr_supplies(const Game& game, const Request& req) const {
+uint32_t WarehouseSupply::nr_supplies
+	(const Game & game, const Request & req) const
+{
 	if (req.get_type() == wwWORKER)
-		return m_warehouse->count_workers(game, req.get_index(), req.get_requirements());
+		return
+			m_warehouse->count_workers
+				(game, req.get_index(), req.get_requirements());
 
 	//  Calculate how many wares can be sent out - it might be that we need them
 	// ourselves. E.g. for hiring new soldiers.
@@ -199,16 +216,18 @@
 	// of *this* warehouse + 1 (+1 is important, as else the ware would directly
 	// be taken back to the warehouse as the request of the warehouse would be
 	// highered and would have the same value as the original request)
-	int32_t const y = x + (req.get_priority(0) / 100) -
-	                  (m_warehouse->get_priority(wwWARE, req.get_index()) / 100) - 1;
+	int32_t const y =
+		x + (req.get_priority(0) / 100)
+		- (m_warehouse->get_priority(wwWARE, req.get_index()) / 100) - 1;
 	// But the number should never be higher than the number of wares available
 	if (y > x)
 		return x;
 	return (x > 0) ? x : 0;
 }
 
+
 /// Launch a ware.
-WareInstance& WarehouseSupply::launch_ware(Game& game, const Request& req) {
+WareInstance & WarehouseSupply::launch_ware(Game & game, const Request & req) {
 	if (req.get_type() != wwWARE)
 		throw wexception("WarehouseSupply::launch_ware: called for non-ware request");
 	if (!m_wares.stock(req.get_index()))
@@ -218,26 +237,29 @@
 }
 
 /// Launch a ware as worker.
-Worker& WarehouseSupply::launch_worker(Game& game, const Request& req) {
-	return m_warehouse->launch_worker(game, req.get_index(), req.get_requirements());
+Worker & WarehouseSupply::launch_worker(Game & game, const Request & req)
+{
+	return
+		m_warehouse->launch_worker
+			(game, req.get_index(), req.get_requirements());
 }
 
+
 /*
 ==============================
 Warehouse Building
 ==============================
 */
 
+
 /// Warehouse Descr
-WarehouseDescr::WarehouseDescr(char const* const _name,
-                               char const* const _descname,
-                               const std::string& directory,
-                               Profile& prof,
-                               Section& global_s,
-                               const TribeDescr& _tribe)
-   : BuildingDescr(MapObjectType::WAREHOUSE, _name, _descname, directory, prof, global_s, _tribe),
-     m_conquers(0),
-     m_heal_per_second(0) {
+WarehouseDescr::WarehouseDescr
+	(char const* const _name, char const* const _descname,
+	 const std::string& directory, Profile& prof, Section& global_s, const TribeDescr& _tribe)
+	: BuildingDescr(MapObjectType::WAREHOUSE, _name, _descname, directory, prof, global_s, _tribe),
+	  m_conquers         (0),
+	  m_heal_per_second  (0)
+{
 	m_heal_per_second = global_s.get_safe_int("heal_per_second");
 	if ((m_conquers = prof.get_safe_section("global").get_positive("conquers", 0)))
 		m_workarea_info[m_conquers].insert(descname() + " conquer");
@@ -249,21 +271,25 @@
 ==============================
 */
 
-Warehouse::Warehouse(const WarehouseDescr& warehouse_descr)
-   : Building(warehouse_descr),
-     m_supply(new WarehouseSupply(this)),
-     m_next_military_act(0),
-     m_portdock(nullptr) {
+Warehouse::Warehouse(const WarehouseDescr & warehouse_descr) :
+	Building(warehouse_descr),
+	m_supply(new WarehouseSupply(this)),
+	m_next_military_act(0),
+	m_portdock(nullptr)
+{
 	uint8_t nr_worker_types_without_cost =
-	   warehouse_descr.tribe().worker_types_without_cost().size();
-	m_next_worker_without_cost_spawn = new uint32_t[nr_worker_types_without_cost];
+		warehouse_descr.tribe().worker_types_without_cost().size();
+	m_next_worker_without_cost_spawn =
+		new uint32_t[nr_worker_types_without_cost];
 	for (int i = 0; i < nr_worker_types_without_cost; ++i) {
 		m_next_worker_without_cost_spawn[i] = never();
 	}
 	m_next_stock_remove_act = 0;
 }
 
-Warehouse::~Warehouse() {
+
+Warehouse::~Warehouse()
+{
 	delete m_supply;
 	delete[] m_next_worker_without_cost_spawn;
 }
@@ -272,19 +298,22 @@
  * Try to bring the given \ref PlannedWorkers up to date with our game data.
  * Return \c false if \p pw cannot be salvaged.
  */
-bool Warehouse::_load_finish_planned_worker(PlannedWorkers& pw) {
+bool Warehouse::_load_finish_planned_worker(PlannedWorkers & pw)
+{
 	if (pw.index == INVALID_INDEX || !(pw.index < m_supply->get_workers().get_nrwareids()))
 		return false;
 
-	const WorkerDescr* w_desc = descr().tribe().get_worker_descr(pw.index);
+	const WorkerDescr * w_desc = descr().tribe().get_worker_descr(pw.index);
 	if (!w_desc || !w_desc->is_buildable())
 		return false;
 
-	const WorkerDescr::Buildcost& cost = w_desc->buildcost();
+	const WorkerDescr::Buildcost & cost = w_desc->buildcost();
 	uint32_t idx = 0;
 
-	for (WorkerDescr::Buildcost::const_iterator cost_it = cost.begin(); cost_it != cost.end();
-	     ++cost_it, ++idx) {
+	for
+		(WorkerDescr::Buildcost::const_iterator cost_it = cost.begin();
+		 cost_it != cost.end(); ++cost_it, ++idx)
+	{
 		WareWorker type;
 		WareIndex ware;
 		ware = descr().tribe().ware_index(cost_it->first);
@@ -296,10 +325,13 @@
 			return false;
 
 		if (idx < pw.requests.size()) {
-			if (pw.requests[idx]->get_type() == type && pw.requests[idx]->get_index() == ware)
+			if
+				(pw.requests[idx]->get_type() == type &&
+				 pw.requests[idx]->get_index() == ware)
 				continue;
 
-			std::vector<Request*>::iterator req_it = pw.requests.begin() + idx + 1;
+			std::vector<Request *>::iterator req_it =
+				pw.requests.begin() + idx + 1;
 			while (req_it != pw.requests.end()) {
 				if ((*req_it)->get_type() == type && (*req_it)->get_index() == ware)
 					break;
@@ -312,16 +344,19 @@
 			}
 		}
 
-		log("_load_finish_planned_worker: old savegame: "
-		    "need to create new request for '%s'\n",
-		    cost_it->first.c_str());
-		pw.requests.insert(
-		   pw.requests.begin() + idx, new Request(*this, ware, &Warehouse::request_cb, type));
+		log
+			("_load_finish_planned_worker: old savegame: "
+			 "need to create new request for '%s'\n",
+			 cost_it->first.c_str());
+		pw.requests.insert
+			(pw.requests.begin() + idx,
+			 new Request(*this, ware, &Warehouse::request_cb, type));
 	}
 
 	while (pw.requests.size() > idx) {
-		log("_load_finish_planned_worker: old savegame: "
-		    "removing outdated request.\n");
+		log
+			("_load_finish_planned_worker: old savegame: "
+			 "removing outdated request.\n");
 		delete pw.requests.back();
 		pw.requests.pop_back();
 	}
@@ -329,31 +364,30 @@
 	return true;
 }
 
-void Warehouse::load_finish(EditorGameBase& egbase) {
+void Warehouse::load_finish(EditorGameBase & egbase) {
 	Building::load_finish(egbase);
 
 	uint32_t next_spawn = never();
-	const std::vector<WareIndex>& worker_types_without_cost =
-	   descr().tribe().worker_types_without_cost();
+	const std::vector<WareIndex> & worker_types_without_cost =
+		descr().tribe().worker_types_without_cost();
 	for (uint8_t i = worker_types_without_cost.size(); i;) {
 		WareIndex const worker_index = worker_types_without_cost.at(--i);
-		if (owner().is_worker_type_allowed(worker_index) &&
-		    m_next_worker_without_cost_spawn[i] == static_cast<uint32_t>(never())) {
+		if
+			(owner().is_worker_type_allowed(worker_index) &&
+			 m_next_worker_without_cost_spawn[i] == static_cast<uint32_t>(never()))
+		{
 			if (next_spawn == static_cast<uint32_t>(never())) {
-				next_spawn =
-				   schedule_act(dynamic_cast<Game&>(egbase), WORKER_WITHOUT_COST_SPAWN_INTERVAL);
+				next_spawn = schedule_act(dynamic_cast<Game&>(egbase), WORKER_WITHOUT_COST_SPAWN_INTERVAL);
 			}
 			m_next_worker_without_cost_spawn[i] = next_spawn;
-			log("WARNING: player %u is allowed to create worker type %s but his "
-			    "%s %u at (%i, %i) does not have a next_spawn time set for that "
-			    "worker type; setting it to %u\n",
-			    owner().player_number(),
-			    descr().tribe().get_worker_descr(worker_index)->descname().c_str(),
-			    descr().descname().c_str(),
-			    serial(),
-			    get_position().x,
-			    get_position().y,
-			    next_spawn);
+			log
+				("WARNING: player %u is allowed to create worker type %s but his "
+				 "%s %u at (%i, %i) does not have a next_spawn time set for that "
+				 "worker type; setting it to %u\n",
+				 owner().player_number(),
+				 descr().tribe().get_worker_descr(worker_index)->descname().c_str(),
+				 descr().descname().c_str(), serial(), get_position().x, get_position().y,
+				 next_spawn);
 		}
 	}
 
@@ -371,12 +405,13 @@
 	}
 }
 
-void Warehouse::init(EditorGameBase& egbase) {
+void Warehouse::init(EditorGameBase & egbase)
+{
 	Building::init(egbase);
 
-	WareIndex const nr_wares = descr().tribe().get_nrwares();
+	WareIndex const nr_wares   = descr().tribe().get_nrwares  ();
 	WareIndex const nr_workers = descr().tribe().get_nrworkers();
-	m_supply->set_nrwares(nr_wares);
+	m_supply->set_nrwares  (nr_wares);
 	m_supply->set_nrworkers(nr_workers);
 
 	m_ware_policy.resize(nr_wares, SP_Normal);
@@ -385,15 +420,17 @@
 	// Even though technically, a warehouse might be completely empty,
 	// we let warehouse see always for simplicity's sake (since there's
 	// almost always going to be a carrier inside, that shouldn't hurt).
-	Player& player = owner();
+	Player & player = owner();
 	if (upcast(Game, game, &egbase)) {
-		player.see_area(
-		   Area<FCoords>(egbase.map().get_fcoords(get_position()), descr().vision_range()));
+		player.see_area
+			(Area<FCoords>
+			 (egbase.map().get_fcoords(get_position()), descr().vision_range()));
 
 		{
-			uint32_t const act_time = schedule_act(*game, WORKER_WITHOUT_COST_SPAWN_INTERVAL);
-			const std::vector<WareIndex>& worker_types_without_cost =
-			   descr().tribe().worker_types_without_cost();
+			uint32_t const act_time = schedule_act
+					(*game, WORKER_WITHOUT_COST_SPAWN_INTERVAL);
+			const std::vector<WareIndex> & worker_types_without_cost =
+				descr().tribe().worker_types_without_cost();
 
 			for (size_t i = 0; i < worker_types_without_cost.size(); ++i) {
 				if (owner().is_worker_type_allowed(worker_types_without_cost.at(i))) {
@@ -408,21 +445,38 @@
 
 		m_next_stock_remove_act = schedule_act(*game, 4000);
 
-		log("Message: adding (wh) (%s) %i \n",
-		    to_string(descr().type()).c_str(),
-		    player.player_number());
-		send_message(*game,
-		             "warehouse",
-		             descr().descname(),
-		             (boost::format(_("A new %s was added to your economy.")) %
-		              descr().descname().c_str()).str(),
-		             true);
+		log("Message: adding (wh) (%s) %i \n", to_string(descr().type()).c_str(), player.player_number());
+
+		if (descr().name() == "port") {
+			send_message
+				(*game,
+				 Message::Type::kSeafaring,
+				 descr().descname(),
+				 _("A new port was added to your economy."),
+				 true);
+		} else if (descr().name() == "headquarters") {
+			send_message
+				(*game,
+				 Message::Type::kEconomy,
+				 descr().descname(),
+				 _("A new headquarters was added to your economy."),
+				 true);
+		} else {
+			send_message
+				(*game,
+				 Message::Type::kEconomy,
+				 descr().descname(),
+				 _("A new warehouse was added to your economy."),
+				 true);
+		}
 	}
 
 	if (uint32_t const conquer_radius = descr().get_conquers())
-		egbase.conquer_area(PlayerArea<Area<FCoords>>(
-		   player.player_number(),
-		   Area<FCoords>(egbase.map().get_fcoords(get_position()), conquer_radius)));
+		egbase.conquer_area
+			(PlayerArea<Area<FCoords> >
+			 	(player.player_number(),
+			 	 Area<FCoords>
+			 	 	(egbase.map().get_fcoords(get_position()), conquer_radius)));
 
 	if (descr().get_isport())
 		init_portdock(egbase);
@@ -432,10 +486,11 @@
  * Find a contiguous set of water fields close to the port for docking
  * and initialize the @ref PortDock instance.
  */
-void Warehouse::init_portdock(EditorGameBase& egbase) {
+void Warehouse::init_portdock(EditorGameBase & egbase)
+{
 	molog("Setting up port dock fields\n");
 
-	Map& map = egbase.map();
+	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");
@@ -456,12 +511,14 @@
 		m_portdock->set_economy(get_economy());
 }
 
-void Warehouse::destroy(EditorGameBase& egbase) {
+void Warehouse::destroy(EditorGameBase & egbase)
+{
 	Building::destroy(egbase);
 }
 
 /// Destroy the warehouse.
-void Warehouse::cleanup(EditorGameBase& egbase) {
+void Warehouse::cleanup(EditorGameBase & egbase)
+{
 	if (egbase.objects().object_still_available(m_portdock)) {
 		m_portdock->remove(egbase);
 		m_portdock = nullptr;
@@ -488,18 +545,21 @@
 
 	Map& map = egbase.map();
 	if (const uint32_t conquer_radius = descr().get_conquers())
-		egbase.unconquer_area(
-		   PlayerArea<Area<FCoords>>(owner().player_number(),
-		                             Area<FCoords>(map.get_fcoords(get_position()), conquer_radius)),
-		   m_defeating_player);
+		egbase.unconquer_area
+			(PlayerArea<Area<FCoords> >
+			 	(owner().player_number(),
+			 	 Area<FCoords>(map.get_fcoords(get_position()), conquer_radius)),
+			 m_defeating_player);
 
 	// Unsee the area that we started seeing in init()
-	Player& player = owner();
-	player.unsee_area(Area<FCoords>(map.get_fcoords(get_position()), descr().vision_range()));
+	Player & player = owner();
+	player.unsee_area
+			(Area<FCoords>(map.get_fcoords(get_position()), descr().vision_range()));
 
 	Building::cleanup(egbase);
 }
 
+
 /// Act regularly to create workers of buildable types without cost. According
 /// to intelligence, this is some highly advanced technology. Not only do the
 /// settlers have no problems with birth control, they do not even need anybody
@@ -507,11 +567,12 @@
 /// what the hell are they doing, killing useless tribesmen! The Borg? Or just
 /// like Soylent Green? Or maybe I should just stop writing comments that late
 /// at night ;-)
-void Warehouse::act(Game& game, uint32_t const data) {
+void Warehouse::act(Game & game, uint32_t const data)
+{
 	uint32_t const gametime = game.get_gametime();
 	{
-		const std::vector<WareIndex>& worker_types_without_cost =
-		   owner().tribe().worker_types_without_cost();
+		const std::vector<WareIndex> & worker_types_without_cost =
+			owner().tribe().worker_types_without_cost();
 		for (size_t i = worker_types_without_cost.size(); i;)
 			if (m_next_worker_without_cost_spawn[--i] <= gametime) {
 				WareIndex const id = worker_types_without_cost.at(i);
@@ -529,7 +590,8 @@
 						remove_workers(id, 1);
 					}
 
-					m_next_worker_without_cost_spawn[i] = schedule_act(game, tdelta);
+					m_next_worker_without_cost_spawn[i] =
+						schedule_act(game, tdelta);
 				} else
 					m_next_worker_without_cost_spawn[i] = never();
 			}
@@ -540,15 +602,19 @@
 		WareIndex const ware = descr().tribe().safe_worker_index("soldier");
 
 		if (m_incorporated_workers.count(ware)) {
-			WorkerList& soldiers = m_incorporated_workers[ware];
+			WorkerList & soldiers = m_incorporated_workers[ware];
 
 			uint32_t total_heal = descr().get_heal_per_second();
 			// Using an explicit iterator, as we plan to erase some
 			// of those guys
-			for (WorkerList::iterator it = soldiers.begin(); it != soldiers.end(); ++it) {
+			for
+				(WorkerList::iterator it = soldiers.begin();
+				 it != soldiers.end();
+				 ++it)
+			{
 				// This is a safe cast: we know only soldiers can land in this
 				// slot in the incorporated array
-				Soldier* soldier = static_cast<Soldier*>(*it);
+				Soldier * soldier = static_cast<Soldier *>(*it);
 
 				//  Soldier dead ...
 				if (!soldier || soldier->get_current_hitpoints() == 0) {
@@ -561,6 +627,7 @@
 					soldier->heal(total_heal);
 					continue;
 				}
+
 			}
 		}
 		m_next_military_act = schedule_act(game, 1000);
@@ -581,9 +648,11 @@
 	Building::act(game, data);
 }
 
+
 /// Transfer our registration to the new economy.
-void Warehouse::set_economy(Economy* const e) {
-	Economy* const old = get_economy();
+void Warehouse::set_economy(Economy * const e)
+{
+	Economy * const old = get_economy();
 
 	if (old == e)
 		return;
@@ -597,7 +666,7 @@
 	Building::set_economy(e);
 
 	for (const PlannedWorkers& pw : m_planned_workers) {
-		for (Request* req : pw.requests) {
+		for (Request * req : pw.requests) {
 			req->set_economy(e);
 		}
 	}
@@ -609,62 +678,82 @@
 		e->add_warehouse(*this);
 }
 
-const WareList& Warehouse::get_wares() const {
+
+const WareList & Warehouse::get_wares() const
+{
 	return m_supply->get_wares();
 }
 
-const WareList& Warehouse::get_workers() const {
+
+const WareList & Warehouse::get_workers() const
+{
 	return m_supply->get_workers();
 }
 
-PlayerImmovable::Workers Warehouse::get_incorporated_workers() {
+PlayerImmovable::Workers Warehouse::get_incorporated_workers()
+{
 	PlayerImmovable::Workers all_workers;
 
 	for (const std::pair<WareIndex, WorkerList>& worker_pair : m_incorporated_workers) {
-		for (Worker* worker : worker_pair.second) {
+		for (Worker * worker : worker_pair.second) {
 			all_workers.push_back(worker);
 		}
 	}
 	return all_workers;
 }
 
+
 /// Magically create wares in this warehouse. Updates the economy accordingly.
-void Warehouse::insert_wares(WareIndex const id, uint32_t const count) {
+void Warehouse::insert_wares(WareIndex const id, uint32_t const count)
+{
 	m_supply->add_wares(id, count);
 }
 
+
 /// Magically destroy wares.
-void Warehouse::remove_wares(WareIndex const id, uint32_t const count) {
+void Warehouse::remove_wares(WareIndex const id, uint32_t const count)
+{
 	m_supply->remove_wares(id, count);
 }
 
+
 /// Magically create workers in this warehouse. Updates the economy accordingly.
-void Warehouse::insert_workers(WareIndex const id, uint32_t const count) {
+void Warehouse::insert_workers(WareIndex const id, uint32_t const count)
+{
 	m_supply->add_workers(id, count);
 }
 
+
 /// Magically destroy workers.
-void Warehouse::remove_workers(WareIndex const id, uint32_t const count) {
+void Warehouse::remove_workers(WareIndex const id, uint32_t const count)
+{
 	m_supply->remove_workers(id, count);
 }
 
+
+
 /// Launch a carrier to fetch an ware from our flag.
-bool Warehouse::fetch_from_flag(Game& game) {
+bool Warehouse::fetch_from_flag(Game & game)
+{
 	WareIndex const carrierid = descr().tribe().safe_worker_index("carrier");
 
-	if (!m_supply->stock_workers(carrierid))  // XXX yep, let's cheat
+	if (!m_supply->stock_workers(carrierid)) // XXX yep, let's cheat
 		insert_workers(carrierid, 1);
 
-	launch_worker(game, carrierid, Requirements()).start_task_fetchfromflag(game);
+	launch_worker(game, carrierid, Requirements()).start_task_fetchfromflag
+		(game);
 
 	return true;
 }
 
+
 /**
  * \return the number of workers that we can launch satisfying the given
  * requirements.
  */
-uint32_t Warehouse::count_workers(const Game& /* game */, WareIndex ware, const Requirements& req) {
+uint32_t Warehouse::count_workers
+	(const Game & /* game */, WareIndex ware, const Requirements & req)
+{
 	uint32_t sum = 0;
 
 	do {
@@ -672,7 +761,7 @@
 
 		// NOTE: This code lies about the TrainingAttributes of non-instantiated workers.
 		if (m_incorporated_workers.count(ware)) {
-			for (Worker* worker : m_incorporated_workers[ware]) {
+			for (Worker * worker : m_incorporated_workers[ware]) {
 				if (!req.check(*worker)) {
 					//  This is one of the workers in our sum.
 					//  But he is too stupid for this job
@@ -689,7 +778,9 @@
 
 /// Start a worker of a given type. The worker will
 /// be assigned a job by the caller.
-Worker& Warehouse::launch_worker(Game& game, WareIndex ware, const Requirements& req) {
+Worker & Warehouse::launch_worker
+	(Game & game, WareIndex ware, const Requirements & req)
+{
 	do {
 		if (m_supply->stock_workers(ware)) {
 			uint32_t unincorporated = m_supply->stock_workers(ware);
@@ -702,15 +793,15 @@
 				remove_no_longer_existing_workers(game, &m_incorporated_workers[ware]);
 				WorkerList& incorporated_workers = m_incorporated_workers[ware];
 
-				for (std::vector<Worker*>::iterator worker_iter = incorporated_workers.begin();
-				     worker_iter != incorporated_workers.end();
-				     ++worker_iter) {
+				for (std::vector<Worker *>::iterator worker_iter = incorporated_workers.begin();
+					 worker_iter != incorporated_workers.end(); ++worker_iter)
+				{
 					Worker* worker = *worker_iter;
 					--unincorporated;
 
 					if (req.check(*worker)) {
-						worker->reset_tasks(game);   //  forget everything you did
-						worker->set_location(this);  //  back in a economy
+						worker->reset_tasks(game);  //  forget everything you did
+						worker->set_location(this); //  back in a economy
 						incorporated_workers.erase(worker_iter);
 
 						m_supply->remove_workers(ware, 1);
@@ -725,7 +816,7 @@
 				// Create a new one
 				// NOTE: This code lies about the TrainingAttributes of the new worker
 				m_supply->remove_workers(ware, 1);
-				const WorkerDescr& workerdescr = *descr().tribe().get_worker_descr(ware);
+				const WorkerDescr & workerdescr = *descr().tribe().get_worker_descr(ware);
 				return workerdescr.create(game, owner(), this, m_position);
 			}
 		}
@@ -738,10 +829,13 @@
 		}
 	} while (ware != INVALID_INDEX);
 
-	throw wexception("Warehouse::launch_worker: worker does not actually exist");
+	throw wexception
+		("Warehouse::launch_worker: worker does not actually exist");
 }
 
-void Warehouse::incorporate_worker(EditorGameBase& egbase, Worker* w) {
+
+void Warehouse::incorporate_worker(EditorGameBase & egbase, Worker* w)
+{
 	assert(w != nullptr);
 	assert(w->get_owner() == &owner());
 
@@ -767,10 +861,10 @@
 
 	// Incorporate the worker
 	if (!m_incorporated_workers.count(worker_index))
-		m_incorporated_workers[worker_index] = std::vector<Worker*>();
+		m_incorporated_workers[worker_index] = std::vector<Worker *>();
 	m_incorporated_workers[worker_index].push_back(w);
 
-	w->set_location(nullptr);  //  no longer in an economy
+	w->set_location(nullptr); //  no longer in an economy
 
 	if (upcast(Game, game, &egbase)) {
 		//  Bind the worker into this house, hide him on the map.
@@ -781,9 +875,9 @@
 
 /// Create an instance of a ware and make sure it gets
 /// carried out of the warehouse.
-WareInstance& Warehouse::launch_ware(Game& game, WareIndex const ware_index) {
+WareInstance & Warehouse::launch_ware(Game & game, WareIndex const ware_index) {
 	// Create the ware
-	WareInstance& ware = *new WareInstance(ware_index, descr().tribe().get_ware_descr(ware_index));
+	WareInstance & ware = *new WareInstance(ware_index, descr().tribe().get_ware_descr(ware_index));
 	ware.init(game);
 	do_launch_ware(game, ware);
 
@@ -792,13 +886,15 @@
 	return ware;
 }
 
+
 /// Get a carrier to actually move this ware out of the warehouse.
-void Warehouse::do_launch_ware(Game& game, WareInstance& ware) {
+void Warehouse::do_launch_ware(Game & game, WareInstance & ware)
+{
 	// Create a carrier
 	WareIndex const carrierid = descr().tribe().worker_index("carrier");
-	const WorkerDescr& workerdescr = *descr().tribe().get_worker_descr(carrierid);
+	const WorkerDescr & workerdescr = *descr().tribe().get_worker_descr(carrierid);
 
-	Worker& worker = workerdescr.create(game, owner(), this, m_position);
+	Worker & worker = workerdescr.create(game, owner(), this, m_position);
 
 	// Yup, this is cheating.
 	if (m_supply->stock_workers(carrierid))
@@ -808,15 +904,23 @@
 	worker.start_task_dropoff(game, ware);
 }
 
-void Warehouse::incorporate_ware(EditorGameBase& egbase, WareInstance* ware) {
+
+void Warehouse::incorporate_ware(EditorGameBase & egbase, WareInstance* ware)
+{
 	m_supply->add_wares(ware->descr_index(), 1);
 	ware->destroy(egbase);
 }
 
+
 /// Called when a transfer for one of the idle Requests completes.
-void Warehouse::request_cb(
-   Game& game, Request&, WareIndex const ware, Worker* const w, PlayerImmovable& target) {
-	Warehouse& wh = dynamic_cast<Warehouse&>(target);
+void Warehouse::request_cb
+	(Game            &       game,
+	 Request         &,
+	 WareIndex        const ware,
+	 Worker          * const w,
+	 PlayerImmovable &       target)
+{
+	Warehouse & wh = dynamic_cast<Warehouse&>(target);
 
 	if (w) {
 		w->schedule_incorporate(game);
@@ -833,35 +937,38 @@
 /**
  * Receive a ware from a transfer that was not associated to a \ref Request.
  */
-void Warehouse::receive_ware(Game& /* game */, WareIndex ware) {
+void Warehouse::receive_ware(Game & /* game */, WareIndex ware)
+{
 	m_supply->add_wares(ware, 1);
 }
 
 /**
  * Receive a worker from a transfer that was not associated to a \ref Request.
  */
-void Warehouse::receive_worker(Game& game, Worker& worker) {
+void Warehouse::receive_worker(Game & game, Worker & worker)
+{
 	worker.schedule_incorporate(game);
 }
 
-Building& WarehouseDescr::create_object() const {
+Building & WarehouseDescr::create_object() const {
 	return *new Warehouse(*this);
 }
 
-bool Warehouse::can_create_worker(Game&, WareIndex const worker) const {
+
+bool Warehouse::can_create_worker(Game &, WareIndex const worker) const {
 	if (!(worker < m_supply->get_workers().get_nrwareids()))
-		throw wexception("worker type %d does not exists (max is %d)",
-		                 worker,
-		                 m_supply->get_workers().get_nrwareids());
+		throw wexception
+			("worker type %d does not exists (max is %d)",
+			 worker, m_supply->get_workers().get_nrwareids());
 
-	const WorkerDescr& w_desc = *descr().tribe().get_worker_descr(worker);
+	const WorkerDescr & w_desc = *descr().tribe().get_worker_descr(worker);
 	assert(&w_desc);
 	if (!w_desc.is_buildable())
 		return false;
 
 	//  see if we have the resources
 	for (const std::pair<std::string, uint8_t>& buildcost : w_desc.buildcost()) {
-		const std::string& input_name = buildcost.first;
+		const std::string & input_name = buildcost.first;
 		WareIndex id_w = descr().tribe().ware_index(input_name);
 		if (id_w != INVALID_INDEX) {
 			if (m_supply->stock_wares(id_w) < buildcost.second)
@@ -870,26 +977,27 @@
 			if (m_supply->stock_workers(id_w) < buildcost.second)
 				return false;
 		} else
-			throw wexception("worker type %s needs \"%s\" to be built but that is neither "
-			                 "a ware type nor a worker type defined in the tribe %s",
-			                 w_desc.descname().c_str(),
-			                 input_name.c_str(),
-			                 descr().tribe().name().c_str());
+			throw wexception
+				("worker type %s needs \"%s\" to be built but that is neither "
+				 "a ware type nor a worker type defined in the tribe %s",
+				 w_desc.descname().c_str(), input_name.c_str(),
+				 descr().tribe().name().c_str());
 	}
 	return true;
 }
 
-void Warehouse::create_worker(Game& game, WareIndex const worker) {
-	assert(can_create_worker(game, worker));
-
-	const WorkerDescr& w_desc = *descr().tribe().get_worker_descr(worker);
+
+void Warehouse::create_worker(Game & game, WareIndex const worker) {
+	assert(can_create_worker (game, worker));
+
+	const WorkerDescr & w_desc = *descr().tribe().get_worker_descr(worker);
 
 	for (const std::pair<std::string, uint8_t>& buildcost : w_desc.buildcost()) {
-		const std::string& input = buildcost.first;
+		const std::string & input = buildcost.first;
 		WareIndex const id_ware = descr().tribe().ware_index(input);
 		if (id_ware != INVALID_INDEX) {
-			remove_wares(id_ware, buildcost.second);
-			// update statistic accordingly
+			remove_wares  (id_ware,                        buildcost.second);
+			//update statistic accordingly
 			owner().ware_consumed(id_ware, buildcost.second);
 		} else
 			remove_workers(descr().tribe().safe_worker_index(input), buildcost.second);
@@ -911,7 +1019,8 @@
  * Return the number of workers of the given type that we plan to
  * create in this warehouse.
  */
-uint32_t Warehouse::get_planned_workers(Game& /* game */, WareIndex index) const {
+uint32_t Warehouse::get_planned_workers(Game & /* game */, WareIndex index) const
+{
 	for (const PlannedWorkers& pw : m_planned_workers) {
 		if (pw.index == index)
 			return pw.amount;
@@ -925,21 +1034,23 @@
  *
  * This is the current stock plus any incoming transfers.
  */
-std::vector<uint32_t> Warehouse::calc_available_for_worker(Game& /* game */,
-                                                           WareIndex index) const {
-	const WorkerDescr& w_desc = *descr().tribe().get_worker_descr(index);
+std::vector<uint32_t> Warehouse::calc_available_for_worker
+	(Game & /* game */, WareIndex index) const
+{
+	const WorkerDescr & w_desc = *descr().tribe().get_worker_descr(index);
 	std::vector<uint32_t> available;
 
 	for (const std::pair<std::string, uint8_t>& buildcost : w_desc.buildcost()) {
-		const std::string& input_name = buildcost.first;
+		const std::string & input_name = buildcost.first;
 		WareIndex id_w = descr().tribe().ware_index(input_name);
 		if (id_w != INVALID_INDEX) {
 			available.push_back(get_wares().stock(id_w));
 		} else if ((id_w = descr().tribe().worker_index(input_name)) != INVALID_INDEX) {
 			available.push_back(get_workers().stock(id_w));
 		} else
-			throw wexception(
-			   "Economy::_create_requested_worker: buildcost inconsistency '%s'", input_name.c_str());
+			throw wexception
+				("Economy::_create_requested_worker: buildcost inconsistency '%s'",
+				 input_name.c_str());
 	}
 
 	for (const PlannedWorkers& pw : m_planned_workers) {
@@ -955,12 +1066,14 @@
 	return available;
 }
 
+
 /**
  * Set the amount of workers we plan to create
  * of the given \p index to \p amount.
  */
-void Warehouse::plan_workers(Game& game, WareIndex index, uint32_t amount) {
-	PlannedWorkers* pw = nullptr;
+void Warehouse::plan_workers(Game & game, WareIndex index, uint32_t amount)
+{
+	PlannedWorkers * pw = nullptr;
 
 	for (PlannedWorkers& planned_worker : m_planned_workers) {
 		if (planned_worker.index == index) {
@@ -978,17 +1091,22 @@
 		pw->index = index;
 		pw->amount = 0;
 
-		const WorkerDescr& w_desc = *descr().tribe().get_worker_descr(pw->index);
+		const WorkerDescr & w_desc = *descr().tribe().get_worker_descr(pw->index);
 		for (const std::pair<std::string, uint8_t>& buildcost : w_desc.buildcost()) {
-			const std::string& input_name = buildcost.first;
+			const std::string & input_name = buildcost.first;
 
 			WareIndex id_w = descr().tribe().ware_index(input_name);
 			if (id_w != INVALID_INDEX) {
-				pw->requests.push_back(new Request(*this, id_w, &Warehouse::request_cb, wwWARE));
+				pw->requests.push_back
+					(new Request
+					 (*this, id_w, &Warehouse::request_cb, wwWARE));
 			} else if ((id_w = descr().tribe().worker_index(input_name)) != INVALID_INDEX) {
-				pw->requests.push_back(new Request(*this, id_w, &Warehouse::request_cb, wwWORKER));
+				pw->requests.push_back
+					(new Request
+					 (*this, id_w, &Warehouse::request_cb, wwWORKER));
 			} else
-				throw wexception("plan_workers: bad buildcost '%s'", input_name.c_str());
+				throw wexception
+					("plan_workers: bad buildcost '%s'", input_name.c_str());
 		}
 	}
 
@@ -1000,8 +1118,10 @@
  * See if we can create the workers of the given plan,
  * and update requests accordingly.
  */
-void Warehouse::_update_planned_workers(Game& game, Warehouse::PlannedWorkers& pw) {
-	const WorkerDescr& w_desc = *descr().tribe().get_worker_descr(pw.index);
+void Warehouse::_update_planned_workers
+	(Game & game, Warehouse::PlannedWorkers & pw)
+{
+	const WorkerDescr & w_desc = *descr().tribe().get_worker_descr(pw.index);
 
 	while (pw.amount && can_create_worker(game, pw.index)) {
 		create_worker(game, pw.index);
@@ -1010,7 +1130,7 @@
 	uint32_t idx = 0;
 	for (const std::pair<std::string, uint8_t>& buildcost : w_desc.buildcost()) {
 
-		const std::string& input_name = buildcost.first;
+		const std::string & input_name = buildcost.first;
 		uint32_t supply;
 
 		WareIndex id_w = descr().tribe().ware_index(input_name);
@@ -1019,12 +1139,14 @@
 		} else if ((id_w = descr().tribe().worker_index(input_name)) != INVALID_INDEX) {
 			supply = m_supply->stock_workers(id_w);
 		} else
-			throw wexception("_update_planned_workers: bad buildcost '%s'", input_name.c_str());
+			throw wexception
+				("_update_planned_workers: bad buildcost '%s'", input_name.c_str());
 
 		if (supply >= pw.amount * buildcost.second)
 			pw.requests[idx]->set_count(0);
 		else
-			pw.requests[idx]->set_count(pw.amount * buildcost.second - supply);
+			pw.requests[idx]->set_count
+				(pw.amount * buildcost.second - supply);
 		++idx;
 	}
 
@@ -1040,7 +1162,8 @@
  * Needs to be called periodically, because some necessary supplies might arrive
  * due to idle transfers instead of by explicit request.
  */
-void Warehouse::_update_all_planned_workers(Game& game) {
+void Warehouse::_update_all_planned_workers(Game & game)
+{
 	uint32_t idx = 0;
 	while (idx < m_planned_workers.size()) {
 		_update_planned_workers(game, m_planned_workers[idx]);
@@ -1054,35 +1177,51 @@
 	}
 }
 
-void Warehouse::enable_spawn(Game& game, uint8_t const worker_types_without_cost_index) {
-	assert(m_next_worker_without_cost_spawn[worker_types_without_cost_index] ==
-	       static_cast<uint32_t>(never()));
+void Warehouse::enable_spawn
+	(Game & game, uint8_t const worker_types_without_cost_index)
+{
+	assert
+		(m_next_worker_without_cost_spawn[worker_types_without_cost_index]
+		 ==
+		 static_cast<uint32_t>(never()));
 	m_next_worker_without_cost_spawn[worker_types_without_cost_index] =
-	   schedule_act(game, WORKER_WITHOUT_COST_SPAWN_INTERVAL);
+		schedule_act(game, WORKER_WITHOUT_COST_SPAWN_INTERVAL);
 }
-void Warehouse::disable_spawn(uint8_t const worker_types_without_cost_index) {
-	assert(m_next_worker_without_cost_spawn[worker_types_without_cost_index] !=
-	       static_cast<uint32_t>(never()));
+void Warehouse::disable_spawn(uint8_t const worker_types_without_cost_index)
+{
+	assert
+		(m_next_worker_without_cost_spawn[worker_types_without_cost_index]
+		 !=
+		 static_cast<uint32_t>(never()));
 	m_next_worker_without_cost_spawn[worker_types_without_cost_index] = never();
 }
 
-bool Warehouse::can_attack() {
+
+bool Warehouse::can_attack()
+{
 	return descr().get_conquers() > 0;
 }
 
-void Warehouse::aggressor(Soldier& enemy) {
+void Warehouse::aggressor(Soldier & enemy)
+{
 	if (!descr().get_conquers())
 		return;
 
-	Game& game = dynamic_cast<Game&>(owner().egbase());
-	Map& map = game.map();
-	if (enemy.get_owner() == &owner() || enemy.get_battle() ||
-	    descr().get_conquers() <= map.calc_distance(enemy.get_position(), get_position()))
+	Game & game = dynamic_cast<Game&>(owner().egbase());
+	Map  & map  = game.map();
+	if
+		(enemy.get_owner() == &owner() ||
+		 enemy.get_battle() ||
+		 descr().get_conquers()
+		 <=
+		 map.calc_distance(enemy.get_position(), get_position()))
 		return;
 
-	if (game.map().find_bobs(Area<FCoords>(map.get_fcoords(base_flag().get_position()), 2),
-	                         nullptr,
-	                         FindBobEnemySoldier(&owner())))
+	if
+		(game.map().find_bobs
+		 	(Area<FCoords>(map.get_fcoords(base_flag().get_position()), 2),
+		 	 nullptr,
+		 	 FindBobEnemySoldier(&owner())))
 		return;
 
 	WareIndex const soldier_index = descr().tribe().worker_index("soldier");
@@ -1091,17 +1230,18 @@
 	if (!count_workers(game, soldier_index, noreq))
 		return;
 
-	Soldier& defender = dynamic_cast<Soldier&>(launch_worker(game, soldier_index, noreq));
+	Soldier & defender = dynamic_cast<Soldier&>(launch_worker(game, soldier_index, noreq));
 	defender.start_task_defense(game, false);
 }
 
-bool Warehouse::attack(Soldier& enemy) {
-	Game& game = dynamic_cast<Game&>(owner().egbase());
+bool Warehouse::attack(Soldier & enemy)
+{
+	Game & game = dynamic_cast<Game&>(owner().egbase());
 	WareIndex const soldier_index = descr().tribe().worker_index("soldier");
 	Requirements noreq;
 
 	if (count_workers(game, soldier_index, noreq)) {
-		Soldier& defender = dynamic_cast<Soldier&>(launch_worker(game, soldier_index, noreq));
+		Soldier & defender = dynamic_cast<Soldier&>(launch_worker(game, soldier_index, noreq));
 		defender.start_task_defense(game, true);
 		enemy.send_signal(game, "sleep");
 		return true;
@@ -1112,36 +1252,45 @@
 	return false;
 }
 
-void Warehouse::PlannedWorkers::cleanup() {
+void Warehouse::PlannedWorkers::cleanup()
+{
 	while (!requests.empty()) {
 		delete requests.back();
 		requests.pop_back();
 	}
 }
 
-Warehouse::StockPolicy Warehouse::get_ware_policy(WareIndex ware) const {
+Warehouse::StockPolicy Warehouse::get_ware_policy(WareIndex ware) const
+{
 	assert(ware < m_ware_policy.size());
 	return m_ware_policy[ware];
 }
 
-Warehouse::StockPolicy Warehouse::get_worker_policy(WareIndex ware) const {
+Warehouse::StockPolicy Warehouse::get_worker_policy(WareIndex ware) const
+{
 	assert(ware < m_worker_policy.size());
 	return m_worker_policy[ware];
 }
 
-Warehouse::StockPolicy Warehouse::get_stock_policy(WareWorker waretype, WareIndex wareindex) const {
+Warehouse::StockPolicy Warehouse::get_stock_policy
+	(WareWorker waretype, WareIndex wareindex) const
+{
 	if (waretype == wwWORKER)
 		return get_worker_policy(wareindex);
 	else
 		return get_ware_policy(wareindex);
 }
 
-void Warehouse::set_ware_policy(WareIndex ware, Warehouse::StockPolicy policy) {
+
+void Warehouse::set_ware_policy(WareIndex ware, Warehouse::StockPolicy policy)
+{
 	assert(ware < m_ware_policy.size());
 	m_ware_policy[ware] = policy;
 }
 
-void Warehouse::set_worker_policy(WareIndex ware, Warehouse::StockPolicy policy) {
+void Warehouse::set_worker_policy
+	(WareIndex ware, Warehouse::StockPolicy policy)
+{
 	assert(ware < m_worker_policy.size());
 	m_worker_policy[ware] = policy;
 }
@@ -1150,7 +1299,8 @@
  * Check if there are remaining wares with stock policy \ref SP_Remove,
  * and remove one of them if appropriate.
  */
-void Warehouse::check_remove_stock(Game& game) {
+void Warehouse::check_remove_stock(Game & game)
+{
 	if (base_flag().current_wares() < base_flag().total_capacity() / 2) {
 		for (WareIndex ware = 0; ware < m_ware_policy.size(); ++ware) {
 			if (get_ware_policy(ware) != SP_Remove || !get_wares().stock(ware))
@@ -1165,7 +1315,7 @@
 		if (get_worker_policy(widx) != SP_Remove || !get_workers().stock(widx))
 			continue;
 
-		Worker& worker = launch_worker(game, widx, Requirements());
+		Worker & worker = launch_worker(game, widx, Requirements());
 		worker.start_task_leavebuilding(game, true);
 		break;
 	}
@@ -1181,34 +1331,36 @@
 /*
  * SoldierControl implementations
  */
-std::vector<Soldier*> Warehouse::present_soldiers() const {
-	std::vector<Soldier*> rv;
+std::vector<Soldier *> Warehouse::present_soldiers() const
+{
+	std::vector<Soldier *> rv;
 
 	WareIndex const ware = descr().tribe().safe_worker_index("soldier");
 	IncorporatedWorkers::const_iterator sidx = m_incorporated_workers.find(ware);
 
 	if (sidx != m_incorporated_workers.end()) {
-		const WorkerList& soldiers = sidx->second;
+		const WorkerList & soldiers = sidx->second;
 
-		for (Worker* temp_soldier : soldiers) {
-			rv.push_back(static_cast<Soldier*>(temp_soldier));
+		for (Worker * temp_soldier: soldiers) {
+			rv.push_back(static_cast<Soldier *>(temp_soldier));
 		}
 	}
 
 	return rv;
 }
-int Warehouse::incorporate_soldier(EditorGameBase& egbase, Soldier& soldier) {
+int Warehouse::incorporate_soldier(EditorGameBase & egbase, Soldier & soldier) {
 	incorporate_worker(egbase, &soldier);
 	return 0;
 }
 
-int Warehouse::outcorporate_soldier(EditorGameBase& /* egbase */, Soldier& soldier) {
+int Warehouse::outcorporate_soldier(EditorGameBase & /* egbase */, Soldier & soldier) {
 
 	WareIndex const ware = descr().tribe().safe_worker_index("soldier");
 	if (m_incorporated_workers.count(ware)) {
-		WorkerList& soldiers = m_incorporated_workers[ware];
+		WorkerList & soldiers = m_incorporated_workers[ware];
 
-		WorkerList::iterator i = std::find(soldiers.begin(), soldiers.end(), &soldier);
+		WorkerList::iterator i = std::find
+			(soldiers.begin(), soldiers.end(), &soldier);
 
 		soldiers.erase(i);
 		m_supply->remove_workers(ware, 1);
@@ -1221,10 +1373,13 @@
 	return 0;
 }
 
-void Warehouse::log_general_info(const EditorGameBase& egbase) {
+void Warehouse::log_general_info(const EditorGameBase & egbase)
+{
 	Building::log_general_info(egbase);
 
 	if (descr().get_isport())
 		molog("Port dock: %u\n", m_portdock ? m_portdock->serial() : 0);
 }
+
+
 }

=== modified file 'src/logic/worker.cc'
--- src/logic/worker.cc	2014-12-11 12:38:10 +0000
+++ src/logic/worker.cc	2014-12-28 17:03:29 +0000
@@ -938,12 +938,24 @@
 					 % rdescr->name().c_str()
 					 % _("A geologist found resources.")).str();
 
+			Message::Type message_type = Message::Type::kGeologists;
+			if (rdescr->name() == "coal")
+				message_type = Message::Type::kGeologistsCoal;
+			else if (rdescr->name() == "gold")
+				message_type = Message::Type::kGeologistsGold;
+			else if (rdescr->name() == "granite")
+				message_type = Message::Type::kGeologistsGranite;
+			else if (rdescr->name() == "iron")
+				message_type = Message::Type::kGeologistsIron;
+			else if (rdescr->name() == "water")
+				message_type = Message::Type::kGeologistsWater;
+
 			//  We should add a message to the player's message queue - but only,
 			//  if there is not already a similar one in list.
 			owner().add_message_with_timeout
 				(game,
 				 *new Message
-				 	("geologist " + rdescr->name(), // e.g. "geologist gold"
+					(message_type,
 					 game.get_gametime(),
 				 	 rdescr->descname(),
 				 	 message,
@@ -1843,7 +1855,7 @@
 		owner().add_message
 			(game,
 			 *new Message
-			 	("game engine",
+				(Message::Type::kGameLogic,
 				 game.get_gametime(),
 			 	 _("Worker got lost!"),
 				 message,

=== modified file 'src/map_io/map_players_messages_packet.cc'
--- src/map_io/map_players_messages_packet.cc	2014-10-27 10:14:10 +0000
+++ src/map_io/map_players_messages_packet.cc	2014-12-28 17:03:29 +0000
@@ -22,6 +22,7 @@
 #include <boost/format.hpp>
 
 #include "logic/game_data_error.h"
+#include "logic/message.h"
 #include "logic/player.h"
 #include "map_io/coords_profile.h"
 #include "map_io/map_object_loader.h"
@@ -64,14 +65,14 @@
 						 "added it to the queue. This is only allowed during "
 						 "simulation, not at load. The following messge will be "
 						 "removed when the queue is reset:\n"
-						 "\tsender  : %s\n"
+						 "\tstype   : %u\n"
 						 "\ttitle   : %s\n"
 						 "\tsent    : %u\n"
 						 "\tposition: (%i, %i)\n"
 						 "\tstatus  : %u\n"
 						 "\tbody    : %s\n",
 						 p,
-						 begin->second->sender  ().c_str(),
+						 begin->second->type    (),
 						 begin->second->title   ().c_str(),
 						 begin->second->sent    (),
 						 begin->second->position().x, begin->second->position().y,
@@ -98,13 +99,13 @@
 							 "gametime is only %u",
 							 sent, gametime);
 
-					Message::Status status = Message::Archived; //  default status
+					Message::Status status = Message::Status::kArchived; //  default status
 					if (char const * const status_string = s->get_string("status")) {
 						try {
 							if      (!strcmp(status_string, "new"))
-								status = Message::New;
+								status = Message::Status::kNew;
 							else if (!strcmp(status_string, "read"))
-								status = Message::Read;
+								status = Message::Status::kRead;
 							else
 								throw GameDataError
 									("expected %s but found \"%s\"",
@@ -123,7 +124,7 @@
 
 					messages.add_message
 						(*new Message
-						 	(s->get_string     ("sender", ""),
+							(static_cast<Message::Type>(s->get_natural("type")),
 						 	 sent,
 						 	 s->get_name       (),
 						 	 s->get_safe_string("body"),
@@ -159,20 +160,19 @@
 			assert(message.sent() <= static_cast<uint32_t>(egbase.get_gametime()));
 
 			Section & s = prof.create_section_duplicate(message.title().c_str());
-			if (message.sender().size())
-				s.set_string("sender",    message.sender  ());
-			s.set_int      ("sent",      message.sent    ());
-			s.set_string   ("body",      message.body    ());
-			if (Coords const c =         message.position())
+			s.set_int    ("type",      static_cast<int32_t>(message.type()));
+			s.set_int    ("sent",      message.sent    ());
+			s.set_string ("body",      message.body    ());
+			if (Coords const c =       message.position())
 				set_coords("position",  c, &s);
 			switch (message.status()) {
-			case Message::New:
+			case Message::Status::kNew:
 				s.set_string("status",    "new");
 				break;
-			case Message::Read:
+			case Message::Status::kRead:
 				s.set_string("status",    "read");
 				break;
-			case Message::Archived: //  The default status. Do not write.
+			case Message::Status::kArchived: //  The default status. Do not write.
 				break;
 			default:
 				assert(false);

=== modified file 'src/scripting/lua_game.cc'
--- src/scripting/lua_game.cc	2014-11-18 19:30:39 +0000
+++ src/scripting/lua_game.cc	2014-12-28 17:03:29 +0000
@@ -28,6 +28,7 @@
 #include "logic/campaign_visibility.h"
 #include "logic/constants.h"
 #include "logic/game_controller.h"
+#include "logic/message.h"
 #include "logic/objective.h"
 #include "logic/path.h"
 #include "logic/player.h"
@@ -202,7 +203,7 @@
 	lua_newtable(L);
 	uint32_t cidx = 1;
 	for (const std::pair<MessageId, Message *>& temp_message : p.messages()) {
-		if (temp_message.second->status() == Message::Archived)
+		if (temp_message.second->status() == Message::Status::kArchived)
 			continue;
 
 		lua_pushuint32(L, cidx ++);
@@ -276,9 +277,6 @@
 			'archived'. Default: "new"
 		:type status: :class:`string`
 
-		:arg sender: sender name of this string. Default: "ScriptingEngine"
-		:type sender: :class:`string`
-
 		:arg popup: should the message window be opened for this message or not.
 			Default: :const:`false`
 		:type popup: :class:`boolean`
@@ -291,8 +289,7 @@
 	std::string title = luaL_checkstring(L, 2);
 	std::string body = luaL_checkstring(L, 3);
 	Coords c = Coords::null();
-	Message::Status st = Message::New;
-	std::string sender = "ScriptingEngine";
+	Message::Status st = Message::Status::kNew;
 	bool popup = false;
 
 	if (n == 4) {
@@ -305,18 +302,13 @@
 		lua_getfield(L, 4, "status");
 		if (!lua_isnil(L, -1)) {
 			std::string s = luaL_checkstring(L, -1);
-			if (s == "new") st = Message::New;
-			else if (s == "read") st = Message::Read;
-			else if (s == "archived") st = Message::Archived;
+			if (s == "new") st = Message::Status::kNew;
+			else if (s == "read") st = Message::Status::kRead;
+			else if (s == "archived") st = Message::Status::kArchived;
 			else report_error(L, "Unknown message status: %s", s.c_str());
 		}
 		lua_pop(L, 1);
 
-		lua_getfield(L, 4, "sender");
-		if (!lua_isnil(L, -1))
-			sender = luaL_checkstring(L, -1);
-		lua_pop(L, 1);
-
 		lua_getfield(L, 4, "popup");
 		if (!lua_isnil(L, -1))
 			popup = luaL_checkboolean(L, -1);
@@ -330,7 +322,7 @@
 		plr.add_message
 			(game,
 			 *new Message
-			 	(sender,
+				(Message::Type::kScenario,
 			 	 game.get_gametime(),
 			 	 title,
 			 	 body,
@@ -1048,7 +1040,6 @@
 	{nullptr, nullptr},
 };
 const PropertyType<LuaMessage> LuaMessage::Properties[] = {
-	PROP_RO(LuaMessage, sender),
 	PROP_RO(LuaMessage, title),
 	PROP_RO(LuaMessage, body),
 	PROP_RO(LuaMessage, sent),
@@ -1078,15 +1069,7 @@
  PROPERTIES
  ==========================================================
  */
-/* RST
-	.. attribute:: sender
 
-		(RO) The name of the sender of this message
-*/
-int LuaMessage::get_sender(lua_State * L) {
-	lua_pushstring(L, get(L, get_game(L)).sender());
-	return 1;
-}
 /* RST
 	.. attribute:: title
 
@@ -1140,19 +1123,19 @@
 */
 int LuaMessage::get_status(lua_State * L) {
 	switch (get(L, get_game(L)).status()) {
-		case Message::New: lua_pushstring(L, "new"); break;
-		case Message::Read: lua_pushstring(L, "read"); break;
-		case Message::Archived: lua_pushstring(L, "archived"); break;
+		case Message::Status::kNew: lua_pushstring(L, "new"); break;
+		case Message::Status::kRead: lua_pushstring(L, "read"); break;
+		case Message::Status::kArchived: lua_pushstring(L, "archived"); break;
 		default: report_error(L, "Unknown Message status encountered!");
 	}
 	return 1;
 }
 int LuaMessage::set_status(lua_State * L) {
-	Message::Status status = Message::New;
+	Message::Status status = Message::Status::kNew;
 	std::string s = luaL_checkstring(L, -1);
-	if (s == "new") status = Message::New;
-	else if (s == "read") status = Message::Read;
-	else if (s == "archived") status = Message::Archived;
+	if (s == "new") status = Message::Status::kNew;
+	else if (s == "read") status = Message::Status::kRead;
+	else if (s == "archived") status = Message::Status::kArchived;
 	else report_error(L, "Invalid message status <%s>!", s.c_str());
 
 	get_plr(L, get_game(L)).messages().set_message_status(m_mid, status);

=== modified file 'src/scripting/lua_game.h'
--- src/scripting/lua_game.h	2014-09-18 18:56:20 +0000
+++ src/scripting/lua_game.h	2014-12-28 17:03:29 +0000
@@ -161,7 +161,6 @@
 	/*
 	 * Properties
 	 */
-	int get_sender(lua_State * L);
 	int get_sent(lua_State * L);
 	int get_title(lua_State * L);
 	int get_body(lua_State * L);

=== modified file 'src/wui/game_message_menu.cc'
--- src/wui/game_message_menu.cc	2014-11-30 18:49:38 +0000
+++ src/wui/game_message_menu.cc	2014-12-28 17:03:29 +0000
@@ -20,6 +20,7 @@
 #include "wui/game_message_menu.h"
 
 #include <boost/bind.hpp>
+#include <boost/format.hpp>
 
 #include "base/time_string.h"
 #include "graphic/graphic.h"
@@ -45,11 +46,12 @@
 		(&plr, "messages", &registry, 580, 375, _("Messages: Inbox")),
 	message_body
 		(this,
-		 5, 150, 570, 220,
+		 5, 154, 570, 216,
 		 "", UI::Align_Left, 1),
 	mode(Inbox)
 {
-	list = new UI::Table<uintptr_t>(this, 5, 35, 570, 110);
+
+	list = new UI::Table<uintptr_t>(this, 5, message_body.get_y() - 110, 570, 110);
 	list->selected.connect(boost::bind(&GameMessageMenu::selected, this, _1));
 	list->double_clicked.connect(boost::bind(&GameMessageMenu::double_clicked, this, _1));
 	list->add_column (60, _("Select"), "", UI::Align_HCenter, true);
@@ -58,39 +60,105 @@
 	list->add_column(120, _("Time sent"));
 	list->focus();
 
+	// Buttons for message types
+	m_geologistsbtn =
+			new UI::Button
+				(this, "filter_geologists_messages",
+				 5, 5, 34, 34,
+				 g_gr->images().get("pics/but0.png"),
+				 g_gr->images().get("pics/menu_geologist.png"),
+				 "",
+				 true);
+	m_geologistsbtn->sigclicked.connect
+			(boost::bind(&GameMessageMenu::filter_messages, this, Widelands::Message::Type::kGeologists));
+
+	m_economybtn =
+			new UI::Button
+				(this, "filter_economy_messages",
+				 2 * 5 + 34, 5, 34, 34,
+				 g_gr->images().get("pics/but0.png"),
+				 g_gr->images().get("pics/menu_build_flag.png"),
+				 "",
+				 true);
+	m_economybtn->sigclicked.connect
+			(boost::bind(&GameMessageMenu::filter_messages, this, Widelands::Message::Type::kEconomy));
+
+	m_seafaringbtn =
+			new UI::Button
+				(this, "filter_seafaring_messages",
+				 3 * 5 + 2 * 34, 5, 34, 34,
+				 g_gr->images().get("pics/but0.png"),
+				 g_gr->images().get("pics/start_expedition.png"),
+				 "",
+				 true);
+	m_seafaringbtn->sigclicked.connect
+			(boost::bind(&GameMessageMenu::filter_messages, this, Widelands::Message::Type::kSeafaring));
+
+	m_warfarebtn =
+			new UI::Button
+				(this, "filter_warfare_messages",
+				 4 * 5 + 3 * 34, 5, 34, 34,
+				 g_gr->images().get("pics/but0.png"),
+				 g_gr->images().get("pics/messages_warfare.png"),
+				 "",
+				 true);
+	m_warfarebtn->sigclicked.connect
+			(boost::bind(&GameMessageMenu::filter_messages, this, Widelands::Message::Type::kWarfare));
+
+	m_scenariobtn =
+			new UI::Button
+				(this, "filter_scenario_messages",
+				 5 * 5 + 4 * 34, 5, 34, 34,
+				 g_gr->images().get("pics/but0.png"),
+				 g_gr->images().get("pics/menu_objectives.png"),
+				 "",
+				 true);
+	m_scenariobtn->sigclicked.connect
+			(boost::bind(&GameMessageMenu::filter_messages, this, Widelands::Message::Type::kScenario));
+
+	m_message_filter = Widelands::Message::Type::kAllMessages;
+	set_filter_messages_tooltips();
+	// End: Buttons for message types
+
 	UI::Button * clearselectionbtn =
 		new UI::Button
 			(this, "clear_selection",
-			 5, 5, 140, 25,
-			 g_gr->images().get("pics/but0.png"),
-			 _("Clear"), _("Clear selection"));
+			 5 * 5 + 6 * 34 + 17, 5, 34, 34,
+			 g_gr->images().get("pics/but2.png"),
+			 g_gr->images().get("pics/message_clear_selection.png"),
+			 _("Clear selection"));
 	clearselectionbtn->sigclicked.connect
 		(boost::bind(&GameMessageMenu::do_clear_selection, this));
 
 	UI::Button * invertselectionbtn =
 		new UI::Button
 			(this, "invert_selection",
-			 150, 5, 140, 25,
-			 g_gr->images().get("pics/but0.png"),
-			 _("Invert"), _("Invert selection"));
+			 6 * 5 + 7 * 34 + 17, 5, 34, 34,
+			 g_gr->images().get("pics/but2.png"),
+			 g_gr->images().get("pics/message_selection_invert.png"),
+			 _("Invert selection"));
 	invertselectionbtn->sigclicked.connect
 		(boost::bind(&GameMessageMenu::do_invert_selection, this));
 
 	m_archivebtn =
 		new UI::Button
 			(this, "archive_or_restore_selected_messages",
-			 295, 5, 25, 25,
+			 6 * 5 + 9 * 34 + 34, 5, 34, 34,
 			 g_gr->images().get("pics/but2.png"),
 			 g_gr->images().get("pics/message_archive.png"),
-			 _("Archive selected messages"));
+			 /** TRANSLATORS: %s is a tooltip, Del is the corresponding hotkey */
+			 (boost::format(_("Del: %s"))
+			  /** TRANSLATORS: Tooltip in the messages window */
+			  % _("Archive selected messages")).str());
 	m_archivebtn->sigclicked.connect
 		(boost::bind(&GameMessageMenu::archive_or_restore, this));
 
 	m_togglemodebtn =
 		new UI::Button
 			(this, "toggle_between_inbox_or_archive",
-			 325, 5, 190, 25,
+			 7 * 5 + 10 * 34 + 34, 5, 34, 34,
 			 g_gr->images().get("pics/but2.png"),
+			 g_gr->images().get("pics/message_archived.png"),
 			 _("Show Archive"));
 	m_togglemodebtn->sigclicked.connect
 		(boost::bind(&GameMessageMenu::toggle_mode, this));
@@ -98,13 +166,24 @@
 	m_centerviewbtn =
 		new UI::Button
 			(this, "center_main_mapview_on_location",
-			 550, 5, 25, 25,
+			 580 - 5 - 34, 5, 34, 34,
 			 g_gr->images().get("pics/but2.png"),
 			 g_gr->images().get("pics/menu_goto.png"),
-			 _("center main mapview on location"),
+			 /** TRANSLATORS: %s is a tooltip, G is the corresponding hotkey */
+			 (boost::format(_("G: %s"))
+			  /** TRANSLATORS: Tooltip in the messages window */
+			  % _("Center main mapview on location")).str(),
 			 false);
 	m_centerviewbtn->sigclicked.connect(boost::bind(&GameMessageMenu::center_view, this));
 
+
+	m_display_message_type_label =
+		new UI::MultilineTextarea
+			(this,
+			 5, 375 - 5 - 34, 5 * 34, 40,
+			 "<rt image=pics/message_new.png></rt>",
+			 UI::Align::Align_BottomLeft, false);
+
 	if (get_usedefaultpos())
 		center_to_parent();
 
@@ -127,7 +206,7 @@
 	const Message * msgb = mq[MessageId((*list)[b])];
 
 	if (msga && msgb) {
-		return msga->status() == Message::New && msgb->status() != Message::New;
+		return msga->status() == Message::Status::kNew && msgb->status() != Message::Status::kNew;
 	}
 	return false; // shouldn't happen
 }
@@ -144,7 +223,7 @@
 	assert(iplayer().player().messages()[id] == &message);
 	assert(!list->find(id.value()));
 	Message::Status const status = message.status();
-	if ((mode == Archive) != (status == Message::Archived))
+	if ((mode == Archive) != (status == Message::Status::kArchived))
 		toggle_mode();
 	UI::Table<uintptr_t>::EntryRecord & te = list->add(id.value(), true);
 	update_record(te, message);
@@ -159,7 +238,7 @@
 	for (uint32_t j = list->size(); j; --j) {
 		MessageId m_id((*list)[j - 1]);
 		if (Message const * const message = mq[m_id]) {
-			if ((mode == Archive) != (message->status() == Message::Archived)) {
+			if ((mode == Archive) != (message->status() == Message::Status::kArchived)) {
 				list->remove(j - 1);
 			} else {
 				update_record(list->get_record(j - 1), *message);
@@ -174,7 +253,7 @@
 		MessageId      const id      =  temp_message.first;
 		const Message &       message = *temp_message.second;
 		Message::Status const status  = message.status();
-		if ((mode == Archive) != (status == Message::Archived))
+		if ((mode == Archive) != (status == Message::Status::kArchived))
 			continue;
 		if (!list->find(id.value())) {
 			UI::Table<uintptr_t>::EntryRecord & er = list->add(id.value());
@@ -183,6 +262,19 @@
 		}
 	}
 
+	// Filter message type
+	if (m_message_filter != Message::Type::kAllMessages) {
+		set_display_message_type_label(m_message_filter);
+		for (uint32_t j = list->size(); j; --j) {
+			MessageId m_id((*list)[j - 1]);
+			if (Message const * const message = mq[m_id]) {
+				if (message->message_type_category() != m_message_filter) {
+					list->remove(j - 1);
+				}
+			}
+		}
+	}
+
 	if (list->size()) {
 		if (!list->has_selection())
 			list->select(0);
@@ -192,6 +284,7 @@
 	} else {
 		m_centerviewbtn->set_enabled(false);
 		message_body.set_text(std::string());
+		set_display_message_type_label(Widelands::Message::Type::kNoMessages);
 	}
 }
 
@@ -201,7 +294,7 @@
 {
 	er.set_picture
 		(ColStatus,
-		 g_gr->images().get(status_picture_filename[message.status()]));
+		 g_gr->images().get(status_picture_filename[static_cast<int>(message.status())]));
 	er.set_string(ColTitle, message.title());
 
 	const uint32_t time = message.sent();
@@ -218,7 +311,7 @@
 		MessageId const id = MessageId((*list)[t]);
 		if (Message const * const message = mq[id]) {
 			//  Maybe the message was removed since think?
-			if (message->status() == Message::New) {
+			if (message->status() == Message::Status::kNew) {
 				Widelands::Game & game = iplayer().game();
 				game.send_player_command
 					(*new Widelands::CmdMessageSetStatusRead
@@ -226,6 +319,7 @@
 			}
 			m_centerviewbtn->set_enabled(message->position());
 			message_body.set_text(message->body    ());
+			set_display_message_type_label(message->message_type_category());
 			return;
 		}
 	}
@@ -247,19 +341,37 @@
 {
 	if (down) {
 		switch (code.sym) {
+		// Don't forget to change the tooltips if any of these get reassigned
 		case SDLK_g:
 			if (m_centerviewbtn->enabled())
 				center_view();
 			return true;
-
+		case SDLK_0:
+			filter_messages(Widelands::Message::Type::kAllMessages);
+			return true;
+		case SDLK_1:
+			filter_messages(Widelands::Message::Type::kGeologists);
+			return true;
+		case SDLK_2:
+			filter_messages(Widelands::Message::Type::kEconomy);
+			return true;
+		case SDLK_3:
+			filter_messages(Widelands::Message::Type::kSeafaring);
+			return true;
+		case SDLK_4:
+			filter_messages(Widelands::Message::Type::kWarfare);
+			return true;
+		case SDLK_5:
+			filter_messages(Widelands::Message::Type::kScenario);
+			return true;
+		case SDLK_DELETE:
+			archive_or_restore();
+			return true;
+		case SDL_SCANCODE_KP_PERIOD:
 		case SDLK_KP_PERIOD:
 			if (code.mod & KMOD_NUM)
 				break;
 			/* no break */
-		case SDLK_DELETE:
-			archive_or_restore();
-			return true;
-
 		default:
 			break; // not handled
 		}
@@ -336,6 +448,141 @@
 }
 
 /**
+ * Show only messages of a certain type
+ * @param msgtype the types of messages to show
+ */
+void GameMessageMenu::filter_messages(Widelands::Message::Type const msgtype) {
+	switch (msgtype) {
+		case Widelands::Message::Type::kGeologists:
+			toggle_filter_messages_button(*m_geologistsbtn, msgtype);
+			break;
+		case Widelands::Message::Type::kEconomy:
+			toggle_filter_messages_button(*m_economybtn, msgtype);
+			break;
+		case Widelands::Message::Type::kSeafaring:
+			toggle_filter_messages_button(*m_seafaringbtn, msgtype);
+			break;
+		case Widelands::Message::Type::kWarfare:
+			toggle_filter_messages_button(*m_warfarebtn, msgtype);
+			break;
+		case Widelands::Message::Type::kScenario:
+			toggle_filter_messages_button(*m_scenariobtn, msgtype);
+			break;
+		default:
+			set_filter_messages_tooltips();
+			m_message_filter = Widelands::Message::Type::kAllMessages;
+			m_geologistsbtn->set_perm_pressed(false);
+			m_economybtn->set_perm_pressed(false);
+			m_seafaringbtn->set_perm_pressed(false);
+			m_warfarebtn->set_perm_pressed(false);
+			m_scenariobtn->set_perm_pressed(false);
+	}
+	think();
+}
+
+/**
+ * Helper for filter_messages
+ */
+void GameMessageMenu::toggle_filter_messages_button(UI::Button & button, Widelands::Message::Type msgtype) {
+	set_filter_messages_tooltips();
+	if (button.get_perm_pressed()) {
+		button.set_perm_pressed(false);
+		m_message_filter = Widelands::Message::Type::kAllMessages;
+	} else {
+		m_geologistsbtn->set_perm_pressed(false);
+		m_economybtn->set_perm_pressed(false);
+		m_seafaringbtn->set_perm_pressed(false);
+		m_warfarebtn->set_perm_pressed(false);
+		m_scenariobtn->set_perm_pressed(false);
+		button.set_perm_pressed(true);
+		m_message_filter = msgtype;
+		/** TRANSLATORS: %1% is a tooltip, %2% is the corresponding hotkey */
+		button.set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+								  /** TRANSLATORS: Tooltip in the messages window */
+								  % _("Show all messages")
+								  % "0").str());
+	}
+}
+
+/**
+ * Helper for filter_messages
+ */
+void GameMessageMenu::set_filter_messages_tooltips() {
+	m_geologistsbtn->set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+											/** TRANSLATORS: Tooltip in the messages window */
+											% _("Show geologists' messages only")
+											% "1").str());
+	m_economybtn->set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+										/** TRANSLATORS: Tooltip in the messages window */
+										% _("Show economy messages only")
+										% "2").str());
+	m_seafaringbtn->set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+										  /** TRANSLATORS: Tooltip in the messages window */
+										  % _("Show seafaring messages only")
+										  % "3").str());
+	m_warfarebtn->set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+										/** TRANSLATORS: Tooltip in the messages window */
+										% _("Show warfare messages only")
+										% "4").str());
+	m_scenariobtn->set_tooltip((boost::format(_("%1% (Hotkey: %2%)"))
+										 /** TRANSLATORS: Tooltip in the messages window */
+										 % _("Show scenario messages only")
+										 % "5").str());
+}
+
+/**
+ * Update image and tooltip for message category label
+ */
+void GameMessageMenu::set_display_message_type_label(Widelands::Message::Type msgtype) {
+	std::string message_type_tooltip = "";
+	std::string message_type_image = "";
+
+	switch (msgtype) {
+		case Widelands::Message::Type::kGeologists:
+			/** TRANSLATORS: This is a message's type */
+			message_type_tooltip =  _("Geologists");
+			message_type_image =  "<rt image=pics/menu_geologist.png></rt>";
+			break;
+		case Widelands::Message::Type::kEconomy:
+			/** TRANSLATORS: This is a message's type */
+			message_type_tooltip =  _("Economy");
+			message_type_image =  "<rt image=pics/menu_build_flag.png></rt>";
+			break;
+		case Widelands::Message::Type::kSeafaring:
+			/** TRANSLATORS: This is a message's type */
+			message_type_tooltip =  _("Seafaring");
+			message_type_image =  "<rt image=pics/start_expedition.png></rt>";
+			break;
+		case Widelands::Message::Type::kWarfare:
+			/** TRANSLATORS: This is a message's type */
+			message_type_tooltip =  _("Warfare");
+			message_type_image =  "<rt image=pics/messages_warfare.png></rt>";
+			break;
+		case Widelands::Message::Type::kScenario:
+			/** TRANSLATORS: This is a message's type */
+			message_type_tooltip =  _("Scenario");
+			message_type_image =  "<rt image=pics/menu_objectives.png></rt>";
+			break;
+		case Widelands::Message::Type::kNoMessages:
+			/** TRANSLATORS: This show up instead of a message's type when there are no messages found */
+			message_type_tooltip =  _("No message found");
+			break;
+		default:
+			/** TRANSLATORS: This is the default message type */
+			message_type_tooltip = _("General");
+			message_type_image =  "<rt image=pics/message_new.png></rt>";
+	}
+
+	m_display_message_type_label->set_tooltip(
+				 /** TRANSLATORS: %s is a message's type */
+				 (boost::format(_("Type of this message: %s"))
+				  /** TRANSLATORS: Tooltip in the messages window */
+				  % message_type_tooltip).str());
+	m_display_message_type_label->set_text(message_type_image);
+}
+
+
+/**
  * Clear the current selection of messages.
  */
 void GameMessageMenu::do_clear_selection()
@@ -359,15 +606,23 @@
 		mode = Archive;
 		set_title(_("Messages: Archive"));
 		m_archivebtn->set_pic(g_gr->images().get("pics/message_restore.png"));
-		m_archivebtn->set_tooltip(_("Restore selected messages"));
-		m_togglemodebtn->set_title(_("Show Inbox"));
+		/** TRANSLATORS: %s is a tooltip, Del is the corresponding hotkey */
+		m_archivebtn->set_tooltip((boost::format(_("Del: %s"))
+											/** TRANSLATORS: Tooltip in the messages window */
+											% _("Restore selected messages")).str());
+		m_togglemodebtn->set_pic(g_gr->images().get("pics/message_new.png"));
+		m_togglemodebtn->set_tooltip(_("Show Inbox"));
 		break;
 	case Archive:
 		mode = Inbox;
 		set_title(_("Messages: Inbox"));
 		m_archivebtn->set_pic(g_gr->images().get("pics/message_archive.png"));
-		m_archivebtn->set_tooltip(_("Archive selected messages"));
-		m_togglemodebtn->set_title(_("Show Archive"));
+		/** TRANSLATORS: %s is a tooltip, Del is the corresponding hotkey */
+		m_archivebtn->set_tooltip((boost::format(_("Del: %s"))
+											/** TRANSLATORS: Tooltip in the messages window */
+											% _("Archive selected messages")).str());
+		m_togglemodebtn->set_pic(g_gr->images().get("pics/message_archived.png"));
+		m_togglemodebtn->set_tooltip(_("Show Archive"));
 		break;
 	default:
 		assert(false); // there is nothing but Archive and Inbox

=== modified file 'src/wui/game_message_menu.h'
--- src/wui/game_message_menu.h	2014-11-28 16:40:55 +0000
+++ src/wui/game_message_menu.h	2014-12-28 17:03:29 +0000
@@ -21,6 +21,7 @@
 #define WL_WUI_GAME_MESSAGE_MENU_H
 
 #include "base/i18n.h"
+#include "logic/message.h"
 #include "logic/message_queue.h"
 #include "ui_basic/button.h"
 #include "ui_basic/multilinetextarea.h"
@@ -48,6 +49,7 @@
 
 private:
 	enum Cols {ColSelect, ColStatus, ColTitle, ColTimeSent};
+	enum class ReadUnread: uint8_t {allMessages, readMessages, newMessages};
 
 	InteractivePlayer & iplayer() const;
 	void selected(uint32_t);
@@ -59,6 +61,10 @@
 	void archive_or_restore();
 	void toggle_mode();
 	void center_view();
+	void filter_messages(Widelands::Message::Type);
+	void toggle_filter_messages_button(UI::Button &, Widelands::Message::Type);
+	void set_filter_messages_tooltips();
+	void set_display_message_type_label(Widelands::Message::Type);
 	void update_record(UI::Table<uintptr_t>::EntryRecord & er, const Widelands::Message &);
 
 	UI::Table<uintptr_t> * list;
@@ -67,6 +73,14 @@
 	UI::Button * m_togglemodebtn;
 	UI::Button * m_centerviewbtn;
 	Mode mode;
+	// Buttons for message types
+	UI::Button * m_geologistsbtn;
+	UI::Button * m_economybtn;
+	UI::Button * m_seafaringbtn;
+	UI::Button * m_warfarebtn;
+	UI::Button * m_scenariobtn;
+	Widelands::Message::Type m_message_filter;
+	UI::MultilineTextarea * m_display_message_type_label;
 };
 
 #endif  // end of include guard: WL_WUI_GAME_MESSAGE_MENU_H

=== modified file 'src/wui/interactive_player.cc'
--- src/wui/interactive_player.cc	2014-12-03 08:14:35 +0000
+++ src/wui/interactive_player.cc	2014-12-28 17:03:29 +0000
@@ -254,7 +254,7 @@
 		std::string msg_tooltip = _("Messages");
 		if
 			(uint32_t const nr_new_messages =
-			 	player().messages().nr_messages(Widelands::Message::New))
+				player().messages().nr_messages(Widelands::Message::Status::kNew))
 		{
 			msg_icon    = "pics/menu_toggle_newmessage_menu.png";
 			msg_tooltip =

=== modified file 'test/maps/lua_persistence.wmf/scripting/test_persistence.lua'
--- test/maps/lua_persistence.wmf/scripting/test_persistence.lua	2014-08-01 15:30:12 +0000
+++ test/maps/lua_persistence.wmf/scripting/test_persistence.lua	2014-12-28 17:03:29 +0000
@@ -49,7 +49,7 @@
    objective.done = true
 
    p:send_message("dummy msg1", "dummy msg 1")
-   msg = p:send_message("hello nice", "World", {sender="blah", field = field })
+   msg = p:send_message("hello nice", "World", {field = field })
    player_slot = map.player_slots[1]
 
    myset = Set:new{
@@ -118,7 +118,6 @@
    assert_table(msg)
    assert_equal("hello nice", msg.title)
    assert_equal("World", msg.body)
-   assert_equal("blah", msg.sender)
    assert_equal(field, msg.field)
 
    assert_table(map)

=== modified file 'test/maps/lua_testsuite.wmf/scripting/messages.lua'
--- test/maps/lua_testsuite.wmf/scripting/messages.lua	2014-09-09 08:24:10 +0000
+++ test/maps/lua_testsuite.wmf/scripting/messages.lua	2014-12-28 17:03:29 +0000
@@ -13,7 +13,6 @@
    local m = player1:send_message("Hallo", "World!")
    assert_equal("Hallo", m.title)
    assert_equal("World!", m.body)
-   assert_equal("ScriptingEngine", m.sender)
    assert_equal(0, m.sent)
    assert_equal(0, m.sent)
    assert_equal(nil, m.field)
@@ -32,10 +31,6 @@
       player1:send_message("Hallo", "World!", {status="nono"})
    end)
 end
-function messages_tests:test_sender()
-   local m = player1:send_message("Hallo", "World!", {sender="i am you"})
-   assert_equal("i am you", m.sender)
-end
 function messages_tests:test_field()
    local f = map:get_field(23,28)
    local m = player1:send_message("Hallo", "World!", {field = f})

=== modified file 'txts/README.lua'
--- txts/README.lua	2014-12-11 19:38:39 +0000
+++ txts/README.lua	2014-12-28 17:03:29 +0000
@@ -79,8 +79,14 @@
    ) .. p(_
 [[In the message window, the following additional shortcuts are available:]]
    ) .. p(
-_ "G: jumps to the location corresponding to the current message" .. "<br>"
-.. _"DELETE: archives the current message"
+_ "0: shows all messages" .. "<br>"
+.. _ "1: shows geologists' messages only" .. "<br>"
+.. _ "2: shows economy messages only" .. "<br>"
+.. _ "3: shows seafaring messages only" .. "<br>"
+.. _ "4: shows warfare messages only" .. "<br>"
+.. _ "5: shows scenario messages only" .. "<br>"
+.. _ "G: jumps to the location corresponding to the current message" .. "<br>"
+.. _"DELETE: archives/restores the current message"
    ) .. h2(_
 [[Online Help]]
    ) .. p( _