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

[Benedikt Straub]

Allow scripts to override the hostility of each player to each other player.
Add an option »Peaceful Mode« to the launch game screen.

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 4656. State: errored. Details: https://travis-ci.org/widelands/widelands/builds/512954165.
Appveyor build 4443. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_peaceful-4443.

[GunChleoc (gunchleoc)]

Code LGTM so far except for a few nits, not tested.

I think we should also add some code to the fieldactions to forbid attacking a building, and the AI will need changing as well.

[Benedikt Straub (nordfriese)]

Implemented your comments.
Fieldaction and the AI already work correctly, because they use
  if (player_->is_hostile(bld->owner())) …
to see whether the aggressor is hostile to a building´s owner, and is_hostile() is where I put the important logic.
The only change the AI might need is that I´m not sure how it will handle players in a different team whom it is forbidden to attack. But when I tested the 2nd frisian scenario with these changes, it behaved well.

[GunChleoc (gunchleoc)]

Tested and working.

I think we should not allow peaceful mode for territorial time, territorial lord or autocrat, because it can make those game modes unwinnable. UI-wise, you could hook into the win condition dropdown's selected signal and show/hide the checkbox.

[Benedikt Straub (nordfriese)]

OK, implemented that :)

[GunChleoc (gunchleoc)]

Code LGTM, 1 nit. Will do some testing.

[GunChleoc (gunchleoc)]

Tested.

1 more thing: Tooltips that have only 1 sentence in them should not have a . at the end.

[Benedikt Straub (nordfriese)]

Tooltips changed

[bunnybot (widelandsofficial)]

Continuous integration builds have changed state:

Travis build 4815. State: passed. Details: https://travis-ci.org/widelands/widelands/builds/525048138.
Appveyor build 4596. State: success. Details: https://ci.appveyor.com/project/widelands-dev/widelands/build/_widelands_dev_widelands_peaceful-4596.

[GunChleoc (gunchleoc)]

Excellent :)

@bunnybot merge

=== modified file 'data/campaigns/fri02.wmf/scripting/mission_thread.lua'
--- data/campaigns/fri02.wmf/scripting/mission_thread.lua	2018-09-29 08:43:57 +0000
+++ data/campaigns/fri02.wmf/scripting/mission_thread.lua	2019-04-26 16:56:58 +0000
@@ -280,7 +280,8 @@
    if not p2.defeated then
       campaign_message_box(defeat_murilius_1)
       campaign_message_box(defeat_murilius_2)
-      p2.team = 2
+      p1:set_attack_forbidden(2, false)
+      p2:set_attack_forbidden(1, false)
       o = add_campaign_objective(obj_defeat_murilius)
       local def = false
       while not def do
@@ -299,7 +300,8 @@
 end
 
 function defeat_murilius()
-   p2.team = 2
+   p1:set_attack_forbidden(2, false)
+   p2:set_attack_forbidden(1, false)
    campaign_message_box(defeat_both)
    local o = add_campaign_objective(obj_defeat_both)
    while not (p2.defeated and p3.defeated) do sleep(4829) end
@@ -333,13 +335,28 @@
    include "map:scripting/starting_conditions.lua"
    sleep(5000)
 
-   p1.team = 1
-   p2.team = 1
-   p3.team = 2
--- TODO: instead of alliances, just forbid certain players to attack each other:
---     · Beginning:          forbid 1>2, 2>1, 2>3
---     · Refusing alliance:  forbid only 2>3
---     · Accepting alliance: first unchanged, after p3 defeated: allow all
+   p1:set_attack_forbidden(2, true)
+   p2:set_attack_forbidden(1, true)
+   p2:set_attack_forbidden(3, true)
+   run(function()
+      repeat
+         local conquered = (#p3:get_buildings("empire_sentry") +
+                            #p3:get_buildings("empire_blockhouse") +
+                            #p3:get_buildings("empire_outpost") +
+                            #p3:get_buildings("empire_barrier") +
+                            #p3:get_buildings("empire_tower") +
+                            #p3:get_buildings("empire_fortress") +
+                            #p3:get_buildings("empire_castle") -
+                            #p2:get_buildings("barbarians_sentry") -
+                            #p2:get_buildings("barbarians_barrier") -
+                            #p2:get_buildings("barbarians_tower") -
+                            #p2:get_buildings("barbarians_fortress") -
+                            #p2:get_buildings("barbarians_citadel"))
+         p2:set_attack_forbidden(3, conquered <= 0)
+         sleep(6913)
+      until p3.defeated or p2.defeated
+      p2:set_attack_forbidden(3, false)
+   end)
 
    campaign_message_box(intro_3)
    local o = add_campaign_objective(obj_new_home)
 
=== modified file 'data/scripting/win_conditions/artifacts.lua'
--- data/scripting/win_conditions/artifacts.lua	2019-04-25 12:07:53 +0000
+++ data/scripting/win_conditions/artifacts.lua	2019-04-26 16:56:58 +0000
@@ -23,6 +23,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = true,
    map_tags = { "artifacts" }, -- Map tags needed so that this win condition will be available only for suitable maps
    init = function()
       -- Find all artifacts
 
=== modified file 'data/scripting/win_conditions/collectors.lua'
--- data/scripting/win_conditions/collectors.lua	2019-02-13 16:29:08 +0000
+++ data/scripting/win_conditions/collectors.lua	2019-04-26 16:56:58 +0000
@@ -24,6 +24,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = true,
    func = function()
 
    -- set the objective with the game type for all players
 
=== modified file 'data/scripting/win_conditions/defeat_all.lua'
--- data/scripting/win_conditions/defeat_all.lua	2016-03-15 08:42:41 +0000
+++ data/scripting/win_conditions/defeat_all.lua	2019-04-26 16:56:58 +0000
@@ -18,6 +18,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = false,
    func = function()
       local plrs = wl.Game().players
 
 
=== modified file 'data/scripting/win_conditions/endless_game.lua'
--- data/scripting/win_conditions/endless_game.lua	2016-03-15 08:42:41 +0000
+++ data/scripting/win_conditions/endless_game.lua	2019-04-26 16:56:58 +0000
@@ -18,6 +18,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = true,
    func = function()
       local plrs = wl.Game().players
 
 
=== modified file 'data/scripting/win_conditions/endless_game_fogless.lua'
--- data/scripting/win_conditions/endless_game_fogless.lua	2016-03-15 08:42:41 +0000
+++ data/scripting/win_conditions/endless_game_fogless.lua	2019-04-26 16:56:58 +0000
@@ -18,6 +18,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = true,
    func = function()
       local plrs = wl.Game().players
 
 
=== modified file 'data/scripting/win_conditions/territorial_lord.lua'
--- data/scripting/win_conditions/territorial_lord.lua	2019-04-25 06:13:15 +0000
+++ data/scripting/win_conditions/territorial_lord.lua	2019-04-26 16:56:58 +0000
@@ -26,6 +26,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = false,
    init = function()
       fields = wl.Game().map:count_conquerable_fields()
    end,
 
=== modified file 'data/scripting/win_conditions/territorial_time.lua'
--- data/scripting/win_conditions/territorial_time.lua	2019-04-25 06:13:15 +0000
+++ data/scripting/win_conditions/territorial_time.lua	2019-04-26 16:56:58 +0000
@@ -30,6 +30,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = false,
    init = function()
       fields = wl.Game().map:count_conquerable_fields()
    end,
 
=== modified file 'data/scripting/win_conditions/wood_gnome.lua'
--- data/scripting/win_conditions/wood_gnome.lua	2019-03-09 10:55:24 +0000
+++ data/scripting/win_conditions/wood_gnome.lua	2019-04-26 16:56:58 +0000
@@ -24,6 +24,7 @@
 return {
    name = wc_name,
    description = wc_desc,
+   peaceful_mode_allowed = true,
    init = function()
       -- Calculate valuable fields
       wl.Game().map:count_terrestrial_fields()
 
=== modified file 'src/game_io/game_player_info_packet.cc'
--- src/game_io/game_player_info_packet.cc	2019-02-23 11:00:49 +0000
+++ src/game_io/game_player_info_packet.cc	2019-04-26 16:56:58 +0000
@@ -30,14 +30,14 @@
 
 namespace Widelands {
 
-constexpr uint16_t kCurrentPacketVersion = 22;
+constexpr uint16_t kCurrentPacketVersion = 23;
 
 void GamePlayerInfoPacket::read(FileSystem& fs, Game& game, MapObjectLoader*) {
 	try {
 		FileRead fr;
 		fr.open(fs, "binary/player_info");
 		uint16_t const packet_version = fr.unsigned_16();
-		if (packet_version == kCurrentPacketVersion) {
+		if (packet_version <= kCurrentPacketVersion && packet_version >= 22) {
 			uint32_t const max_players = fr.unsigned_16();
 			for (uint32_t i = 1; i < max_players + 1; ++i) {
 				game.remove_player(i);
@@ -59,6 +59,15 @@
 					player->set_see_all(see_all);
 
 					player->set_ai(fr.c_string());
+
+					if (packet_version == kCurrentPacketVersion) {
+						player->forbid_attack_.clear();
+						uint8_t size = fr.unsigned_8();
+						for (uint8_t j = 0; j < size; ++j) {
+							player->forbid_attack_.emplace(fr.unsigned_8());
+						}
+					}
+
 					player->read_statistics(fr, packet_version);
 					player->read_remaining_shipnames(fr);
 
@@ -118,6 +127,11 @@
 		fw.c_string(plr->name_.c_str());
 		fw.c_string(plr->ai_.c_str());
 
+		fw.unsigned_8(plr->forbid_attack_.size());
+		for (const auto& it : plr->forbid_attack_) {
+			fw.unsigned_8(it);
+		}
+
 		plr->write_statistics(fw);
 		plr->write_remaining_shipnames(fw);
 		fw.unsigned_32(plr->casualties());
 
=== modified file 'src/logic/game.cc'
--- src/logic/game.cc	2019-04-08 06:45:49 +0000
+++ src/logic/game.cc	2019-04-26 16:56:58 +0000
@@ -323,6 +323,19 @@
 	// Check for win_conditions
 	if (!settings.scenario) {
 		loader_ui->step(_("Initializing game…"));
+		if (settings.peaceful) {
+			for (uint32_t i = 1; i < settings.players.size(); ++i) {
+				if (Player* p1 = get_player(i)) {
+					for (uint32_t j = i + 1; j <= settings.players.size(); ++j) {
+						if (Player* p2 = get_player(j)) {
+							p1->set_attack_forbidden(j, true);
+							p2->set_attack_forbidden(i, true);
+						}
+					}
+				}
+			}
+		}
+
 		std::unique_ptr<LuaTable> table(lua().run_script(settings.win_condition_script));
 		table->do_not_warn_about_unaccessed_keys();
 		win_condition_displayname_ = table->get_string("name");
 
=== modified file 'src/logic/game_settings.h'
--- src/logic/game_settings.h	2019-02-23 11:00:49 +0000
+++ src/logic/game_settings.h	2019-04-26 16:56:58 +0000
@@ -111,7 +111,7 @@
  * Think of it as the Model in MVC.
  */
 struct GameSettings {
-	GameSettings() : playernum(0), usernum(0), scenario(false), multiplayer(false), savegame(false) {
+	GameSettings() : playernum(0), usernum(0), scenario(false), multiplayer(false), savegame(false), peaceful(false) {
 		std::unique_ptr<LuaInterface> lua(new LuaInterface);
 		std::unique_ptr<LuaTable> win_conditions(
 		   lua->run_script("scripting/win_conditions/init.lua"));
@@ -156,6 +156,9 @@
 	/// Is a savegame selected for loading?
 	bool savegame;
 
+	// Is all fighting forbidden?
+	bool peaceful;
+
 	/// List of tribes that players are allowed to choose
 	std::vector<Widelands::TribeBasicInfo> tribes;
 
@@ -210,6 +213,9 @@
 	virtual void set_win_condition_script(const std::string& wc) = 0;
 	virtual std::string get_win_condition_script() = 0;
 
+	virtual void set_peaceful_mode(bool peace) = 0;
+	virtual bool is_peaceful_mode() = 0;
+
 	// For retrieving tips texts
 	struct NoTribe {};
 	const std::string& get_players_tribe() {
 
=== modified file 'src/logic/player.cc'
--- src/logic/player.cc	2019-04-24 06:01:37 +0000
+++ src/logic/player.cc	2019-04-26 16:56:58 +0000
@@ -254,7 +254,8 @@
  * each other.
  */
 bool Player::is_hostile(const Player& other) const {
-	return &other != this && (!team_number_ || team_number_ != other.team_number_);
+	return &other != this && (!team_number_ || team_number_ != other.team_number_) &&
+			!is_attack_forbidden(other.player_number());
 }
 
 bool Player::is_defeated() const {
@@ -1334,6 +1335,21 @@
 	return ai_;
 }
 
+bool Player::is_attack_forbidden(PlayerNumber who) const {
+	return forbid_attack_.find(who) != forbid_attack_.end();
+}
+
+void Player::set_attack_forbidden(PlayerNumber who, bool forbid) {
+	const auto it = forbid_attack_.find(who);
+	if (forbid ^ (it == forbid_attack_.end())) {
+		return;
+	} else if (forbid) {
+		forbid_attack_.emplace(who);
+	} else {
+		forbid_attack_.erase(it);
+	}
+}
+
 /**
  * Pick random name from remaining names (if any)
  */
 
=== modified file 'src/logic/player.h'
--- src/logic/player.h	2019-03-17 11:44:04 +0000
+++ src/logic/player.h	2019-04-26 16:56:58 +0000
@@ -604,6 +604,9 @@
 		further_initializations_.push_back(init);
 	}
 
+	void set_attack_forbidden(PlayerNumber who, bool forbid);
+	bool is_attack_forbidden(PlayerNumber who) const;
+
 	const std::string pick_shipname();
 
 private:
@@ -681,6 +684,8 @@
 	 */
 	std::vector<std::vector<uint32_t>> ware_stocks_;
 
+	std::set<PlayerNumber> forbid_attack_;
+
 	PlayerBuildingStats building_stats_;
 
 	FxId message_fx_;
 
=== modified file 'src/logic/single_player_game_settings_provider.cc'
--- src/logic/single_player_game_settings_provider.cc	2019-02-23 11:00:49 +0000
+++ src/logic/single_player_game_settings_provider.cc	2019-04-26 16:56:58 +0000
@@ -69,6 +69,14 @@
 	return s.mapfilename;
 }
 
+bool SinglePlayerGameSettingsProvider::is_peaceful_mode() {
+	return s.peaceful;
+}
+
+void SinglePlayerGameSettingsProvider::set_peaceful_mode(bool peace) {
+	s.peaceful = peace;
+}
+
 void SinglePlayerGameSettingsProvider::set_map(const std::string& mapname,
                                                const std::string& mapfilename,
                                                uint32_t const maxplayers,
 
=== modified file 'src/logic/single_player_game_settings_provider.h'
--- src/logic/single_player_game_settings_provider.h	2019-02-23 11:00:49 +0000
+++ src/logic/single_player_game_settings_provider.h	2019-04-26 16:56:58 +0000
@@ -62,6 +62,9 @@
 	std::string get_win_condition_script() override;
 	void set_win_condition_script(const std::string& wc) override;
 
+	void set_peaceful_mode(bool peace) override;
+	bool is_peaceful_mode() override;
+
 private:
 	GameSettings s;
 };
 
=== modified file 'src/network/gameclient.cc'
--- src/network/gameclient.cc	2019-02-23 11:00:49 +0000
+++ src/network/gameclient.cc	2019-04-26 16:56:58 +0000
@@ -405,6 +405,15 @@
 	// set_player_number(uint8_t) to the host.
 }
 
+
+void GameClient::set_peaceful_mode(bool peace) {
+	d->settings.peaceful = peace;
+}
+
+bool GameClient::is_peaceful_mode() {
+	return d->settings.peaceful;
+}
+
 std::string GameClient::get_win_condition_script() {
 	return d->settings.win_condition_script;
 }
@@ -819,6 +828,10 @@
 		d->settings.win_condition_script = g_fs->FileSystem::fix_cross_file(packet.string());
 		break;
 	}
+	case NETCMD_PEACEFUL_MODE: {
+		d->settings.peaceful = packet.unsigned_8();
+		break;
+	}
 
 	case NETCMD_LAUNCH: {
 		if (!d->modal || d->game) {
 
=== modified file 'src/network/gameclient.h'
--- src/network/gameclient.h	2019-02-23 11:00:49 +0000
+++ src/network/gameclient.h	2019-04-26 16:56:58 +0000
@@ -95,6 +95,9 @@
 	void set_win_condition_script(const std::string&) override;
 	std::string get_win_condition_script() override;
 
+	void set_peaceful_mode(bool peace) override;
+	bool is_peaceful_mode() override;
+
 	// ChatProvider interface
 	void send(const std::string& msg) override;
 	const std::vector<ChatMessage>& get_messages() const override;
 
=== modified file 'src/network/gamehost.cc'
--- src/network/gamehost.cc	2019-02-23 11:00:49 +0000
+++ src/network/gamehost.cc	2019-04-26 16:56:58 +0000
@@ -203,6 +203,13 @@
 		host_->set_win_condition_script(wc);
 	}
 
+	void set_peaceful_mode(bool peace) override {
+		host_->set_peaceful_mode(peace);
+	}
+	bool is_peaceful_mode() override {
+		return host_->settings().peaceful;
+	}
+
 private:
 	GameHost* host_;
 	std::vector<std::string> wincondition_scripts_;
@@ -1368,6 +1375,16 @@
 	broadcast(packet);
 }
 
+void GameHost::set_peaceful_mode(bool peace) {
+	d->settings.peaceful = peace;
+
+	// Broadcast changes
+	SendPacket packet;
+	packet.unsigned_8(NETCMD_PEACEFUL_MODE);
+	packet.unsigned_8(peace ? 1 : 0);
+	broadcast(packet);
+}
+
 void GameHost::switch_to_player(uint32_t user, uint8_t number) {
 	if (number < d->settings.players.size() &&
 	    (d->settings.players.at(number).state != PlayerSettings::State::kOpen &&
@@ -1676,6 +1693,11 @@
 	packet.string(d->settings.win_condition_script);
 	d->net->send(client.sock_id, packet);
 
+	packet.reset();
+	packet.unsigned_8(NETCMD_PEACEFUL_MODE);
+	packet.unsigned_8(d->settings.peaceful ? 1 : 0);
+	d->net->send(client.sock_id, packet);
+
 	// Broadcast new information about the player to everybody
 	packet.reset();
 	packet.unsigned_8(NETCMD_SETTING_USER);
@@ -2143,6 +2165,12 @@
 		}
 		break;
 
+	case NETCMD_PEACEFUL_MODE:
+		if (!d->game) {
+			throw DisconnectException("NO_ACCESS_TO_SERVER");
+		}
+		break;
+
 	case NETCMD_LAUNCH:
 		if (!d->game) {
 			throw DisconnectException("NO_ACCESS_TO_SERVER");
 
=== modified file 'src/network/gamehost.h'
--- src/network/gamehost.h	2019-02-23 11:00:49 +0000
+++ src/network/gamehost.h	2019-04-26 16:56:58 +0000
@@ -80,6 +80,7 @@
 	void set_player_shared(PlayerSlot number, Widelands::PlayerNumber shared);
 	void switch_to_player(uint32_t user, uint8_t number);
 	void set_win_condition_script(const std::string& wc);
+	void set_peaceful_mode(bool peace);
 	void replace_client_with_ai(uint8_t playernumber, const std::string& ai);
 
 	// just visible stuff for the select mapmenu
 
=== modified file 'src/network/network_protocol.h'
--- src/network/network_protocol.h	2019-02-23 11:00:49 +0000
+++ src/network/network_protocol.h	2019-04-26 16:56:58 +0000
@@ -28,7 +28,7 @@
 	 * The current version of the in-game network protocol. Client and host
 	 * protocol versions must match.
 	 */
-	NETWORK_PROTOCOL_VERSION = 22,
+	NETWORK_PROTOCOL_VERSION = 23,
 
 	/**
 	 * The default interval (in milliseconds) in which the host issues
@@ -429,6 +429,14 @@
 	NETCMD_SYSTEM_MESSAGE_CODE = 32,
 
 	/**
+	 * Sent by the host to toggle peaceful mode.
+	 *
+	 * Attached data is:
+	 * \li uint8_t: 1 if peaceful mode is enabled, 0 otherwise
+	 */
+	NETCMD_PEACEFUL_MODE = 33,
+
+	/**
 	 * Sent by the metaserver to a freshly opened game to check connectability
 	 */
 	NETCMD_METASERVER_PING = 64
 
=== modified file 'src/scripting/lua_game.cc'
--- src/scripting/lua_game.cc	2019-04-24 06:43:22 +0000
+++ src/scripting/lua_game.cc	2019-04-26 16:56:58 +0000
@@ -100,6 +100,8 @@
    METHOD(LuaPlayer, allow_workers),
    METHOD(LuaPlayer, switchplayer),
    METHOD(LuaPlayer, get_produced_wares_count),
+   METHOD(LuaPlayer, set_attack_forbidden),
+   METHOD(LuaPlayer, is_attack_forbidden),
    {nullptr, nullptr},
 };
 const PropertyType<LuaPlayer> LuaPlayer::Properties[] = {
@@ -856,6 +858,39 @@
 	return 1;
 }
 
+/* RST
+   .. method:: is_attack_forbidden(who)
+
+      Returns true if this player is currently forbidden to attack the player with the specified
+      player number. Note that the return value `false` does not necessarily mean that this
+      player *can* attack the other player, as they might for example be in the same team.
+
+      :arg who: player number of the player to query
+      :type who: :class:`int`
+      :rtype: :class:`boolean`
+*/
+int LuaPlayer::is_attack_forbidden(lua_State* L) {
+	lua_pushboolean(L, get(L, get_egbase(L)).is_attack_forbidden(luaL_checkinteger(L, 2)));
+	return 1;
+}
+
+/* RST
+   .. method:: set_attack_forbidden(who, forbid)
+
+      Sets whether this player is forbidden to attack the player with the specified
+      player number. Note that setting this to `false` does not necessarily mean that this
+      player *can* attack the other player, as they might for example be in the same team.
+
+      :arg who: player number of the player to query
+      :type who: :class:`int`
+      :arg forbid: Whether to allow or forbid attacks
+      :type forbid: :class:`boolean`
+*/
+int LuaPlayer::set_attack_forbidden(lua_State* L) {
+	get(L, get_egbase(L)).set_attack_forbidden(luaL_checkinteger(L, 2), luaL_checkboolean(L, 3));
+	return 0;
+}
+
 /*
  ==========================================================
  C METHODS
 
=== modified file 'src/scripting/lua_game.h'
--- src/scripting/lua_game.h	2019-04-18 16:50:35 +0000
+++ src/scripting/lua_game.h	2019-04-26 16:56:58 +0000
@@ -96,6 +96,8 @@
 	int allow_workers(lua_State* L);
 	int switchplayer(lua_State* L);
 	int get_produced_wares_count(lua_State* L);
+	int set_attack_forbidden(lua_State* L);
+	int is_attack_forbidden(lua_State* L);
 
 	/*
 	 * C methods
 
=== modified file 'src/ui_fsmenu/launch_game.cc'
--- src/ui_fsmenu/launch_game.cc	2019-02-23 11:00:49 +0000
+++ src/ui_fsmenu/launch_game.cc	2019-04-26 16:56:58 +0000
@@ -55,6 +55,11 @@
                              "",
                              UI::DropdownType::kTextual,
                              UI::PanelStyle::kFsMenu),
+
+     peaceful_(this,
+               Vector2i(get_w() * 7 / 10,
+               get_h() * 19 / 40 + buth_),
+               _("Peaceful mode")),
      ok_(this, "ok", 0, 0, butw_, buth_, UI::ButtonStyle::kFsMenuPrimary, _("Start game")),
      back_(this, "back", 0, 0, butw_, buth_, UI::ButtonStyle::kFsMenuSecondary, _("Back")),
      // Text labels
@@ -62,9 +67,12 @@
      // Variables and objects used in the menu
      settings_(settings),
      ctrl_(ctrl),
+     peaceful_mode_forbidden_(false),
      nr_players_(0) {
 	win_condition_dropdown_.selected.connect(
 	   boost::bind(&FullscreenMenuLaunchGame::win_condition_selected, this));
+	peaceful_.changed.connect(
+	   boost::bind(&FullscreenMenuLaunchGame::toggle_peaceful, this));
 	back_.sigclicked.connect(
 	   boost::bind(&FullscreenMenuLaunchGame::clicked_back, boost::ref(*this)));
 	ok_.sigclicked.connect(boost::bind(&FullscreenMenuLaunchGame::clicked_ok, boost::ref(*this)));
@@ -78,6 +86,23 @@
 	delete lua_;
 }
 
+void FullscreenMenuLaunchGame::update_peaceful_mode() {
+	bool forbidden = peaceful_mode_forbidden_ || settings_->settings().scenario || settings_->settings().savegame;
+	peaceful_.set_enabled(!forbidden && settings_->can_change_map());
+	if (forbidden) {
+		peaceful_.set_state(false);
+	}
+	if (settings_->settings().scenario) {
+		peaceful_.set_tooltip(_("The relations between players are set by the scenario"));
+	} else if (settings_->settings().savegame) {
+		peaceful_.set_tooltip(_("The relations between players are set by the saved game"));
+	} else if (peaceful_mode_forbidden_) {
+		peaceful_.set_tooltip(_("The selected win condition does not allow peaceful matches"));
+	} else {
+		peaceful_.set_tooltip(_("Forbid fighting between players"));
+	}
+}
+
 bool FullscreenMenuLaunchGame::init_win_condition_label() {
 	if (settings_->settings().scenario) {
 		win_condition_dropdown_.set_enabled(false);
@@ -190,6 +215,10 @@
 	return t;
 }
 
+void FullscreenMenuLaunchGame::toggle_peaceful() {
+	settings_->set_peaceful_mode(peaceful_.get_state());
+}
+
 // Implemented by subclasses
 void FullscreenMenuLaunchGame::clicked_ok() {
 	NEVER_HERE();
 
=== modified file 'src/ui_fsmenu/launch_game.h'
--- src/ui_fsmenu/launch_game.h	2019-02-23 11:00:49 +0000
+++ src/ui_fsmenu/launch_game.h	2019-04-26 16:56:58 +0000
@@ -26,6 +26,7 @@
 #include "graphic/playercolor.h"
 #include "logic/map.h"
 #include "ui_basic/button.h"
+#include "ui_basic/checkbox.h"
 #include "ui_basic/dropdown.h"
 #include "ui_basic/textarea.h"
 #include "ui_fsmenu/base.h"
@@ -56,6 +57,9 @@
 	/// Creates a blank label/tooltip and returns 'false' otherwise.
 	bool init_win_condition_label();
 
+	/// Enables or disables the peaceful mode checkbox.
+	void update_peaceful_mode();
+
 	/// Loads all win conditions that can be played with the map into the selection dropdown.
 	/// Disables the dropdown if the map is a scenario.
 	void update_win_conditions();
@@ -71,16 +75,21 @@
 	std::unique_ptr<LuaTable> win_condition_if_valid(const std::string& win_condition_script,
 	                                                 std::set<std::string> tags) const;
 
+	void toggle_peaceful();
+
 	uint32_t butw_;
 	uint32_t buth_;
 
 	UI::Dropdown<std::string> win_condition_dropdown_;
+	UI::Checkbox peaceful_;
 	std::string last_win_condition_;
 	UI::Button ok_, back_;
 	UI::Textarea title_;
 	GameSettingsProvider* settings_;
 	GameController* ctrl_;
 
+	bool peaceful_mode_forbidden_;
+
 	Widelands::PlayerNumber nr_players_;
 };
 
 
=== modified file 'src/ui_fsmenu/launch_mpg.cc'
--- src/ui_fsmenu/launch_mpg.cc	2019-02-23 11:00:49 +0000
+++ src/ui_fsmenu/launch_mpg.cc	2019-04-26 16:56:58 +0000
@@ -159,7 +159,7 @@
                UI::PanelStyle::kFsMenu),
      client_info_(this,
                   right_column_x_,
-                  get_h() * 13 / 20 - 2 * label_height_,
+                  get_h() * 15 / 20 - 2 * label_height_,
                   butw_,
                   get_h(),
                   UI::PanelStyle::kFsMenu),
@@ -167,7 +167,8 @@
 
      // Variables and objects used in the menu
      chat_(nullptr) {
-	ok_.set_pos(Vector2i(right_column_x_, get_h() * 12 / 20 - 2 * label_height_));
+	peaceful_.set_pos(Vector2i(right_column_x_, get_h() * 25 / 40 - 2 * label_height_));
+	ok_.set_pos(Vector2i(right_column_x_, get_h() * 14 / 20 - 2 * label_height_));
 	back_.set_pos(Vector2i(right_column_x_, get_h() * 218 / 240));
 	win_condition_dropdown_.set_pos(
 	   Vector2i(right_column_x_, get_h() * 11 / 20 - 2 * label_height_));
@@ -240,6 +241,11 @@
 	if (settings_->can_change_map() && win_condition_dropdown_.has_selection()) {
 		settings_->set_win_condition_script(win_condition_dropdown_.get_selected());
 		last_win_condition_ = win_condition_dropdown_.get_selected();
+
+		std::unique_ptr<LuaTable> t = lua_->run_script(last_win_condition_);
+		t->do_not_warn_about_unaccessed_keys();
+		peaceful_mode_forbidden_ = !t->get_bool("peaceful_mode_allowed");
+		update_peaceful_mode();
 	}
 }
 
@@ -422,6 +428,9 @@
 	change_map_or_save_.set_enabled(settings_->can_change_map());
 	change_map_or_save_.set_visible(settings_->can_change_map());
 
+	update_peaceful_mode();
+	peaceful_.set_state(settings_->is_peaceful_mode());
+
 	if (!settings_->can_change_map() && !init_win_condition_label()) {
 		try {
 			// We do not validate the scripts for the client - it's only a label.
 
=== modified file 'src/ui_fsmenu/launch_spg.cc'
--- src/ui_fsmenu/launch_spg.cc	2019-02-23 11:00:49 +0000
+++ src/ui_fsmenu/launch_spg.cc	2019-04-26 16:56:58 +0000
@@ -166,6 +166,11 @@
 void FullscreenMenuLaunchSPG::win_condition_selected() {
 	if (win_condition_dropdown_.has_selection()) {
 		last_win_condition_ = win_condition_dropdown_.get_selected();
+
+		std::unique_ptr<LuaTable> t = lua_->run_script(last_win_condition_);
+		t->do_not_warn_about_unaccessed_keys();
+		peaceful_mode_forbidden_ = !t->get_bool("peaceful_mode_allowed");
+		update_peaceful_mode();
 	}
 }
 
@@ -217,6 +222,8 @@
 		select_map_.set_visible(settings_->can_change_map());
 		select_map_.set_enabled(settings_->can_change_map());
 
+		peaceful_.set_state(settings_->is_peaceful_mode());
+
 		set_player_names_and_tribes();
 	}
 
@@ -262,6 +269,7 @@
 	safe_place_for_host(nr_players_);
 	settings_->set_map(mapdata.name, mapdata.filename, nr_players_);
 	update_win_conditions();
+	update_peaceful_mode();
 	update(true);
 	return true;
 }
 
=== added file 'test/maps/port_space.wmf/scripting/test_attack_forbidden.lua'
--- test/maps/port_space.wmf/scripting/test_attack_forbidden.lua	1970-01-01 00:00:00 +0000
+++ test/maps/port_space.wmf/scripting/test_attack_forbidden.lua	2019-04-26 16:56:58 +0000
@@ -0,0 +1,38 @@
+run(function()
+   -- Initially, no overrides exist
+   assert_equal(false, p1:is_attack_forbidden(2))
+   assert_equal(false, p2:is_attack_forbidden(1))
+   -- No dumbness checks should take place
+   assert_equal(false, p1:is_attack_forbidden(1))
+   assert_equal(false, p2:is_attack_forbidden(2))
+   assert_equal(false, p1:is_attack_forbidden(3))
+
+   p1:set_attack_forbidden(2, true)
+
+   assert_equal(true, p1:is_attack_forbidden(2))
+   assert_equal(false, p2:is_attack_forbidden(1))
+   assert_equal(false, p1:is_attack_forbidden(3))
+
+   p2:set_attack_forbidden(3, true)
+
+   assert_equal(true, p1:is_attack_forbidden(2))
+   assert_equal(false, p2:is_attack_forbidden(1))
+   assert_equal(false, p1:is_attack_forbidden(3))
+   assert_equal(true, p2:is_attack_forbidden(3))
+
+   p2:set_attack_forbidden(1, true)
+
+   assert_equal(true, p1:is_attack_forbidden(2))
+   assert_equal(true, p2:is_attack_forbidden(1))
+   assert_equal(true, p2:is_attack_forbidden(3))
+
+   p2:set_attack_forbidden(1, false)
+   p1:set_attack_forbidden(2, false)
+
+   assert_equal(false, p2:is_attack_forbidden(1))
+   assert_equal(false, p1:is_attack_forbidden(2))
+   assert_equal(true, p2:is_attack_forbidden(3))
+
+   print("# All Tests passed.")
+   wl.ui.MapView():close()
+end)