Add a setting that controls the amount of captures required to eliminate a team

Author: LoneWolfHT

mods/ctf/ctf_core/init.lua

@@ -2,6 +2,7 @@ ctf_core = {
 	settings = {
 		-- server_mode = minetest.settings:get("ctf_server_mode") or "play",
 		server_mode = minetest.settings:get_bool("creative_mode", false) and "mapedit" or "play",
+		eliminate_team_flag_captures = tonumber(minetest.settings:get("ctf_eliminate_team_flag_captures")) or 1,
 		low_ram_mode = minetest.settings:get("ctf_low_ram_mode") or false,
 	}
 }

mods/ctf/ctf_modebase/features.lua

@@ -424,9 +424,12 @@ local item_levels = {
 
 local delete_queue = {}
 local team_switch_after_capture = false
+local flag_capture_counter = {}
 
 return {
 	on_new_match = function()
+		flag_capture_counter = {}
+
 		team_list = {}
 		for tname in pairs(ctf_map.current_map.teams) do
 			table.insert(team_list, tname)
@@ -603,6 +606,17 @@ return {
 			return worst_players.t
 		end
 	end,
+	base_flag_name = function(flagteam)
+		local eliminate_counter = ""
+		local max = ctf_core.settings.eliminate_team_flag_captures
+
+		if max > 1 then
+			eliminate_counter = "[" .. max - (flag_capture_counter[flagteam] or 0) .. "/" .. max .. "] "
+		end
+
+		return eliminate_counter ..
+				HumanReadable(flagteam) .. "'s flag"
+	end,
 	can_take_flag = function(player, teamname)
 		if not ctf_modebase.match_started then
 			tp_player_near_flag(player)
@@ -704,7 +718,27 @@ return {
 
 		recent_rankings.add(pname, {score = capture_reward, flag_captures = #teamnames})
 
-		teams_left = teams_left - #teamnames
+		local not_finished = {}
+		for _, lost_team in ipairs(teamnames) do
+			local newcapcount = (flag_capture_counter[lost_team] or 0) + 1
+
+			flag_capture_counter[lost_team] = newcapcount
+
+			if newcapcount < ctf_core.settings.eliminate_team_flag_captures then
+				ctf_modebase.restore_flag(lost_team, pname)
+				not_finished[lost_team] = true
+			else
+				teams_left = teams_left - 1
+
+				table.remove(team_list, table.indexof(team_list, lost_team))
+
+				for lost_player in pairs(ctf_teams.online_players[lost_team].players) do
+					team_switch_after_capture = true
+						ctf_teams.allocate_player(lost_player)
+					team_switch_after_capture = false
+				end
+			end
+		end
 
 		if teams_left <= 1 then
 			local capture_text = "Player %s captured"
@@ -726,17 +760,9 @@ return {
 			ctf_modebase.announce(win_text)
 
 			ctf_modebase.start_new_match(5)
-		else
-			for _, lost_team in ipairs(teamnames) do
-				table.remove(team_list, table.indexof(team_list, lost_team))
-
-				for lost_player in pairs(ctf_teams.online_players[lost_team].players) do
-					team_switch_after_capture = true
-						ctf_teams.allocate_player(lost_player)
-					team_switch_after_capture = false
-				end
-			end
 		end
+
+		return not_finished
 	end,
 	on_allocplayer = function(player, new_team)
 		player:set_hp(player:get_properties().hp_max)

mods/ctf/ctf_modebase/flags/huds.lua

@@ -108,7 +108,8 @@ function ctf_modebase.flag_huds.update_player(player)
 	for tname, def in pairs(ctf_map.current_map.teams) do
 		local hud_label = "flag_pos:" .. tname
 
-		local base_label = HumanReadable(tname) .. "'s flag"
+		local base_label = ctf_modebase:get_current_mode().base_flag_name(tname)
+
 		if ctf_modebase.flag_captured[tname] then
 			base_label = base_label .. " (captured)"
 		elseif ctf_modebase.flag_taken[tname] then

mods/ctf/ctf_modebase/flags/taking.lua

@@ -1,31 +1,41 @@
-local function drop_flags(player, pteam)
-	local pname = player:get_player_name()
-	local flagteams = ctf_modebase.taken_flags[pname]
-	if not flagteams then return end
-
-	for _, flagteam in ipairs(flagteams) do
-		ctf_modebase.flag_taken[flagteam] = nil
+function ctf_modebase.restore_flag(flagteam, taker)
+	ctf_modebase.flag_taken[flagteam] = nil
 
-		local fpos = vector.offset(ctf_map.current_map.teams[flagteam].flag_pos, 0, 1, 0)
+	if ctf_modebase.taken_flags[taker] then
+		table.remove(ctf_modebase.taken_flags[taker], table.indexof(ctf_modebase.taken_flags[taker], flagteam))
 
-		minetest.load_area(fpos)
-		local node = minetest.get_node(fpos)
+		if #ctf_modebase.taken_flags[taker] <= 0 then
+			ctf_modebase.taken_flags[taker] = nil
 
-		if node.name == "ctf_modebase:flag_captured_top" then
-			node.name = "ctf_modebase:flag_top_" .. flagteam
-			minetest.set_node(fpos, node)
-		else
-			minetest.log("error", string.format("[ctf_flags] Unable to return flag node=%s, pos=%s",
-				node.name, vector.to_string(fpos))
-			)
+			if player_api.players[taker] then
+				player_api.set_texture(minetest.get_player_by_name(taker), 2, "blank.png")
+			end
 		end
 	end
 
-	if player_api.players[pname] then
-		player_api.set_texture(player, 2, "blank.png")
+	local fpos = vector.offset(ctf_map.current_map.teams[flagteam].flag_pos, 0, 1, 0)
+
+	minetest.load_area(fpos)
+	local node = minetest.get_node(fpos)
+
+	if node.name == "ctf_modebase:flag_captured_top" then
+		node.name = "ctf_modebase:flag_top_" .. flagteam
+		minetest.set_node(fpos, node)
+	else
+		minetest.log("error", string.format("[ctf_flags] Unable to return flag node=%s, pos=%s",
+			node.name, vector.to_string(fpos))
+		)
 	end
+end
 
-	ctf_modebase.taken_flags[pname] = nil
+local function drop_flags(player, pteam)
+	local pname = player:get_player_name()
+	local flagteams = ctf_modebase.taken_flags[pname]
+	if not flagteams then return end
+
+	for _, flagteam in ipairs(table.copy(flagteams)) do
+		ctf_modebase.restore_flag(flagteam, pname)
+	end
 
 	ctf_modebase.skip_vote.on_flag_drop(#flagteams)
 	ctf_modebase:get_current_mode().on_flag_drop(player, flagteams, pteam)
@@ -109,7 +119,15 @@ function ctf_modebase.flag_on_punch(puncher, nodepos, node)
 			ctf_modebase.on_flag_capture(puncher, flagteams)
 
 			ctf_modebase.skip_vote.on_flag_capture(#flagteams)
-			ctf_modebase:get_current_mode().on_flag_capture(puncher, flagteams)
+			local not_finished = ctf_modebase:get_current_mode().on_flag_capture(puncher, flagteams)
+
+			for team in pairs(not_finished) do
+				ctf_modebase.flag_captured[team] = nil
+			end
+
+			for _, player in pairs(minetest.get_connected_players()) do
+				ctf_modebase.flag_huds.update_player(player)
+			end
 		end
 	end
 end

mods/ctf/ctf_modes/ctf_mode_classes/init.lua

@@ -135,6 +135,7 @@ ctf_modebase.register_mode("classes", {
 
 		classes.reset_class_cooldowns(player)
 	end,
+	base_flag_name = features.base_flag_name,
 	can_take_flag = features.can_take_flag,
 	on_flag_take = features.on_flag_take,
 	on_flag_drop = features.on_flag_drop,

mods/ctf/ctf_modes/ctf_mode_classic/init.lua

@@ -64,6 +64,7 @@ ctf_modebase.register_mode("classic", {
 	on_leaveplayer = features.on_leaveplayer,
 	on_dieplayer = features.on_dieplayer,
 	on_respawnplayer = features.on_respawnplayer,
+	base_flag_name = features.base_flag_name,
 	can_take_flag = features.can_take_flag,
 	on_flag_take = features.on_flag_take,
 	on_flag_drop = features.on_flag_drop,

mods/ctf/ctf_modes/ctf_mode_nade_fight/init.lua

@@ -99,6 +99,7 @@ ctf_modebase.register_mode("nade_fight", {
 	on_leaveplayer = features.on_leaveplayer,
 	on_dieplayer = features.on_dieplayer,
 	on_respawnplayer = features.on_respawnplayer,
+	base_flag_name = features.base_flag_name,
 	can_take_flag = features.can_take_flag,
 	on_flag_take = features.on_flag_take,
 	on_flag_drop = features.on_flag_drop,

settingtypes.txt

@@ -10,3 +10,6 @@ ctf_rankings_redis_server_port (Rankings Redis Server Port) int 6379
 # CTF can sometimes reduce CPU usage by calculating things once and putting them in RAM.
 # Turn on low ram mode if you're getting crashes related to RAM/Memory usage
 ctf_low_ram_mode (Low RAM mode) bool false
+
+# Once a team's flag has been captured x times the team's members will be allocated to a new team
+ctf_eliminate_team_flag_captures (Amount of flag captures to eliminate a team) int 1