Merge lp:~widelands-dev/widelands/bug-1395278-tribes-t-z into lp:widelands

[GunChleoc]

Refactored remaining member variables in tribes.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 683. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/109009669.
Appveyor build 535. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_bug_1395278_tribes_t_z-535.

[SirVer (sirver)]

how many more of these do we have o_O?

lgtm.

@bunnybot merge

review: Approve

[GunChleoc (gunchleoc)]

Lots - if we put them all into 1 branch, we would go blind trying to read the diff :P

I think that the worst is over now though :)

=== modified file 'src/logic/map_objects/tribes/trainingsite.cc'
--- src/logic/map_objects/tribes/trainingsite.cc	2016-01-18 19:35:25 +0000
+++ src/logic/map_objects/tribes/trainingsite.cc	2016-02-13 14:28:04 +0000
@@ -39,28 +39,28 @@
 
 namespace Widelands {
 
-const uint32_t TrainingSite::training_state_multiplier = 12;
+const uint32_t TrainingSite::training_state_multiplier_ = 12;
 
 TrainingSiteDescr::TrainingSiteDescr
 	(const std::string& init_descname, const LuaTable& table, const EditorGameBase& egbase)
 	:
 	ProductionSiteDescr
 		(init_descname, "", MapObjectType::TRAININGSITE, table, egbase),
-	m_num_soldiers      (table.get_int("soldier_capacity")),
-	m_max_stall         (table.get_int("trainer_patience")),
+	num_soldiers_      (table.get_int("soldier_capacity")),
+	max_stall_         (table.get_int("trainer_patience")),
 
-	m_train_hp          (false),
-	m_train_attack      (false),
-	m_train_defense     (false),
-	m_train_evade       (false),
-	m_min_hp            (0),
-	m_min_attack        (0),
-	m_min_defense       (0),
-	m_min_evade         (0),
-	m_max_hp            (0),
-	m_max_attack        (0),
-	m_max_defense       (0),
-	m_max_evade         (0)
+	train_hp_          (false),
+	train_attack_      (false),
+	train_defense_     (false),
+	train_evade_       (false),
+	min_hp_            (0),
+	min_attack_        (0),
+	min_defense_       (0),
+	min_evade_         (0),
+	max_hp_            (0),
+	max_attack_        (0),
+	max_defense_       (0),
+	max_evade_         (0)
 {
 	// Read the range of levels that can update this building
 	//  TODO(unknown): This is currently hardcoded to "soldier" but it should search for
@@ -70,31 +70,31 @@
 	std::unique_ptr<LuaTable> items_table;
 	if (table.has_key("soldier hp")) {
 		items_table = table.get_table("soldier hp");
-		m_train_hp      = true;
-		m_min_hp = items_table->get_int("min_level");
-		m_max_hp = items_table->get_int("max_level");
+		train_hp_      = true;
+		min_hp_ = items_table->get_int("min_level");
+		max_hp_ = items_table->get_int("max_level");
 		add_training_inputs(*items_table.get(), &food_hp_, &weapons_hp_);
 	}
 
 	if (table.has_key("soldier attack")) {
 		items_table = table.get_table("soldier attack");
-		m_train_attack      = true;
-		m_min_attack = items_table->get_int("min_level");
-		m_max_attack = items_table->get_int("max_level");
+		train_attack_      = true;
+		min_attack_ = items_table->get_int("min_level");
+		max_attack_ = items_table->get_int("max_level");
 		add_training_inputs(*items_table.get(), &food_attack_, &weapons_attack_);
 	}
 	if (table.has_key("soldier defense")) {
 		items_table = table.get_table("soldier defense");
-		m_train_defense      = true;
-		m_min_defense = items_table->get_int("min_level");
-		m_max_defense = items_table->get_int("max_level");
+		train_defense_      = true;
+		min_defense_ = items_table->get_int("min_level");
+		max_defense_ = items_table->get_int("max_level");
 		add_training_inputs(*items_table.get(), &food_defense_, &weapons_defense_);
 	}
 	if (table.has_key("soldier evade")) {
 		items_table = table.get_table("soldier evade");
-		m_train_evade      = true;
-		m_min_evade = items_table->get_int("min_level");
-		m_max_evade = items_table->get_int("max_level");
+		train_evade_      = true;
+		min_evade_ = items_table->get_int("min_level");
+		max_evade_ = items_table->get_int("max_level");
 		add_training_inputs(*items_table.get(), &food_evade_, &weapons_evade_);
 	}
 }
@@ -115,13 +115,13 @@
 int32_t TrainingSiteDescr::get_min_level(const TrainingAttribute at) const {
 	switch (at) {
 	case atrHP:
-		return m_min_hp;
+		return min_hp_;
 	case atrAttack:
-		return m_min_attack;
+		return min_attack_;
 	case atrDefense:
-		return m_min_defense;
+		return min_defense_;
 	case atrEvade:
-		return m_min_evade;
+		return min_evade_;
 	case atrTotal:
 		throw wexception("Unknown attribute value!");
 	}
@@ -137,13 +137,13 @@
 int32_t TrainingSiteDescr::get_max_level(const TrainingAttribute at) const {
 	switch (at) {
 	case atrHP:
-		return m_max_hp;
+		return max_hp_;
 	case atrAttack:
-		return m_max_attack;
+		return max_attack_;
 	case atrDefense:
-		return m_max_defense;
+		return max_defense_;
 	case atrEvade:
-		return m_max_evade;
+		return max_evade_;
 	case atrTotal:
 		throw wexception("Unknown attribute value!");
 	}
@@ -153,7 +153,7 @@
 int32_t
 TrainingSiteDescr::get_max_stall() const
 {
-	return m_max_stall;
+	return max_stall_;
 }
 
 void TrainingSiteDescr::add_training_inputs(
@@ -188,18 +188,18 @@
 
 TrainingSite::TrainingSite(const TrainingSiteDescr & d) :
 ProductionSite   (d),
-m_soldier_request(nullptr),
-m_capacity       (descr().get_max_number_of_soldiers()),
-m_build_heroes    (false),
-m_result         (Failed)
+soldier_request_(nullptr),
+capacity_       (descr().get_max_number_of_soldiers()),
+build_heroes_    (false),
+result_         (Failed)
 {
 	// Initialize this in the constructor so that loading code may
 	// overwrite priorities.
 	calc_upgrades();
-	m_current_upgrade = nullptr;
+	current_upgrade_ = nullptr;
 	set_post_timer(6000);
-	training_failure_count.clear();
-	max_stall_val = training_state_multiplier * d.get_max_stall();
+	training_failure_count_.clear();
+	max_stall_val_ = training_state_multiplier_ * d.get_max_stall();
 
 	if (d.get_train_hp())
 		init_kick_state(atrHP, d);
@@ -228,7 +228,7 @@
 
 	upcast(Game, game, &egbase);
 
-	for (Soldier * soldier : m_soldiers) {
+	for (Soldier * soldier : soldiers_) {
 		soldier->set_location_initially(*this);
 		assert(!soldier->get_state()); //  Should be newly created.
 
@@ -249,8 +249,8 @@
 {
 	ProductionSite::set_economy(e);
 
-	if (m_soldier_request)
-		m_soldier_request->set_economy(e);
+	if (soldier_request_)
+		soldier_request_->set_economy(e);
 }
 
 /**
@@ -260,8 +260,8 @@
  */
 void TrainingSite::cleanup(EditorGameBase & egbase)
 {
-	delete m_soldier_request;
-	m_soldier_request = nullptr;
+	delete soldier_request_;
+	soldier_request_ = nullptr;
 
 	ProductionSite::cleanup(egbase);
 }
@@ -275,9 +275,9 @@
 		// Note that the given Soldier might already be in the array
 		// for loadgames.
 		if
-			(std::find(m_soldiers.begin(), m_soldiers.end(), soldier) ==
-			 m_soldiers.end())
-			m_soldiers.push_back(soldier);
+			(std::find(soldiers_.begin(), soldiers_.end(), soldier) ==
+			 soldiers_.end())
+			soldiers_.push_back(soldier);
 
 		if (upcast(Game, game, &owner().egbase()))
 			schedule_act(*game, 100);
@@ -290,9 +290,9 @@
 
 	if (upcast(Soldier, soldier, &w)) {
 		std::vector<Soldier *>::iterator const it =
-			std::find(m_soldiers.begin(), m_soldiers.end(), soldier);
-		if (it != m_soldiers.end()) {
-			m_soldiers.erase(it);
+			std::find(soldiers_.begin(), soldiers_.end(), soldier);
+		if (it != soldiers_.end()) {
+			soldiers_.erase(it);
 
 			if (game)
 				schedule_act(*game, 100);
@@ -307,9 +307,9 @@
  * Request soldiers up to capacity, or let go of surplus soldiers.
  */
 void TrainingSite::update_soldier_request() {
-	if (m_soldiers.size() < m_capacity) {
-		if (!m_soldier_request) {
-			m_soldier_request =
+	if (soldiers_.size() < capacity_) {
+		if (!soldier_request_) {
+			soldier_request_ =
 				new Request
 					(*this,
 					 owner().tribe().soldier(),
@@ -344,16 +344,16 @@
 					 	 descr().get_min_level(atrHP),
 					 	 descr().get_max_level(atrHP)));
 
-			m_soldier_request->set_requirements(r);
+			soldier_request_->set_requirements(r);
 		}
 
-		m_soldier_request->set_count(m_capacity - m_soldiers.size());
-	} else if (m_soldiers.size() >= m_capacity) {
-		delete m_soldier_request;
-		m_soldier_request = nullptr;
+		soldier_request_->set_count(capacity_ - soldiers_.size());
+	} else if (soldiers_.size() >= capacity_) {
+		delete soldier_request_;
+		soldier_request_ = nullptr;
 
-		while (m_soldiers.size() > m_capacity) {
-			drop_soldier(**m_soldiers.rbegin());
+		while (soldiers_.size() > capacity_) {
+			drop_soldier(**soldiers_.rbegin());
 		}
 	}
 }
@@ -378,7 +378,7 @@
 	Soldier& s = dynamic_cast<Soldier&>(*w);
 
 	assert(s.get_location(game) == &tsite);
-	assert(tsite.m_soldier_request == &rq);
+	assert(tsite.soldier_request_ == &rq);
 
 	tsite.incorporate_soldier(game, s);
 }
@@ -411,12 +411,12 @@
 
 std::vector<Soldier *> TrainingSite::present_soldiers() const
 {
-	return m_soldiers;
+	return soldiers_;
 }
 
 std::vector<Soldier *> TrainingSite::stationed_soldiers() const
 {
-	return m_soldiers;
+	return soldiers_;
 }
 
 uint32_t TrainingSite::min_soldier_capacity() const {
@@ -427,14 +427,14 @@
 }
 uint32_t TrainingSite::soldier_capacity() const
 {
-	return m_capacity;
+	return capacity_;
 }
 
 void TrainingSite::set_soldier_capacity(uint32_t const capacity) {
 	assert(min_soldier_capacity() <= capacity);
 	assert                        (capacity <= max_soldier_capacity());
-	assert(m_capacity != capacity);
-	m_capacity = capacity;
+	assert(capacity_ != capacity);
+	capacity_ = capacity;
 	update_soldier_request();
 }
 
@@ -452,13 +452,13 @@
 	Game & game = dynamic_cast<Game&>(owner().egbase());
 
 	std::vector<Soldier *>::iterator it =
-		std::find(m_soldiers.begin(), m_soldiers.end(), &soldier);
-	if (it == m_soldiers.end()) {
+		std::find(soldiers_.begin(), soldiers_.end(), &soldier);
+	if (it == soldiers_.end()) {
 		molog("TrainingSite::drop_soldier: soldier not in training site");
 		return;
 	}
 
-	m_soldiers.erase(it);
+	soldiers_.erase(it);
 
 	soldier.reset_tasks(game);
 	soldier.start_task_leavebuilding(game, true);
@@ -476,16 +476,16 @@
 {
 	std::vector<Soldier *> droplist;
 
-	for (uint32_t i = 0; i < m_soldiers.size(); ++i) {
-		std::vector<Upgrade>::iterator it = m_upgrades.begin();
-		for (; it != m_upgrades.end(); ++it) {
-			int32_t level = m_soldiers[i]->get_level(it->attribute);
+	for (uint32_t i = 0; i < soldiers_.size(); ++i) {
+		std::vector<Upgrade>::iterator it = upgrades_.begin();
+		for (; it != upgrades_.end(); ++it) {
+			int32_t level = soldiers_[i]->get_level(it->attribute);
 			if (level >= it->min && level <= it->max)
 				break;
 		}
 
-		if (it == m_upgrades.end())
-			droplist.push_back(m_soldiers[i]);
+		if (it == upgrades_.end())
+			droplist.push_back(soldiers_[i]);
 	}
 
 	// Drop soldiers only now, so that changes in the soldiers array don't
@@ -504,9 +504,9 @@
 	Soldier * soldier_to_drop = nullptr;
 	uint32_t highest_soldier_level_seen = 0;
 
-	for (uint32_t i = 0; i < m_soldiers.size(); ++i)
+	for (uint32_t i = 0; i < soldiers_.size(); ++i)
 	{
-		uint32_t this_soldier_level = m_soldiers[i]->get_level(atrTotal);
+		uint32_t this_soldier_level = soldiers_[i]->get_level(atrTotal);
 
 		bool this_soldier_is_safe = false;
 		if (this_soldier_level <= highest_soldier_level_seen)
@@ -517,14 +517,14 @@
 		}
 		else
 		{
-			for (const Upgrade& upgrade: m_upgrades)
+			for (const Upgrade& upgrade: upgrades_)
 			if  (! this_soldier_is_safe)
 			{
 				// Soldier is safe, if he:
 				//  - is below maximum, and
 				//  - is not in a stalled state
 				// Check done separately for each art.
-				int32_t level = m_soldiers[i]->get_level(upgrade.attribute);
+				int32_t level = soldiers_[i]->get_level(upgrade.attribute);
 
 				 // Below maximum -check
 				if (level > upgrade.max)
@@ -533,8 +533,8 @@
 				}
 
 				TypeAndLevel train_tl(upgrade.attribute, level);
-				TrainFailCount::iterator tstep = training_failure_count.find(train_tl);
-				if (tstep ==  training_failure_count.end())
+				TrainFailCount::iterator tstep = training_failure_count_.find(train_tl);
+				if (tstep ==  training_failure_count_.end())
 					{
 						log("\nTrainingSite::drop_stalled_soldiers: ");
 						log("training step %d,%d not found in this school!\n", upgrade.attribute, level);
@@ -544,7 +544,7 @@
 				tstep->second.second = 1; // a soldier is present at this level
 
 				// Stalled state -check
-				if (max_stall_val > tstep->second.first)
+				if (max_stall_val_ > tstep->second.first)
 				{
 					this_soldier_is_safe = true;
 					break;
@@ -554,7 +554,7 @@
 		if (!this_soldier_is_safe)
 		{
 			// Make this soldier a kick-out candidate
-			soldier_to_drop = m_soldiers[i];
+			soldier_to_drop = soldiers_[i];
 			highest_soldier_level_seen = this_soldier_level;
 		}
 	}
@@ -583,7 +583,7 @@
 
 void TrainingSite::program_end(Game & game, ProgramResult const result)
 {
-	m_result = result;
+	result_ = result;
 	ProductionSite::program_end(game, result);
 	// For unknown reasons sometimes there is a fully upgraded soldier
 	// that failed to be send away, so at the end of this function
@@ -591,19 +591,19 @@
 	// function were run
 	bool leftover_soldiers_check = true;
 
-	if (m_current_upgrade) {
-		if (m_result == Completed) {
+	if (current_upgrade_) {
+		if (result_ == Completed) {
 			drop_unupgradable_soldiers(game);
 			leftover_soldiers_check = false;
-			m_current_upgrade->lastsuccess = true;
-			m_current_upgrade->failures = 0;
+			current_upgrade_->lastsuccess = true;
+			current_upgrade_->failures = 0;
 		}
 		else {
-			m_current_upgrade->failures++;
+			current_upgrade_->failures++;
 			drop_stalled_soldiers(game);
 			leftover_soldiers_check = false;
 		}
-		m_current_upgrade = nullptr;
+		current_upgrade_ = nullptr;
 	}
 
 	if (leftover_soldiers_check) {
@@ -627,7 +627,7 @@
 		uint32_t maxprio = 0;
 		uint32_t maxcredit = 0;
 
-		for (Upgrade& upgrade : m_upgrades) {
+		for (Upgrade& upgrade : upgrades_) {
 			if (upgrade.credit >= 10) {
 				upgrade.credit -= 10;
 				return start_upgrade(game, upgrade);
@@ -645,7 +645,7 @@
 
 		uint32_t const multiplier = 1 + (10 - maxcredit) / maxprio;
 
-		for (Upgrade& upgrade : m_upgrades) {
+		for (Upgrade& upgrade : upgrades_) {
 			upgrade.credit += multiplier * upgrade.prio;
 		}
 	}
@@ -661,7 +661,7 @@
 	int32_t minlevel = upgrade.max;
 	int32_t maxlevel = upgrade.min;
 
-	for (Soldier * soldier : m_soldiers) {
+	for (Soldier * soldier : soldiers_) {
 		int32_t const level = soldier->get_level(upgrade.attribute);
 
 		if (level > upgrade.max || level < upgrade.min)
@@ -680,7 +680,7 @@
 	if (upgrade.lastsuccess || upgrade.lastattempt < 0) {
 		// Start greedily on the first ever attempt, and restart greedily
 		// after a sucessful upgrade
-		if (m_build_heroes)
+		if (build_heroes_)
 			level = maxlevel;
 		else
 			level = minlevel;
@@ -688,7 +688,7 @@
 		// The last attempt wasn't successful;
 		// This happens e.g. when lots of low-level soldiers are present,
 		// but the prerequisites for improving them aren't.
-		if (m_build_heroes) {
+		if (build_heroes_) {
 			level = upgrade.lastattempt - 1;
 			if (level < minlevel)
 				level = maxlevel;
@@ -699,7 +699,7 @@
 		}
 	}
 
-	m_current_upgrade = &upgrade;
+	current_upgrade_ = &upgrade;
 	upgrade.lastattempt = level;
 	upgrade.lastsuccess = false;
 
@@ -710,7 +710,7 @@
 
 TrainingSite::Upgrade * TrainingSite::get_upgrade(TrainingAttribute const atr)
 {
-	for (Upgrade& upgrade : m_upgrades) {
+	for (Upgrade& upgrade : upgrades_) {
 		if (upgrade.attribute == atr) {
 			return &upgrade;
 		}
@@ -724,7 +724,7 @@
  */
 int32_t TrainingSite::get_pri(TrainingAttribute atr)
 {
-	for (const Upgrade& upgrade : m_upgrades) {
+	for (const Upgrade& upgrade : upgrades_) {
 		if (upgrade.attribute == atr) {
 			return upgrade.prio;
 		}
@@ -740,7 +740,7 @@
 	if (prio < 0)
 		prio = 0;
 
-	for (Upgrade& upgrade : m_upgrades) {
+	for (Upgrade& upgrade : upgrades_) {
 		if (upgrade.attribute == atr) {
 			upgrade.prio = prio;
 			return;
@@ -764,14 +764,14 @@
 	u.lastattempt = -1;
 	u.lastsuccess = false;
 	u.failures = 0;
-	m_upgrades.push_back(u);
+	upgrades_.push_back(u);
 }
 
 /**
- * Called once at initialization to populate \ref m_upgrades.
+ * Called once at initialization to populate \ref upgrades_.
  */
 void TrainingSite::calc_upgrades() {
-	assert(m_upgrades.empty());
+	assert(upgrades_.empty());
 
 	//  TODO(unknown): This is currently hardcoded for "soldier" but it should allow any
 	//  soldier type name.
@@ -790,10 +790,10 @@
 TrainingSite::training_attempted(uint32_t type, uint32_t level)
 	{
 	        TypeAndLevel key(type, level);
-		if (training_failure_count.find(key) == training_failure_count.end())
-			training_failure_count[key]  = std::make_pair(training_state_multiplier, 0);
+		if (training_failure_count_.find(key) == training_failure_count_.end())
+			training_failure_count_[key]  = std::make_pair(training_state_multiplier_, 0);
 		else
-			training_failure_count[key].first +=  training_state_multiplier;
+			training_failure_count_[key].first +=  training_state_multiplier_;
 	}
 
 /**
@@ -805,14 +805,14 @@
 {
 	TypeAndLevel key(type, level);
 	// Here I assume that key exists: training has been attempted before it can succeed.
-	training_failure_count[key].first = 0;
+	training_failure_count_[key].first = 0;
 }
 
 void
 TrainingSite::training_done()
 {
 	TrainFailCount::iterator it;
-	for (it = training_failure_count.begin(); it != training_failure_count.end(); it++)
+	for (it = training_failure_count_.begin(); it != training_failure_count_.end(); it++)
 	{
 		// If a soldier is present at this training level, deteoriate
 		if (it->second.second)

=== modified file 'src/logic/map_objects/tribes/trainingsite.h'
--- src/logic/map_objects/tribes/trainingsite.h	2016-01-31 15:31:00 +0000
+++ src/logic/map_objects/tribes/trainingsite.h	2016-02-13 14:28:04 +0000
@@ -39,12 +39,12 @@
 	Building & create_object() const override;
 
 	uint32_t get_max_number_of_soldiers() const {
-		return m_num_soldiers;
+		return num_soldiers_;
 	}
-	bool get_train_hp     () const {return m_train_hp;}
-	bool get_train_attack () const {return m_train_attack;}
-	bool get_train_defense() const {return m_train_defense;}
-	bool get_train_evade  () const {return m_train_evade;}
+	bool get_train_hp     () const {return train_hp_;}
+	bool get_train_attack () const {return train_attack_;}
+	bool get_train_defense() const {return train_defense_;}
+	bool get_train_evade  () const {return train_evade_;}
 
 	int32_t get_min_level(TrainingAttribute) const;
 	int32_t get_max_level(TrainingAttribute) const;
@@ -85,35 +85,35 @@
 	//  struct and there should be a vector, indexed by Soldier_Index,
 	//  with that struct structs as element type.
 	/** Maximum number of soldiers for a training site*/
-	uint32_t m_num_soldiers;
+	uint32_t num_soldiers_;
 	/** Number of rounds w/o successful training, after which a soldier is kicked out.**/
-	uint32_t m_max_stall;
+	uint32_t max_stall_;
 	/** Whether this site can train hitpoints*/
-	bool m_train_hp;
+	bool train_hp_;
 	/** Whether this site can train attack*/
-	bool m_train_attack;
+	bool train_attack_;
 	/** Whether this site can train defense*/
-	bool m_train_defense;
+	bool train_defense_;
 	/** Whether this site can train evasion*/
-	bool m_train_evade;
+	bool train_evade_;
 
 	/** Minimum hitpoints to which a soldier can drop at this site*/
-	int32_t m_min_hp;
+	int32_t min_hp_;
 	/** Minimum attacks to which a soldier can drop at this site*/
-	int32_t m_min_attack;
+	int32_t min_attack_;
 	/** Minimum defense to which a soldier can drop at this site*/
-	int32_t m_min_defense;
+	int32_t min_defense_;
 	/** Minimum evasion to which a soldier can drop at this site*/
-	int32_t m_min_evade;
+	int32_t min_evade_;
 
 	/** Maximum hitpoints a soldier can acquire at this site*/
-	int32_t m_max_hp;
+	int32_t max_hp_;
 	/** Maximum attack a soldier can acquire at this site*/
-	int32_t m_max_attack;
+	int32_t max_attack_;
 	/** Maximum defense a soldier can acquire at this site*/
-	int32_t m_max_defense;
+	int32_t max_defense_;
 	/** Maximum evasion a soldier can acquire at this site*/
-	int32_t m_max_evade;
+	int32_t max_evade_;
 
 	// For building help
 	std::vector<std::vector<std::string>> food_hp_;
@@ -125,8 +125,6 @@
 	std::vector<std::string> weapons_defense_;
 	std::vector<std::string> weapons_evade_;
 
-	// Re-use of m_inputs to get the resources
-	// TrainingMap m_programs;
 	DISALLOW_COPY_AND_ASSIGN(TrainingSiteDescr);
 };
 
@@ -167,14 +165,14 @@
 	void remove_worker(Worker &) override;
 
 	bool get_build_heroes() {
-		return m_build_heroes;
+		return build_heroes_;
 	}
 	void set_build_heroes(bool b_heroes) {
-		m_build_heroes = b_heroes;
+		build_heroes_ = b_heroes;
 	}
 	void switch_heroes() {
-		m_build_heroes = !m_build_heroes;
-		molog("BUILD_HEROES: %s", m_build_heroes ? "TRUE" : "FALSE");
+		build_heroes_ = !build_heroes_;
+		molog("BUILD_HEROES: %s", build_heroes_ ? "TRUE" : "FALSE");
 	}
 
 	void set_economy(Economy * e) override;
@@ -217,38 +215,37 @@
 	void drop_stalled_soldiers(Game &);
 	Upgrade * get_upgrade(TrainingAttribute);
 
-private:
 	/// Open requests for soldiers. The soldiers can be under way or unavailable
-	Request * m_soldier_request;
+	Request * soldier_request_;
 
 	/** The soldiers currently at the training site*/
-	std::vector<Soldier *> m_soldiers;
+	std::vector<Soldier *> soldiers_;
 
 	/** Number of soldiers that should be trained concurrently.
 	 * Equal or less to maximum number of soldiers supported by a training site.
-	 * There is no guarantee there really are m_capacity soldiers in the
+	 * There is no guarantee there really are capacity_ soldiers in the
 	 * building - some of them might still be under way or even not yet
 	 * available*/
-	uint32_t m_capacity;
+	uint32_t capacity_;
 
 	/** True, \b always upgrade already experienced soldiers first, when possible
 	 * False, \b always upgrade inexperienced soldiers first, when possible */
-	bool m_build_heroes;
-
-	std::vector<Upgrade> m_upgrades;
-	Upgrade * m_current_upgrade;
-
-	ProgramResult m_result; /// The result of the last training program.
+	bool build_heroes_;
+
+	std::vector<Upgrade> upgrades_;
+	Upgrade * current_upgrade_;
+
+	ProgramResult result_; /// The result of the last training program.
 
 	// These are used for kicking out soldiers prematurely
-	static const uint32_t training_state_multiplier;
+	static const uint32_t training_state_multiplier_;
 	// Unuque key to address each training level of each war art
 	using TypeAndLevel = std::pair<uint16_t, uint16_t>;
 	// First entry is the "stallness", second is a bool
 	using FailAndPresence = std::pair<uint16_t, uint8_t>; // first might wrap in a long play..
 	using TrainFailCount = std::map<TypeAndLevel, FailAndPresence>;
-	TrainFailCount training_failure_count;
-	uint32_t max_stall_val;
+	TrainFailCount training_failure_count_;
+	uint32_t max_stall_val_;
 	void init_kick_state(const TrainingAttribute&, const TrainingSiteDescr&);
 
 

=== modified file 'src/logic/map_objects/tribes/tribe_descr.cc'
--- src/logic/map_objects/tribes/tribe_descr.cc	2016-01-28 05:24:34 +0000
+++ src/logic/map_objects/tribes/tribe_descr.cc	2016-02-13 14:28:04 +0000
@@ -56,7 +56,7 @@
 	: name_(table.get_string("name")), descname_(info.descname), tribes_(init_tribes) {
 
 	try {
-		m_initializations = info.initializations;
+		initializations_ = info.initializations;
 
 		std::unique_ptr<LuaTable> items_table = table.get_table("animations");
 		frontier_animation_id_ = g_gr->animations().load(*items_table->get_table("frontier"));

=== modified file 'src/logic/map_objects/tribes/tribe_descr.h'
--- src/logic/map_objects/tribes/tribe_descr.h	2016-01-24 20:11:53 +0000
+++ src/logic/map_objects/tribes/tribe_descr.h	2016-02-13 14:28:04 +0000
@@ -126,7 +126,7 @@
 
 	// Returns the initalization at 'index' (which must not be out of bounds).
 	const TribeBasicInfo::Initialization& initialization(const uint8_t index) const {
-		return m_initializations.at(index);
+		return initializations_.at(index);
 	}
 
 	using WaresOrder = std::vector<std::vector<Widelands::DescriptionIndex>>;
@@ -184,7 +184,7 @@
 	WaresOrder                  workers_order_;
 	WaresOrderCoords            workers_order_coords_;
 
-	std::vector<TribeBasicInfo::Initialization> m_initializations;
+	std::vector<TribeBasicInfo::Initialization> initializations_;
 
 	DISALLOW_COPY_AND_ASSIGN(TribeDescr);
 };

=== modified file 'src/logic/map_objects/tribes/warehouse.cc'
--- src/logic/map_objects/tribes/warehouse.cc	2016-02-13 11:25:41 +0000
+++ src/logic/map_objects/tribes/warehouse.cc	2016-02-13 14:28:04 +0000
@@ -255,13 +255,13 @@
 WarehouseDescr::WarehouseDescr
 	(const std::string& init_descname, const LuaTable& table, const EditorGameBase& egbase)
 	: BuildingDescr(init_descname, MapObjectType::WAREHOUSE, table, egbase),
-	  m_conquers         (0),
-	  m_heal_per_second  (0)
+	  conquers_         (0),
+	  heal_per_second_  (0)
 {
-	m_heal_per_second = table.get_int("heal_per_second");
+	heal_per_second_ = table.get_int("heal_per_second");
 	if (table.has_key("conquers")) {
-		m_conquers = table.get_int("conquers");
-		workarea_info_[m_conquers].insert(descname() + " conquer");
+		conquers_ = table.get_int("conquers");
+		workarea_info_[conquers_].insert(descname() + " conquer");
 	}
 }
 
@@ -273,18 +273,18 @@
 
 Warehouse::Warehouse(const WarehouseDescr & warehouse_descr) :
 	Building(warehouse_descr),
-	m_supply(new WarehouseSupply(this)),
-	m_next_military_act(0),
+	supply_(new WarehouseSupply(this)),
+	next_military_act_(0),
 	portdock_(nullptr)
 {
-	m_next_stock_remove_act = 0;
+	next_stock_remove_act_ = 0;
 	cleanup_in_progress_ = false;
 }
 
 
 Warehouse::~Warehouse()
 {
-	delete m_supply;
+	delete supply_;
 }
 
 /**
@@ -295,7 +295,7 @@
 {
 	const TribeDescr& tribe = owner().tribe();
 
-	if (pw.index == INVALID_INDEX || !(pw.index < m_supply->get_workers().get_nrwareids())) {
+	if (pw.index == INVALID_INDEX || !(pw.index < supply_->get_workers().get_nrwareids())) {
 		return false;
 	}
 
@@ -305,7 +305,7 @@
 		return false;
 	}
 
-	if (!(pw.index < m_supply->get_workers().get_nrwareids())) {
+	if (!(pw.index < supply_->get_workers().get_nrwareids())) {
 		return false;
 	}
 
@@ -380,12 +380,12 @@
 		DescriptionIndex const worker_index = worker_types_without_cost.at(--i);
 		if
 			(owner().is_worker_type_allowed(worker_index) &&
-			 m_next_worker_without_cost_spawn[i] == never())
+			 next_worker_without_cost_spawn_[i] == never())
 		{
 			if (next_spawn == never()) {
 				next_spawn = schedule_act(dynamic_cast<Game&>(egbase), WORKER_WITHOUT_COST_SPAWN_INTERVAL);
 			}
-			m_next_worker_without_cost_spawn[i] = next_spawn;
+			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 "
@@ -400,10 +400,10 @@
 	// Ensure consistency of PlannedWorker requests
 	{
 		uint32_t pwidx = 0;
-		while (pwidx < m_planned_workers.size()) {
-			if (!_load_finish_planned_worker(m_planned_workers[pwidx])) {
-				m_planned_workers[pwidx].cleanup();
-				m_planned_workers.erase(m_planned_workers.begin() + pwidx);
+		while (pwidx < planned_workers_.size()) {
+			if (!_load_finish_planned_worker(planned_workers_[pwidx])) {
+				planned_workers_[pwidx].cleanup();
+				planned_workers_.erase(planned_workers_.begin() + pwidx);
 			} else {
 				pwidx++;
 			}
@@ -435,16 +435,16 @@
 
 			for (size_t i = 0; i < worker_types_without_cost.size(); ++i) {
 				if (owner().is_worker_type_allowed(worker_types_without_cost.at(i))) {
-					m_next_worker_without_cost_spawn[i] = act_time;
+					next_worker_without_cost_spawn_[i] = act_time;
 				}
 			}
 		}
-		// m_next_military_act is not touched in the loading code. Is only needed
+		// next_military_act_ is not touched in the loading code. Is only needed
 		// if the warehouse is created in the game?  I assume it's for the
 		// conquer_radius thing
-		m_next_military_act = schedule_act(*game, 1000);
+		next_military_act_ = schedule_act(*game, 1000);
 
-		m_next_stock_remove_act = schedule_act(*game, 4000);
+		next_stock_remove_act_ = schedule_act(*game, 4000);
 
 		log("Message: adding %s for player %i at (%d, %d)\n", to_string(descr().type()).c_str(),
 		    player.player_number(), position_.x, position_.y);
@@ -501,14 +501,14 @@
 void Warehouse::init_containers(Player& player) {
 	DescriptionIndex const nr_wares = player.egbase().tribes().nrwares();
 	DescriptionIndex const nr_workers = player.egbase().tribes().nrworkers();
-	m_supply->set_nrwares(nr_wares);
-	m_supply->set_nrworkers(nr_workers);
+	supply_->set_nrwares(nr_wares);
+	supply_->set_nrworkers(nr_workers);
 
-	m_ware_policy.resize(nr_wares, SP_Normal);
-	m_worker_policy.resize(nr_workers, SP_Normal);
+	ware_policy_.resize(nr_wares, SP_Normal);
+	worker_policy_.resize(nr_workers, SP_Normal);
 
 	uint8_t nr_worker_types_without_cost = player.tribe().worker_types_without_cost().size();
-	m_next_worker_without_cost_spawn.resize(nr_worker_types_without_cost, never());
+	next_worker_without_cost_spawn_.resize(nr_worker_types_without_cost, never());
 }
 
 /**
@@ -603,7 +603,7 @@
 				for (uint32_t i = 0; i < stock; ++i) {
 					launch_worker(*game, id, Requirements()).start_task_leavebuilding(*game, true);
 				}
-				assert(!m_incorporated_workers.count(id) || m_incorporated_workers[id].empty());
+				assert(!incorporated_workers_.count(id) || incorporated_workers_[id].empty());
 			}
 			else
 			{
@@ -612,11 +612,11 @@
 			}
 		}
 	}
-	m_incorporated_workers.clear();
+	incorporated_workers_.clear();
 
-	while (!m_planned_workers.empty()) {
-		m_planned_workers.back().cleanup();
-		m_planned_workers.pop_back();
+	while (!planned_workers_.empty()) {
+		planned_workers_.back().cleanup();
+		planned_workers_.pop_back();
 	}
 
 	Map& map = egbase.map();
@@ -650,10 +650,10 @@
 		const std::vector<DescriptionIndex> & 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) {
+			if (next_worker_without_cost_spawn_[--i] <= gametime) {
 				DescriptionIndex const id = worker_types_without_cost.at(i);
 				if (owner().is_worker_type_allowed(id)) {
-					int32_t const stock = m_supply->stock_workers(id);
+					int32_t const stock = supply_->stock_workers(id);
 					int32_t tdelta = WORKER_WITHOUT_COST_SPAWN_INTERVAL;
 
 					if (stock < 100) {
@@ -666,19 +666,19 @@
 						remove_workers(id, 1);
 					}
 
-					m_next_worker_without_cost_spawn[i] =
+					next_worker_without_cost_spawn_[i] =
 						schedule_act(game, tdelta);
 				} else
-					m_next_worker_without_cost_spawn[i] = never();
+					next_worker_without_cost_spawn_[i] = never();
 			}
 	}
 
 	//  Military stuff: Kill the soldiers that are dead.
-	if (m_next_military_act <= gametime) {
+	if (next_military_act_ <= gametime) {
 		DescriptionIndex const soldier_index = owner().tribe().soldier();
 
-		if (m_incorporated_workers.count(soldier_index)) {
-			WorkerList & soldiers = m_incorporated_workers[soldier_index];
+		if (incorporated_workers_.count(soldier_index)) {
+			WorkerList & soldiers = incorporated_workers_[soldier_index];
 
 			uint32_t total_heal = descr().get_heal_per_second();
 			// Using an explicit iterator, as we plan to erase some
@@ -695,7 +695,7 @@
 				//  Soldier dead ...
 				if (!soldier || soldier->get_current_hitpoints() == 0) {
 					it = soldiers.erase(it);
-					m_supply->remove_workers(soldier_index, 1);
+					supply_->remove_workers(soldier_index, 1);
 					continue;
 				}
 
@@ -706,13 +706,13 @@
 
 			}
 		}
-		m_next_military_act = schedule_act(game, 1000);
+		next_military_act_ = schedule_act(game, 1000);
 	}
 
-	if (static_cast<int32_t>(m_next_stock_remove_act - gametime) <= 0) {
+	if (static_cast<int32_t>(next_stock_remove_act_ - gametime) <= 0) {
 		check_remove_stock(game);
 
-		m_next_stock_remove_act = schedule_act(game, 4000);
+		next_stock_remove_act_ = schedule_act(game, 4000);
 	}
 
 	// Update planned workers; this is to update the request amounts and
@@ -738,10 +738,10 @@
 
 	if (portdock_)
 		portdock_->set_economy(e);
-	m_supply->set_economy(e);
+	supply_->set_economy(e);
 	Building::set_economy(e);
 
-	for (const PlannedWorkers& pw : m_planned_workers) {
+	for (const PlannedWorkers& pw : planned_workers_) {
 		for (Request * req : pw.requests) {
 			req->set_economy(e);
 		}
@@ -757,20 +757,20 @@
 
 const WareList & Warehouse::get_wares() const
 {
-	return m_supply->get_wares();
+	return supply_->get_wares();
 }
 
 
 const WareList & Warehouse::get_workers() const
 {
-	return m_supply->get_workers();
+	return supply_->get_workers();
 }
 
 PlayerImmovable::Workers Warehouse::get_incorporated_workers()
 {
 	PlayerImmovable::Workers all_workers;
 
-	for (const std::pair<DescriptionIndex, WorkerList>& worker_pair : m_incorporated_workers) {
+	for (const std::pair<DescriptionIndex, WorkerList>& worker_pair : incorporated_workers_) {
 		for (Worker * worker : worker_pair.second) {
 			all_workers.push_back(worker);
 		}
@@ -782,28 +782,28 @@
 /// Magically create wares in this warehouse. Updates the economy accordingly.
 void Warehouse::insert_wares(DescriptionIndex const id, uint32_t const count)
 {
-	m_supply->add_wares(id, count);
+	supply_->add_wares(id, count);
 }
 
 
 /// Magically destroy wares.
 void Warehouse::remove_wares(DescriptionIndex const id, uint32_t const count)
 {
-	m_supply->remove_wares(id, count);
+	supply_->remove_wares(id, count);
 }
 
 
 /// Magically create workers in this warehouse. Updates the economy accordingly.
 void Warehouse::insert_workers(DescriptionIndex const id, uint32_t const count)
 {
-	m_supply->add_workers(id, count);
+	supply_->add_workers(id, count);
 }
 
 
 /// Magically destroy workers.
 void Warehouse::remove_workers(DescriptionIndex const id, uint32_t const count)
 {
-	m_supply->remove_workers(id, count);
+	supply_->remove_workers(id, count);
 }
 
 
@@ -813,14 +813,14 @@
 {
 	DescriptionIndex const carrierid = owner().tribe().carrier();
 
-	if (!m_supply->stock_workers(carrierid))
+	if (!supply_->stock_workers(carrierid))
 	{
 		if (can_create_worker(game, carrierid))
 		{
 			create_worker(game, carrierid);
 		}
 	}
-	if (m_supply->stock_workers(carrierid))
+	if (supply_->stock_workers(carrierid))
 	{
 		launch_worker(game, carrierid, Requirements()).start_task_fetchfromflag(game);
 	}
@@ -839,11 +839,11 @@
 	uint32_t sum = 0;
 
 	do {
-		sum += m_supply->stock_workers(ware);
+		sum += supply_->stock_workers(ware);
 
 		// NOTE: This code lies about the TrainingAttributes of non-instantiated workers.
-		if (m_incorporated_workers.count(ware)) {
-			for (Worker * worker : m_incorporated_workers[ware]) {
+		if (incorporated_workers_.count(ware)) {
+			for (Worker * worker : incorporated_workers_[ware]) {
 				if (!req.check(*worker)) {
 					//  This is one of the workers in our sum.
 					//  But he is too stupid for this job
@@ -864,16 +864,16 @@
 	(Game & game, DescriptionIndex worker_id, const Requirements & req)
 {
 	do {
-		if (m_supply->stock_workers(worker_id)) {
-			uint32_t unincorporated = m_supply->stock_workers(worker_id);
+		if (supply_->stock_workers(worker_id)) {
+			uint32_t unincorporated = supply_->stock_workers(worker_id);
 
 			//  look if we got one of those in stock
-			if (m_incorporated_workers.count(worker_id)) {
+			if (incorporated_workers_.count(worker_id)) {
 				// On cleanup, it could be that the worker was deleted under
 				// us, so we erase the pointer we had to it and create a new
 				// one.
-				remove_no_longer_existing_workers(game, &m_incorporated_workers[worker_id]);
-				WorkerList& incorporated_workers = m_incorporated_workers[worker_id];
+				remove_no_longer_existing_workers(game, &incorporated_workers_[worker_id]);
+				WorkerList& incorporated_workers = incorporated_workers_[worker_id];
 
 				for (std::vector<Worker *>::iterator worker_iter = incorporated_workers.begin();
 					 worker_iter != incorporated_workers.end(); ++worker_iter)
@@ -886,18 +886,18 @@
 						worker->set_location(this); //  back in a economy
 						incorporated_workers.erase(worker_iter);
 
-						m_supply->remove_workers(worker_id, 1);
+						supply_->remove_workers(worker_id, 1);
 						return *worker;
 					}
 				}
 			}
 
-			assert(unincorporated <= m_supply->stock_workers(worker_id));
+			assert(unincorporated <= supply_->stock_workers(worker_id));
 
 			if (unincorporated) {
 				// Create a new one
 				// NOTE: This code lies about the TrainingAttributes of the new worker
-				m_supply->remove_workers(worker_id, 1);
+				supply_->remove_workers(worker_id, 1);
 				const WorkerDescr & workerdescr = *game.tribes().get_worker_descr(worker_id);
 				return workerdescr.create(game, owner(), this, position_);
 			}
@@ -926,7 +926,7 @@
 
 	DescriptionIndex worker_index = owner().tribe().worker_index(w->descr().name().c_str());
 
-	m_supply->add_workers(worker_index, 1);
+	supply_->add_workers(worker_index, 1);
 
 	//  We remove carriers, but we keep other workers around.
 	//  TODO(unknown): Remove all workers that do not have properties such as experience.
@@ -942,9 +942,9 @@
 	}
 
 	// Incorporate the worker
-	if (!m_incorporated_workers.count(worker_index))
-		m_incorporated_workers[worker_index] = std::vector<Worker *>();
-	m_incorporated_workers[worker_index].push_back(w);
+	if (!incorporated_workers_.count(worker_index))
+		incorporated_workers_[worker_index] = std::vector<Worker *>();
+	incorporated_workers_[worker_index].push_back(w);
 
 	w->set_location(nullptr); //  no longer in an economy
 
@@ -963,7 +963,7 @@
 	ware.init(game);
 	if (do_launch_ware(game, ware))
 	{
-		m_supply->remove_wares(ware_index, 1);
+		supply_->remove_wares(ware_index, 1);
 	}
 	return ware;
 }
@@ -975,14 +975,14 @@
 	// Create a carrier
 	const DescriptionIndex carrierid = owner().tribe().carrier();
 
-	if (!m_supply->stock_workers(carrierid))
+	if (!supply_->stock_workers(carrierid))
 	{
 		if (can_create_worker(game, carrierid))
 		{
 			create_worker(game, carrierid);
 		}
 	}
-	if (m_supply->stock_workers(carrierid))
+	if (supply_->stock_workers(carrierid))
 	{
 		Widelands::Worker & worker = launch_worker(game, carrierid, Requirements());
 		// Setup the carrier
@@ -997,7 +997,7 @@
 
 void Warehouse::incorporate_ware(EditorGameBase & egbase, WareInstance* ware)
 {
-	m_supply->add_wares(ware->descr_index(), 1);
+	supply_->add_wares(ware->descr_index(), 1);
 	ware->destroy(egbase);
 }
 
@@ -1015,7 +1015,7 @@
 	if (w) {
 		w->schedule_incorporate(game);
 	} else {
-		wh.m_supply->add_wares(ware, 1);
+		wh.supply_->add_wares(ware, 1);
 
 		// This ware may be used to build planned workers,
 		// so it seems like a good idea to update the associated requests
@@ -1029,7 +1029,7 @@
  */
 void Warehouse::receive_ware(Game & /* game */, DescriptionIndex ware)
 {
-	m_supply->add_wares(ware, 1);
+	supply_->add_wares(ware, 1);
 }
 
 /**
@@ -1048,10 +1048,10 @@
 bool Warehouse::can_create_worker(Game &, DescriptionIndex const worker) const {
 	assert(owner().tribe().has_worker(worker));
 
-	if (!(worker < m_supply->get_workers().get_nrwareids()))
+	if (!(worker < supply_->get_workers().get_nrwareids()))
 		throw wexception
 			("worker type %d does not exists (max is %d)",
-			 worker, m_supply->get_workers().get_nrwareids());
+			 worker, supply_->get_workers().get_nrwareids());
 
 	const WorkerDescr& w_desc = *owner().tribe().get_worker_descr(worker);
 	assert(&w_desc);
@@ -1064,13 +1064,13 @@
 		const std::string & input_name = buildcost.first;
 		DescriptionIndex id_w = owner().tribe().ware_index(input_name);
 		if (owner().tribe().has_ware(id_w)) {
-			if (m_supply->stock_wares(id_w) < buildcost.second) {
+			if (supply_->stock_wares(id_w) < buildcost.second) {
 				return false;
 			}
 		} else {
 			id_w = owner().tribe().worker_index(input_name);
 			if (owner().tribe().has_worker(id_w)) {
-				if (m_supply->stock_workers(id_w) < buildcost.second) {
+				if (supply_->stock_workers(id_w) < buildcost.second) {
 					return false;
 				}
 			} else
@@ -1107,7 +1107,7 @@
 	// may have been called directly by the Economy.
 	// Do not update anything else about PlannedWorkers here, because this
 	// function is called by _update_planned_workers, so avoid recursion
-	for (PlannedWorkers& planned_worker : m_planned_workers) {
+	for (PlannedWorkers& planned_worker : planned_workers_) {
 		if (planned_worker.index == worker && planned_worker.amount)
 			planned_worker.amount--;
 	}
@@ -1119,7 +1119,7 @@
  */
 uint32_t Warehouse::get_planned_workers(Game & /* game */, DescriptionIndex index) const
 {
-	for (const PlannedWorkers& pw : m_planned_workers) {
+	for (const PlannedWorkers& pw : planned_workers_) {
 		if (pw.index == index)
 			return pw.amount;
 	}
@@ -1154,7 +1154,7 @@
 		}
 	}
 
-	for (const PlannedWorkers& pw : m_planned_workers) {
+	for (const PlannedWorkers& pw : planned_workers_) {
 		if (pw.index == index) {
 			assert(available.size() == pw.requests.size());
 
@@ -1176,7 +1176,7 @@
 {
 	PlannedWorkers * pw = nullptr;
 
-	for (PlannedWorkers& planned_worker : m_planned_workers) {
+	for (PlannedWorkers& planned_worker : planned_workers_) {
 		if (planned_worker.index == index) {
 			pw = &planned_worker;
 			break;
@@ -1187,8 +1187,8 @@
 		if (!amount)
 			return;
 
-		m_planned_workers.push_back(PlannedWorkers());
-		pw = &m_planned_workers.back();
+		planned_workers_.push_back(PlannedWorkers());
+		pw = &planned_workers_.back();
 		pw->index = index;
 		pw->amount = 0;
 
@@ -1239,11 +1239,11 @@
 
 		DescriptionIndex id_w = owner().tribe().ware_index(input_name);
 		if (owner().tribe().has_ware(id_w)) {
-			supply = m_supply->stock_wares(id_w);
+			supply = supply_->stock_wares(id_w);
 		} else {
 			id_w = owner().tribe().worker_index(input_name);
 			if (owner().tribe().has_worker(id_w)) {
-			supply = m_supply->stock_workers(id_w);
+			supply = supply_->stock_workers(id_w);
 			} else
 				throw wexception
 					("_update_planned_workers: bad buildcost '%s'", input_name.c_str());
@@ -1271,12 +1271,12 @@
 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]);
+	while (idx < planned_workers_.size()) {
+		_update_planned_workers(game, planned_workers_[idx]);
 
-		if (!m_planned_workers[idx].amount) {
-			m_planned_workers[idx].cleanup();
-			m_planned_workers.erase(m_planned_workers.begin() + idx);
+		if (!planned_workers_[idx].amount) {
+			planned_workers_[idx].cleanup();
+			planned_workers_.erase(planned_workers_.begin() + idx);
 		} else {
 			idx++;
 		}
@@ -1286,14 +1286,14 @@
 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] == never());
-	m_next_worker_without_cost_spawn[worker_types_without_cost_index] =
+	assert(next_worker_without_cost_spawn_[worker_types_without_cost_index] == never());
+	next_worker_without_cost_spawn_[worker_types_without_cost_index] =
 		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] != never());
-	m_next_worker_without_cost_spawn[worker_types_without_cost_index] = never();
+	assert(next_worker_without_cost_spawn_[worker_types_without_cost_index] != never());
+	next_worker_without_cost_spawn_[worker_types_without_cost_index] = never();
 }
 
 
@@ -1362,14 +1362,14 @@
 
 Warehouse::StockPolicy Warehouse::get_ware_policy(DescriptionIndex ware) const
 {
-	assert(ware < static_cast<DescriptionIndex>(m_ware_policy.size()));
-	return m_ware_policy[ware];
+	assert(ware < static_cast<DescriptionIndex>(ware_policy_.size()));
+	return ware_policy_[ware];
 }
 
 Warehouse::StockPolicy Warehouse::get_worker_policy(DescriptionIndex ware) const
 {
-	assert(ware < static_cast<DescriptionIndex>(m_worker_policy.size()));
-	return m_worker_policy[ware];
+	assert(ware < static_cast<DescriptionIndex>(worker_policy_.size()));
+	return worker_policy_[ware];
 }
 
 Warehouse::StockPolicy Warehouse::get_stock_policy
@@ -1384,15 +1384,15 @@
 
 void Warehouse::set_ware_policy(DescriptionIndex ware, Warehouse::StockPolicy policy)
 {
-	assert(ware < static_cast<DescriptionIndex>(m_ware_policy.size()));
-	m_ware_policy[ware] = policy;
+	assert(ware < static_cast<DescriptionIndex>(ware_policy_.size()));
+	ware_policy_[ware] = policy;
 }
 
 void Warehouse::set_worker_policy
 	(DescriptionIndex ware, Warehouse::StockPolicy policy)
 {
-	assert(ware < static_cast<DescriptionIndex>(m_worker_policy.size()));
-	m_worker_policy[ware] = policy;
+	assert(ware < static_cast<DescriptionIndex>(worker_policy_.size()));
+	worker_policy_[ware] = policy;
 }
 
 /**
@@ -1402,7 +1402,7 @@
 void Warehouse::check_remove_stock(Game & game)
 {
 	if (base_flag().current_wares() < base_flag().total_capacity() / 2) {
-		for (DescriptionIndex ware = 0; ware < static_cast<DescriptionIndex>(m_ware_policy.size()); ++ware) {
+		for (DescriptionIndex ware = 0; ware < static_cast<DescriptionIndex>(ware_policy_.size()); ++ware) {
 			if (get_ware_policy(ware) != SP_Remove || !get_wares().stock(ware))
 				continue;
 
@@ -1411,7 +1411,7 @@
 		}
 	}
 
-	for (DescriptionIndex widx = 0; widx < static_cast<DescriptionIndex>(m_worker_policy.size()); ++widx) {
+	for (DescriptionIndex widx = 0; widx < static_cast<DescriptionIndex>(worker_policy_.size()); ++widx) {
 		if (get_worker_policy(widx) != SP_Remove || !get_workers().stock(widx))
 			continue;
 
@@ -1436,9 +1436,9 @@
 	std::vector<Soldier *> rv;
 
 	DescriptionIndex const soldier_index = owner().tribe().soldier();
-	IncorporatedWorkers::const_iterator sidx = m_incorporated_workers.find(soldier_index);
+	IncorporatedWorkers::const_iterator sidx = incorporated_workers_.find(soldier_index);
 
-	if (sidx != m_incorporated_workers.end()) {
+	if (sidx != incorporated_workers_.end()) {
 		const WorkerList & soldiers = sidx->second;
 
 		for (Worker * temp_soldier: soldiers) {
@@ -1456,14 +1456,14 @@
 int Warehouse::outcorporate_soldier(EditorGameBase & /* egbase */, Soldier & soldier) {
 
 	DescriptionIndex const soldier_index = owner().tribe().soldier();
-	if (m_incorporated_workers.count(soldier_index)) {
-		WorkerList & soldiers = m_incorporated_workers[soldier_index];
+	if (incorporated_workers_.count(soldier_index)) {
+		WorkerList & soldiers = incorporated_workers_[soldier_index];
 
 		WorkerList::iterator i = std::find
 			(soldiers.begin(), soldiers.end(), &soldier);
 
 		soldiers.erase(i);
-		m_supply->remove_workers(soldier_index, 1);
+		supply_->remove_workers(soldier_index, 1);
 	}
 #ifndef NDEBUG
 	else
@@ -1488,7 +1488,7 @@
 			if (fleet) {
 				molog("* fleet: %u\n", fleet->serial());
 				molog("  ships: %u, ports: %u\n", fleet->count_ships(), fleet->count_ports());
-				molog("  m_act_pending: %s\n", (fleet->get_act_pending())?"true":"false");
+				molog("  act_pending: %s\n", (fleet->get_act_pending())?"true":"false");
 			} else {
 				molog("No fleet?!\n");
 			}

=== modified file 'src/logic/map_objects/tribes/warehouse.h'
--- src/logic/map_objects/tribes/warehouse.h	2016-02-07 06:10:47 +0000
+++ src/logic/map_objects/tribes/warehouse.h	2016-02-13 14:28:04 +0000
@@ -54,15 +54,15 @@
 
 	Building & create_object() const override;
 
-	uint32_t get_conquers() const override {return m_conquers;}
+	uint32_t get_conquers() const override {return conquers_;}
 
 	uint32_t get_heal_per_second        () const {
-		return m_heal_per_second;
+		return heal_per_second_;
 	}
 
 private:
-	int32_t m_conquers;
-	uint32_t m_heal_per_second;
+	int32_t conquers_;
+	uint32_t heal_per_second_;
 	DISALLOW_COPY_AND_ASSIGN(WarehouseDescr);
 };
 
@@ -122,7 +122,7 @@
 	/// * Sets a next_spawn time for each buildable worker type without cost
 	///   that the owning player is allowed to create and schedules act for for
 	///   the spawn.
-	/// * Schedules act for military stuff (and sets m_next_military_act).
+	/// * Schedules act for military stuff (and sets next_military_act_).
 	/// * Sees the area (since a warehouse is considered to be always occupied).
 	/// * Conquers land if the the warehouse type is configured to do that.
 	/// * Sends a message to the player about the creation of this warehouse.
@@ -256,20 +256,20 @@
 	void _update_planned_workers(Game &, PlannedWorkers & pw);
 	void _update_all_planned_workers(Game &);
 
-	WarehouseSupply       * m_supply;
+	WarehouseSupply       * supply_;
 
-	std::vector<StockPolicy> m_ware_policy;
-	std::vector<StockPolicy> m_worker_policy;
+	std::vector<StockPolicy> ware_policy_;
+	std::vector<StockPolicy> worker_policy_;
 
 	// Workers who live here at the moment
 	using WorkerList = std::vector<Worker *>;
 	using IncorporatedWorkers = std::map<DescriptionIndex, WorkerList>;
-	IncorporatedWorkers        m_incorporated_workers;
-	std::vector<Time>          m_next_worker_without_cost_spawn;
-	Time                       m_next_military_act;
-	Time                       m_next_stock_remove_act;
+	IncorporatedWorkers        incorporated_workers_;
+	std::vector<Time>          next_worker_without_cost_spawn_;
+	Time                       next_military_act_;
+	Time                       next_stock_remove_act_;
 
-	std::vector<PlannedWorkers> m_planned_workers;
+	std::vector<PlannedWorkers> planned_workers_;
 
 	PortDock * portdock_;
 

=== modified file 'src/logic/map_objects/tribes/warelist.cc'
--- src/logic/map_objects/tribes/warelist.cc	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/warelist.cc	2016-02-13 14:28:04 +0000
@@ -32,9 +32,9 @@
  */
 WareList::~WareList()
 {
-	for (uint32_t id = 0; id < m_wares.size(); ++id) {
-		if (m_wares[id])
-			log("WareList: %i items of %i left.\n", m_wares[id], id);
+	for (uint32_t id = 0; id < wares_.size(); ++id) {
+		if (wares_[id])
+			log("WareList: %i items of %i left.\n", wares_[id], id);
 	}
 }
 
@@ -46,10 +46,10 @@
 	if (!count)
 		return;
 
-	if (m_wares.size() <= i)
-		m_wares.resize(i + 1, 0);
-	m_wares[i] += count;
-	assert(m_wares[i] >= count);
+	if (wares_.size() <= i)
+		wares_.resize(i + 1, 0);
+	wares_[i] += count;
+	assert(wares_[i] >= count);
 
 	changed();
 }
@@ -58,11 +58,11 @@
 void WareList::add(const WareList & wl)
 {
 	DescriptionIndex const nr_wares = wl.get_nrwareids();
-	if (m_wares.size() < nr_wares)
-		m_wares.reserve(nr_wares);
+	if (wares_.size() < nr_wares)
+		wares_.reserve(nr_wares);
 	for (DescriptionIndex i = 0; i < nr_wares; ++i)
-		if (wl.m_wares[i])
-			add(i, wl.m_wares[i]);
+		if (wl.wares_[i])
+			add(i, wl.wares_[i]);
 }
 
 
@@ -73,9 +73,9 @@
 	if (!count)
 		return;
 
-	assert(i < m_wares.size());
-	assert(m_wares[i] >= count);
-	m_wares[i] -= count;
+	assert(i < wares_.size());
+	assert(wares_[i] >= count);
+	wares_[i] -= count;
 
 	changed();
 }
@@ -85,15 +85,15 @@
 {
 	DescriptionIndex const nr_wares = wl.get_nrwareids();
 	for (DescriptionIndex i = 0; i < nr_wares; ++i)
-		if (wl.m_wares[i])
-			remove(i, wl.m_wares[i]);
+		if (wl.wares_[i])
+			remove(i, wl.wares_[i]);
 }
 
 /**
  * Return the number of wares of a given type stored in this storage.
  */
 WareList::WareCount WareList::stock(DescriptionIndex const id) const {
-	return id < m_wares.size() ? m_wares[id] : 0;
+	return id < wares_.size() ? wares_[id] : 0;
 }
 
 
@@ -105,10 +105,10 @@
 {
 	uint32_t i = 0;
 
-	while (i < wl.m_wares.size()) {
-		const WareCount count = wl.m_wares[i];
-		if (i < m_wares.size()) {
-			if (count != m_wares[i])
+	while (i < wl.wares_.size()) {
+		const WareCount count = wl.wares_[i];
+		if (i < wares_.size()) {
+			if (count != wares_[i])
 				return false;
 		} else {
 			if (count) // wl2 has 0 stock per definition
@@ -117,8 +117,8 @@
 		++i;
 	}
 
-	while (i < m_wares.size()) {
-		if (m_wares[i]) // wl1 has 0 stock per definition
+	while (i < wares_.size()) {
+		if (wares_[i]) // wl1 has 0 stock per definition
 			return false;
 		++i;
 	}

=== modified file 'src/logic/map_objects/tribes/warelist.h'
--- src/logic/map_objects/tribes/warelist.h	2015-11-28 22:29:26 +0000
+++ src/logic/map_objects/tribes/warelist.h	2016-02-13 14:28:04 +0000
@@ -38,13 +38,13 @@
 	WareList() {}
 	~WareList();
 
-	void clear() {m_wares.clear();} /// Clear the storage
+	void clear() {wares_.clear();} /// Clear the storage
 
 	using WareCount = uint32_t;
 	using WareCountVector = std::vector<WareCount>;
 
 	/// \return Highest possible ware id
-	DescriptionIndex get_nrwareids() const {return DescriptionIndex(m_wares.size());}
+	DescriptionIndex get_nrwareids() const {return DescriptionIndex(wares_.size());}
 
 	void add   (DescriptionIndex, WareCount = 1);
 	void add(const WareList &);
@@ -53,8 +53,8 @@
 	WareCount stock(DescriptionIndex) const;
 
 	void set_nrwares(DescriptionIndex const i) {
-		assert(m_wares.empty());
-		m_wares.resize(i, 0);
+		assert(wares_.empty());
+		wares_.resize(i, 0);
 	}
 
 	bool operator== (const WareList &)    const;
@@ -63,7 +63,7 @@
 	mutable boost::signals2::signal<void ()> changed;
 
 private:
-	WareCountVector m_wares;
+	WareCountVector wares_;
 };
 
 }

=== modified file 'src/logic/map_objects/tribes/worker.cc'
--- src/logic/map_objects/tribes/worker.cc	2016-02-07 09:30:20 +0000
+++ src/logic/map_objects/tribes/worker.cc	2016-02-13 14:28:04 +0000
@@ -1021,17 +1021,17 @@
 Worker::Worker(const WorkerDescr & worker_descr)
 	:
 	Bob          (worker_descr),
-	m_economy    (nullptr),
-	m_supply     (nullptr),
-	m_transfer   (nullptr),
-	m_current_exp(0)
+	economy_    (nullptr),
+	supply_     (nullptr),
+	transfer_   (nullptr),
+	current_exp_(0)
 {
 }
 
 Worker::~Worker()
 {
-	assert(!m_location.is_set());
-	assert(!m_transfer);
+	assert(!location_.is_set());
+	assert(!transfer_);
 }
 
 
@@ -1040,29 +1040,29 @@
 {
 	Bob::log_general_info(egbase);
 
-	if (upcast(PlayerImmovable, loc, m_location.get(egbase))) {
+	if (upcast(PlayerImmovable, loc, location_.get(egbase))) {
 		molog("* Owner: (%p)\n", &loc->owner());
 		molog("** Owner (plrnr): %i\n", loc->owner().player_number());
 		molog("* Economy: %p\n", loc->get_economy());
 	}
 
-	PlayerImmovable * imm = m_location.get(egbase);
+	PlayerImmovable * imm = location_.get(egbase);
 	molog("location: %u\n", imm ? imm->serial() : 0);
-	molog("Economy: %p\n", m_economy);
-	molog("transfer: %p\n",  m_transfer);
+	molog("Economy: %p\n", economy_);
+	molog("transfer: %p\n",  transfer_);
 
-	if (upcast(WareInstance, ware, m_carried_ware.get(egbase))) {
+	if (upcast(WareInstance, ware, carried_ware_.get(egbase))) {
 		molog
-			("* m_carried_ware->get_ware() (id): %i\n",
+			("* carried_ware->get_ware() (id): %i\n",
 			 ware->descr_index());
-		molog("* m_carried_ware->get_economy() (): %p\n", ware->get_economy());
+		molog("* carried_ware->get_economy() (): %p\n", ware->get_economy());
 	}
 
 	molog
-		("m_current_exp: %i / %i\n",
-		 m_current_exp, descr().get_needed_experience());
+		("current_exp: %i / %i\n",
+		 current_exp_, descr().get_needed_experience());
 
-	molog("m_supply: %p\n", m_supply);
+	molog("supply: %p\n", supply_);
 }
 
 
@@ -1076,28 +1076,28 @@
 {
 	assert(!location || ObjectPointer(location).get(owner().egbase()));
 
-	PlayerImmovable * const oldlocation = get_location(owner().egbase());
-	if (oldlocation == location)
+	PlayerImmovable * const old_location = get_location(owner().egbase());
+	if (old_location == location)
 		return;
 
-	if (oldlocation) {
-		// Note: even though we have an oldlocation, m_economy may be zero
-		// (oldlocation got deleted)
-		oldlocation->remove_worker(*this);
+	if (old_location) {
+		// Note: even though we have an old location, economy_ may be zero
+		// (old_location got deleted)
+		old_location->remove_worker(*this);
 	} else {
 		if (!is_shipping()) {
-			assert(!m_economy);
+			assert(!economy_);
 		}
 	}
 
-	m_location = location;
+	location_ = location;
 
 	if (location) {
 		Economy * const eco = location->get_economy();
 
-		if (!m_economy || (descr().type() == MapObjectType::SOLDIER)) {
+		if (!economy_ || (descr().type() == MapObjectType::SOLDIER)) {
 			set_economy(eco);
-		} else if (m_economy != eco) {
+		} else if (economy_ != eco) {
 			throw wexception
 				("Worker::set_location changes economy, but worker is no soldier");
 		}
@@ -1124,22 +1124,22 @@
  */
 void Worker::set_economy(Economy * const economy)
 {
-	if (economy == m_economy)
+	if (economy == economy_)
 		return;
 
-	if (m_economy)
-		m_economy->remove_workers
+	if (economy_)
+		economy_->remove_workers
 			(owner().tribe().worker_index(descr().name().c_str()), 1);
 
-	m_economy = economy;
+	economy_ = economy;
 
 	if (WareInstance * const ware = get_carried_ware(owner().egbase()))
-		ware->set_economy(m_economy);
-	if (m_supply)
-		m_supply->set_economy(m_economy);
+		ware->set_economy(economy_);
+	if (supply_)
+		supply_->set_economy(economy_);
 
-	if (m_economy)
-		m_economy->add_workers(owner().tribe().worker_index(descr().name().c_str()), 1);
+	if (economy_)
+		economy_->add_workers(owner().tribe().worker_index(descr().name().c_str()), 1);
 }
 
 
@@ -1167,9 +1167,9 @@
 {
 	WareInstance * const ware = get_carried_ware(egbase);
 
-	if (m_supply) {
-		delete m_supply;
-		m_supply = nullptr;
+	if (supply_) {
+		delete supply_;
+		supply_ = nullptr;
 	}
 
 	if (ware)
@@ -1204,7 +1204,7 @@
 		delete oldware;
 	}
 
-	m_carried_ware = ware;
+	carried_ware_ = ware;
 	ware->set_location(egbase, this);
 	if (upcast(Game, game, &egbase))
 		ware->update(*game);
@@ -1220,7 +1220,7 @@
 
 	if (ware) {
 		ware->set_location(game, nullptr);
-		m_carried_ware = nullptr;
+		carried_ware_ = nullptr;
 	}
 
 	return ware;
@@ -1261,11 +1261,11 @@
 void Worker::create_needed_experience(Game & /* game */)
 {
 	if (descr().get_needed_experience() == INVALID_INDEX) {
-		m_current_exp = INVALID_INDEX;
+		current_exp_ = INVALID_INDEX;
 		return;
 	}
 
-	m_current_exp = 0;
+	current_exp_ = 0;
 }
 
 
@@ -1278,7 +1278,7 @@
  */
 DescriptionIndex Worker::gain_experience(Game & game) {
 	return (descr().get_needed_experience() == INVALID_INDEX ||
-			  ++m_current_exp < descr().get_needed_experience()) ?
+			  ++current_exp_ < descr().get_needed_experience()) ?
 				INVALID_INDEX :
 				level(game);
 }
@@ -1304,8 +1304,8 @@
 	assert(t.has_worker(new_index));
 
 	// Inform the economy, that something has changed
-	m_economy->remove_workers(old_index, 1);
-	m_economy->add_workers   (new_index, 1);
+	economy_->remove_workers(old_index, 1);
+	economy_->add_workers   (new_index, 1);
 
 	create_needed_experience(game);
 	return old_index; //  So that the caller knows what to replace him with.
@@ -1354,21 +1354,21 @@
 	// (in that case, the transfer task already exists on the stack
 	// when this is called).
 	if (get_state(taskGowarehouse) || get_state(taskTransfer)) {
-		assert(!m_transfer);
+		assert(!transfer_);
 
-		m_transfer = t;
+		transfer_ = t;
 		send_signal(game, "transfer");
 	} else { //  just start a normal transfer
 		push_task(game, taskTransfer);
-		m_transfer = t;
+		transfer_ = t;
 	}
 }
 
 void Worker::transfer_pop(Game & /* game */, State & /* state */)
 {
-	if (m_transfer) {
-		m_transfer->has_failed();
-		m_transfer = nullptr;
+	if (transfer_) {
+		transfer_->has_failed();
+		transfer_ = nullptr;
 	}
 }
 
@@ -1384,7 +1384,7 @@
 	}
 
 	// The request is no longer valid, the task has failed
-	if (!m_transfer) {
+	if (!transfer_) {
 		molog("[transfer]: Fail (without transfer)\n");
 
 		send_signal(game, "fail");
@@ -1435,12 +1435,12 @@
 	// Figure out where to go
 	bool success;
 	PlayerImmovable * const nextstep =
-		m_transfer->get_next_step(location, success);
+		transfer_->get_next_step(location, success);
 
 	if (!nextstep) {
-		Transfer * const t = m_transfer;
+		Transfer * const t = transfer_;
 
-		m_transfer = nullptr;
+		transfer_ = nullptr;
 
 		if (success) {
 			pop_task(game);
@@ -1550,7 +1550,7 @@
  */
 void Worker::cancel_task_transfer(Game & game)
 {
-	m_transfer = nullptr;
+	transfer_ = nullptr;
 	send_signal(game, "cancel");
 }
 
@@ -1946,7 +1946,7 @@
  */
 void Worker::start_task_gowarehouse(Game & game)
 {
-	assert(!m_supply);
+	assert(!supply_);
 
 	push_task(game, taskGowarehouse);
 }
@@ -1978,17 +1978,17 @@
 	}
 
 	if (dynamic_cast<Warehouse const *>(location)) {
-		delete m_supply;
-		m_supply = nullptr;
+		delete supply_;
+		supply_ = nullptr;
 
 		schedule_incorporate(game);
 		return;
 	}
 
 	// If we got a transfer, use it
-	if (m_transfer) {
-		Transfer * const t = m_transfer;
-		m_transfer = nullptr;
+	if (transfer_) {
+		Transfer * const t = transfer_;
+		transfer_ = nullptr;
 
 		molog("[gowarehouse]: Got transfer\n");
 
@@ -2011,8 +2011,8 @@
 	// check against disappearing warehouses, or the worker will just
 	// idle on a flag until the end of days (actually, until either the
 	// flag is removed or a warehouse connects to the Economy).
-	if (!m_supply)
-		m_supply = new IdleWorkerSupply(*this);
+	if (!supply_)
+		supply_ = new IdleWorkerSupply(*this);
 
 	return start_task_idle(game, descr().get_animation("idle"), 1000);
 }
@@ -2023,19 +2023,19 @@
 	if (signal == "transfer") {
 		// We are assigned a transfer, make sure our supply disappears immediately
 		// Otherwise, we might receive two transfers in a row.
-		delete m_supply;
-		m_supply = nullptr;
+		delete supply_;
+		supply_ = nullptr;
 	}
 }
 
 void Worker::gowarehouse_pop(Game &, State &)
 {
-	delete m_supply;
-	m_supply = nullptr;
+	delete supply_;
+	supply_ = nullptr;
 
-	if (m_transfer) {
-		m_transfer->has_failed();
-		m_transfer = nullptr;
+	if (transfer_) {
+		transfer_->has_failed();
+		transfer_ = nullptr;
 	}
 }
 
@@ -2477,16 +2477,16 @@
 }
 
 struct FindFlagWithPlayersWarehouse {
-	FindFlagWithPlayersWarehouse(const Player & owner) : m_owner(owner) {}
+	FindFlagWithPlayersWarehouse(const Player & owner) : owner_(owner) {}
 	bool accept(const BaseImmovable & imm) const {
 		if (upcast(Flag const, flag, &imm))
-			if (&flag->owner() == &m_owner)
+			if (&flag->owner() == &owner_)
 				if (flag->economy().warehouses().size())
 					return true;
 		return false;
 	}
 private:
-	const Player & m_owner;
+	const Player & owner_;
 };
 
 void Worker::fugitive_update(Game & game, State & state)
@@ -2925,8 +2925,8 @@
 constexpr uint8_t kCurrentPacketVersion = 2;
 
 Worker::Loader::Loader() :
-	m_location(0),
-	m_carried_ware(0)
+	location_(0),
+	carried_ware_(0)
 {
 }
 
@@ -2938,13 +2938,13 @@
 		if (packet_version == kCurrentPacketVersion) {
 
 			Worker & worker = get<Worker>();
-			m_location = fr.unsigned_32();
-			m_carried_ware = fr.unsigned_32();
-			worker.m_current_exp = fr.signed_32();
+			location_ = fr.unsigned_32();
+			carried_ware_ = fr.unsigned_32();
+			worker.current_exp_ = fr.signed_32();
 
 			if (fr.unsigned_8()) {
-				worker.m_transfer = new Transfer(dynamic_cast<Game&>(egbase()), worker);
-				worker.m_transfer->read(fr, m_transfer);
+				worker.transfer_ = new Transfer(dynamic_cast<Game&>(egbase()), worker);
+				worker.transfer_->read(fr, transfer_);
 			}
 		} else {
 			throw UnhandledVersionError("Worker", packet_version, kCurrentPacketVersion);
@@ -2960,12 +2960,12 @@
 
 	Worker & worker = get<Worker>();
 
-	if (m_location)
-		worker.set_location(&mol().get<PlayerImmovable>(m_location));
-	if (m_carried_ware)
-		worker.m_carried_ware = &mol().get<WareInstance>(m_carried_ware);
-	if (worker.m_transfer)
-		worker.m_transfer->read_pointers(mol(), m_transfer);
+	if (location_)
+		worker.set_location(&mol().get<PlayerImmovable>(location_));
+	if (carried_ware_)
+		worker.carried_ware_ = &mol().get<WareInstance>(carried_ware_);
+	if (worker.transfer_)
+		worker.transfer_->read_pointers(mol(), transfer_);
 }
 
 void Worker::Loader::load_finish()
@@ -2980,7 +2980,7 @@
 	// us and will do so on load too. To make the order at which we are loaded
 	// not a factor, we do not overwrite the economy they might have set for us
 	// already.
-	if (PlayerImmovable * const location = worker.m_location.get(egbase())) {
+	if (PlayerImmovable * const location = worker.location_.get(egbase())) {
 		worker.set_economy(location->get_economy());
 	}
 }
@@ -3076,13 +3076,13 @@
 	Bob::save(egbase, mos, fw);
 
 	fw.unsigned_8(kCurrentPacketVersion);
-	fw.unsigned_32(mos.get_object_file_index_or_zero(m_location.get(egbase)));
-	fw.unsigned_32(mos.get_object_file_index_or_zero(m_carried_ware.get(egbase)));
-	fw.signed_32(m_current_exp);
+	fw.unsigned_32(mos.get_object_file_index_or_zero(location_.get(egbase)));
+	fw.unsigned_32(mos.get_object_file_index_or_zero(carried_ware_.get(egbase)));
+	fw.signed_32(current_exp_);
 
-	if (m_transfer) {
+	if (transfer_) {
 		fw.unsigned_8(1);
-		m_transfer->write(mos, fw);
+		transfer_->write(mos, fw);
 	} else {
 		fw.unsigned_8(0);
 	}

=== modified file 'src/logic/map_objects/tribes/worker.h'
--- src/logic/map_objects/tribes/worker.h	2016-02-02 12:38:05 +0000
+++ src/logic/map_objects/tribes/worker.h	2016-02-13 14:28:04 +0000
@@ -43,7 +43,7 @@
  *  - Work: the worker is running his working schedule
  */
 class Worker : public Bob {
-	friend class Soldier; //  allow access to m_supply
+	friend class Soldier; //  allow access to supply_
 	friend struct WorkerProgram;
 	friend struct MapBobdataPacket;
 
@@ -80,32 +80,32 @@
 
 	Player & owner() const {assert(get_owner()); return *get_owner();}
 	PlayerImmovable * get_location(EditorGameBase & egbase) {
-		return m_location.get(egbase);
+		return location_.get(egbase);
 	}
-	OPtr<PlayerImmovable> get_location() const {return m_location;}
-	Economy * get_economy() const {return m_economy;}
+	OPtr<PlayerImmovable> get_location() const {return location_;}
+	Economy * get_economy() const {return economy_;}
 
 	/// Sets the location of the worker initially. It may not have a previous
 	/// location. Does not add the worker to the location's set of workers (it
 	/// should be there already). The worker must already be in the same economy
 	/// as the location.
 	void set_location_initially(PlayerImmovable & location) {
-		assert(!m_location.is_set());
+		assert(!location_.is_set());
 		assert(location.serial());
-		assert(m_economy);
-		assert(m_economy == location.get_economy());
-		m_location = &location;
+		assert(economy_);
+		assert(economy_ == location.get_economy());
+		location_ = &location;
 	}
 
 	void set_location(PlayerImmovable *);
 	void set_economy(Economy *);
 
 	WareInstance       * get_carried_ware(EditorGameBase       & egbase) {
-		return m_carried_ware.get(egbase);
+		return carried_ware_.get(egbase);
 	}
 	WareInstance const * get_carried_ware(const EditorGameBase & egbase) const
 	{
-		return m_carried_ware.get(egbase);
+		return carried_ware_.get(egbase);
 	}
 	void set_carried_ware(EditorGameBase &, WareInstance *);
 	WareInstance * fetch_carried_ware(EditorGameBase &);
@@ -131,7 +131,7 @@
 	void create_needed_experience(Game &);
 	DescriptionIndex level             (Game &);
 
-	int32_t get_current_experience() const {return m_current_exp;}
+	int32_t get_current_experience() const {return current_exp_;}
 	bool needs_experience() const {return descr().get_needed_experience() != INVALID_INDEX;}
 
 	// debug
@@ -140,7 +140,7 @@
 	// worker-specific tasks
 	void start_task_transfer(Game &, Transfer *);
 	void cancel_task_transfer(Game &);
-	Transfer * get_transfer() const {return m_transfer;}
+	Transfer * get_transfer() const {return transfer_;}
 
 	void start_task_shipping(Game &, PortDock*);
 	void end_shipping(Game &);
@@ -175,7 +175,7 @@
 	void draw(const EditorGameBase &, RenderTarget &, const Point&) const override;
 	void init_auto_task(Game &) override;
 
-	bool does_carry_ware() {return m_carried_ware.is_set();}
+	bool does_carry_ware() {return carried_ware_.is_set();}
 
 	void set_program_objvar(Game &, State &, MapObject * obj);
 
@@ -242,12 +242,12 @@
 	bool run_playfx           (Game &, State &, const Action &);
 	bool run_construct        (Game &, State &, const Action &);
 
-	OPtr<PlayerImmovable> m_location; ///< meta location of the worker
-	Economy          * m_economy;      ///< economy this worker is registered in
-	OPtr<WareInstance>    m_carried_ware; ///< ware we are carrying
-	IdleWorkerSupply * m_supply;   ///< supply while gowarehouse and not transfer
-	Transfer * m_transfer; ///< where we are currently being sent
-	int32_t                m_current_exp;  ///< current experience
+	OPtr<PlayerImmovable> location_; ///< meta location of the worker
+	Economy          * economy_;      ///< economy this worker is registered in
+	OPtr<WareInstance>    carried_ware_; ///< ware we are carrying
+	IdleWorkerSupply * supply_;   ///< supply while gowarehouse and not transfer
+	Transfer * transfer_; ///< where we are currently being sent
+	int32_t                current_exp_;  ///< current experience
 
 	// saving and loading
 protected:
@@ -264,9 +264,9 @@
 		const BobProgramBase * get_program(const std::string & name) override;
 
 	private:
-		uint32_t m_location;
-		uint32_t m_carried_ware;
-		Transfer::ReadData m_transfer;
+		uint32_t location_;
+		uint32_t carried_ware_;
+		Transfer::ReadData transfer_;
 	};
 
 	virtual Loader * create_loader();

=== modified file 'src/map_io/map_buildingdata_packet.cc'
--- src/map_io/map_buildingdata_packet.cc	2016-02-09 08:07:48 +0000
+++ src/map_io/map_buildingdata_packet.cc	2016-02-13 14:28:04 +0000
@@ -365,7 +365,7 @@
 				}
 			}
 
-			assert(warehouse.m_incorporated_workers.empty());
+			assert(warehouse.incorporated_workers_.empty());
 			{
 				uint16_t const nrworkers = fr.unsigned_16();
 				for (uint16_t i = 0; i < nrworkers; ++i) {
@@ -374,9 +374,9 @@
 					try {
 						Worker & worker = mol.get<Worker>(worker_serial);
 						const DescriptionIndex& worker_index = tribe.worker_index(worker.descr().name().c_str());
-						if (!warehouse.m_incorporated_workers.count(worker_index))
-							warehouse.m_incorporated_workers[worker_index] = std::vector<Worker *>();
-						warehouse.m_incorporated_workers[worker_index].push_back(&worker);
+						if (!warehouse.incorporated_workers_.count(worker_index))
+							warehouse.incorporated_workers_[worker_index] = std::vector<Worker *>();
+						warehouse.incorporated_workers_[worker_index].push_back(&worker);
 					} catch (const WException & e) {
 						throw GameDataError
 							("incorporated worker #%u (%u): %s",
@@ -415,7 +415,7 @@
 					assert(i < worker_types_without_cost.size());
 					if (worker_types_without_cost.at(i) == worker_index) {
 						if
-							(warehouse.m_next_worker_without_cost_spawn[i] != never())
+							(warehouse.next_worker_without_cost_spawn_[i] != never())
 							throw GameDataError
 								(
 								 "%s %u has a next_spawn time for worker type "
@@ -423,8 +423,8 @@
 								 "to %u\n",
 								 warehouse.descr().descname().c_str(), warehouse.serial(),
 								 worker_typename, next_spawn,
-								 warehouse.m_next_worker_without_cost_spawn[i]);
-						warehouse.m_next_worker_without_cost_spawn[i] = next_spawn;
+								 warehouse.next_worker_without_cost_spawn_[i]);
+						warehouse.next_worker_without_cost_spawn_[i] = next_spawn;
 						break;
 					}
 				}
@@ -437,10 +437,10 @@
 			// Consistency checks are in Warehouse::load_finish
 			uint32_t nr_planned_workers = fr.unsigned_32();
 			while (nr_planned_workers--) {
-				warehouse.m_planned_workers.push_back
+				warehouse.planned_workers_.push_back
 					(Warehouse::PlannedWorkers());
 				Warehouse::PlannedWorkers & pw =
-					warehouse.m_planned_workers.back();
+					warehouse.planned_workers_.back();
 				pw.index = tribe.worker_index(fr.c_string());
 				pw.amount = fr.unsigned_32();
 
@@ -456,7 +456,7 @@
 				}
 			}
 
-			warehouse.m_next_stock_remove_act = fr.unsigned_32();
+			warehouse.next_stock_remove_act_ = fr.unsigned_32();
 
 			if (warehouse.descr().get_isport()) {
 				if (Serial portdock = fr.unsigned_32()) {
@@ -489,7 +489,7 @@
 				(Area<FCoords>
 				 (game.map().get_fcoords(warehouse.get_position()),
 				  warehouse.descr().vision_range()));
-			warehouse.m_next_military_act = game.get_gametime();
+			warehouse.next_military_act_ = game.get_gametime();
 			//log("Read warehouse stuff for %p\n", &warehouse);
 		} else {
 			throw UnhandledVersionError("MapBuildingdataPacket - Warehouse",
@@ -792,20 +792,20 @@
 		if (packet_version == kCurrentPacketVersionTrainingsite) {
 			read_productionsite(trainingsite, fr, game, mol);
 
-			delete trainingsite.m_soldier_request;
-			trainingsite.m_soldier_request = nullptr;
+			delete trainingsite.soldier_request_;
+			trainingsite.soldier_request_ = nullptr;
 			if (fr.unsigned_8()) {
-				trainingsite.m_soldier_request =
+				trainingsite.soldier_request_ =
 					new Request
 						(trainingsite,
 						 0,
 						 TrainingSite::request_soldier_callback,
 						 wwWORKER);
-				trainingsite.m_soldier_request->read(fr, game, mol);
+				trainingsite.soldier_request_->read(fr, game, mol);
 			}
 
-			trainingsite.m_capacity = fr.unsigned_8();
-			trainingsite.m_build_heroes = fr.unsigned_8();
+			trainingsite.capacity_ = fr.unsigned_8();
+			trainingsite.build_heroes_ = fr.unsigned_8();
 
 			uint8_t const nr_upgrades = fr.unsigned_8();
 			for (uint8_t i = 0; i < nr_upgrades; ++i) {
@@ -835,7 +835,7 @@
 				uint16_t spresence  = fr.unsigned_8();
 				mapsize--;
 				std::pair<uint16_t, uint8_t> t = std::make_pair(trainstall, spresence);
-				trainingsite.training_failure_count[std::make_pair(traintype, trainlevel)] = t;
+				trainingsite.training_failure_count_[std::make_pair(traintype, trainlevel)] = t;
 			}
 		} else {
 			throw UnhandledVersionError("MapBuildingdataPacket - Trainingsite",
@@ -851,22 +851,22 @@
 		//  Cmd_ChangeSoldierCapacity to the beginning of the game's command
 		//  queue. But that would not work because the command queue is not read
 		//  yet and will be cleared before it is read.
-		if        (trainingsite.m_capacity < trainingsite.min_soldier_capacity()) {
+		if        (trainingsite.capacity_ < trainingsite.min_soldier_capacity()) {
 			log
 				("WARNING: trainingsite %u of player %u at (%i, %i) has capacity "
 				 "set to %u but it must be at least %u. Changing to that value.\n",
 				 trainingsite.serial(), trainingsite.owner().player_number(),
 				 trainingsite.get_position().x, trainingsite.get_position().y,
-				 trainingsite.m_capacity, trainingsite.min_soldier_capacity());
-			trainingsite.m_capacity = trainingsite.min_soldier_capacity();
-		} else if (trainingsite.max_soldier_capacity() < trainingsite.m_capacity) {
+				 trainingsite.capacity_, trainingsite.min_soldier_capacity());
+			trainingsite.capacity_ = trainingsite.min_soldier_capacity();
+		} else if (trainingsite.max_soldier_capacity() < trainingsite.capacity_) {
 			log
 				("WARNING: trainingsite %u of player %u at (%i, %i) has capacity "
 				 "set to %u but it can be at most %u. Changing to that value.\n",
 				 trainingsite.serial(), trainingsite.owner().player_number(),
 				 trainingsite.get_position().x, trainingsite.get_position().y,
-				 trainingsite.m_capacity, trainingsite.max_soldier_capacity());
-			trainingsite.m_capacity = trainingsite.max_soldier_capacity();
+				 trainingsite.capacity_, trainingsite.max_soldier_capacity());
+			trainingsite.capacity_ = trainingsite.max_soldier_capacity();
 		}
 	} catch (const WException & e) {
 		throw GameDataError("trainingsite: %s", e.what());
@@ -1042,7 +1042,7 @@
 
 	//  supply
 	const TribeDescr & tribe = warehouse.owner().tribe();
-	const WareList & wares = warehouse.m_supply->get_wares();
+	const WareList & wares = warehouse.supply_->get_wares();
 	for (DescriptionIndex i = 0; i < wares.get_nrwareids  (); ++i) {
 		fw.unsigned_8(1);
 		fw.string(tribe.get_ware_descr(i)->name());
@@ -1050,7 +1050,7 @@
 		fw.unsigned_8(warehouse.get_ware_policy(i));
 	}
 	fw.unsigned_8(0);
-	const WareList & workers = warehouse.m_supply->get_workers();
+	const WareList & workers = warehouse.supply_->get_workers();
 	for (DescriptionIndex i = 0; i < workers.get_nrwareids(); ++i) {
 		fw.unsigned_8(1);
 		fw.string(tribe.get_worker_descr(i)->name());
@@ -1061,14 +1061,14 @@
 
 	//  Incorporated workers, write sorted after file-serial.
 	uint32_t nworkers = 0;
-	for (const std::pair<DescriptionIndex, Warehouse::WorkerList>& cwt: warehouse.m_incorporated_workers) {
+	for (const std::pair<DescriptionIndex, Warehouse::WorkerList>& cwt: warehouse.incorporated_workers_) {
 		nworkers += cwt.second.size();
 	}
 
 	fw.unsigned_16(nworkers);
 	using TWorkerMap = std::map<uint32_t, const Worker *>;
 	TWorkerMap workermap;
-	for (const std::pair<DescriptionIndex, Warehouse::WorkerList>& cwt : warehouse.m_incorporated_workers) {
+	for (const std::pair<DescriptionIndex, Warehouse::WorkerList>& cwt : warehouse.incorporated_workers_) {
 		for (Worker * temp_worker : cwt.second) {
 			const Worker & w = *temp_worker;
 			assert(mos.is_object_known(w));
@@ -1088,9 +1088,9 @@
 		const std::vector<DescriptionIndex> & worker_types_without_cost =
 			tribe.worker_types_without_cost();
 		assert(worker_types_without_cost.size() ==
-				 warehouse.m_next_worker_without_cost_spawn.size());
+				 warehouse.next_worker_without_cost_spawn_.size());
 		for (uint8_t i = worker_types_without_cost.size(); i;) {
-			const Time& next_spawn = warehouse.m_next_worker_without_cost_spawn[--i];
+			const Time& next_spawn = warehouse.next_worker_without_cost_spawn_[--i];
 			if (next_spawn != never()) {
 				fw.string
 					(tribe.get_worker_descr(tribe.worker_types_without_cost().at(i))
@@ -1101,8 +1101,8 @@
 	}
 	fw.unsigned_8(0); //  terminator for spawn times
 
-	fw.unsigned_32(warehouse.m_planned_workers.size());
-	for (const Warehouse::PlannedWorkers& temp_worker : warehouse.m_planned_workers) {
+	fw.unsigned_32(warehouse.planned_workers_.size());
+	for (const Warehouse::PlannedWorkers& temp_worker : warehouse.planned_workers_) {
 		fw.c_string(tribe.get_worker_descr(temp_worker.index)->name());
 		fw.unsigned_32(temp_worker.amount);
 
@@ -1113,7 +1113,7 @@
 		}
 	}
 
-	fw.unsigned_32(warehouse.m_next_stock_remove_act);
+	fw.unsigned_32(warehouse.next_stock_remove_act_);
 
 	if (warehouse.descr().get_isport()) {
 		fw.unsigned_32(mos.get_object_file_index_or_zero(warehouse.portdock_));
@@ -1261,34 +1261,34 @@
 
 	//  requests
 
-	if (trainingsite.m_soldier_request) {
+	if (trainingsite.soldier_request_) {
 		fw.unsigned_8(1);
-		trainingsite.m_soldier_request->write(fw, game, mos);
+		trainingsite.soldier_request_->write(fw, game, mos);
 	} else {
 		fw.unsigned_8(0);
 	}
 
-	fw.unsigned_8(trainingsite.m_capacity);
-	fw.unsigned_8(trainingsite.m_build_heroes);
+	fw.unsigned_8(trainingsite.capacity_);
+	fw.unsigned_8(trainingsite.build_heroes_);
 
 	// upgrades
-	fw.unsigned_8(trainingsite.m_upgrades.size());
-	for (uint8_t i = 0; i < trainingsite.m_upgrades.size(); ++i) {
-		const TrainingSite::Upgrade & upgrade = trainingsite.m_upgrades[i];
+	fw.unsigned_8(trainingsite.upgrades_.size());
+	for (uint8_t i = 0; i < trainingsite.upgrades_.size(); ++i) {
+		const TrainingSite::Upgrade & upgrade = trainingsite.upgrades_[i];
 		fw.unsigned_8(upgrade.attribute);
 		fw.unsigned_8(upgrade.prio);
 		fw.unsigned_8(upgrade.credit);
 		fw.signed_32(upgrade.lastattempt);
 		fw.signed_8(upgrade.lastsuccess);
 	}
-	if (255 < trainingsite.training_failure_count.size())
+	if (255 < trainingsite.training_failure_count_.size())
 		log
 			("Save TrainingSite: Failure counter has ridiculously many entries! (%u)\n",
-			 static_cast<uint16_t>(trainingsite.training_failure_count.size()));
-	fw.unsigned_16(static_cast<uint16_t> (trainingsite.training_failure_count.size()));
+			 static_cast<uint16_t>(trainingsite.training_failure_count_.size()));
+	fw.unsigned_16(static_cast<uint16_t> (trainingsite.training_failure_count_.size()));
 	for
-		(TrainingSite::TrainFailCount::const_iterator i = trainingsite.training_failure_count.begin();
-		 i != trainingsite.training_failure_count.end(); i++)
+		(TrainingSite::TrainFailCount::const_iterator i = trainingsite.training_failure_count_.begin();
+		 i != trainingsite.training_failure_count_.end(); i++)
 	{
 		fw.unsigned_16(i->first.first);
 		fw.unsigned_16(i->first.second);