ATC_Settings = {
	["Capture Incremental"] = true, -- Default: true
		-- Determines if the point counting will be incremental or not. This works like the timer, each
		-- time squad, implacement, captured building in territory adds its own points with each count,
		-- if the check is incremental than these points will be raised each and every check
		-- Note: If check interval is small incremental capturing will go faster
		-- Note: Setting to true disables If Enemy Present Setting!
	["Use squad member count"] = true, -- Default: true
		-- Determines how to use squad member count with the ATC
		-- If set to true squads with 3 members will have 3x capture rate
	["Min points to capture"] = 50, -- Default: 50
		-- Determines what number of points a team needs to have for the territory sector to capture it
		-- Points are counted for different squads, captured buildings and emplacements differently
	["Capture Incremental: neutral on"] = 1, -- Default: 1
		-- Determines when the point becomes neutral
		-- 0 - Never. Enemy team captures only when it has enough points
		-- 1 - If player has less points than min points to capture
		-- 2 - If player has less than 'Capture Incremental: neutral on points' points
	["Capture Incremental: neutral on - points"] = 25, -- Default: 25
		-- See 'Capture Incremental: neutral on'
		-- Note: Shouldn't be bigger than 'Min points to capture'
	["Capture Incremental: max points"] = 1000, -- Default: 1000
		-- The maximum number of points for the sector, so the process of capture doesn't go too slowly
		-- Set to 0 to disable this limit
	["Min points to outnumber to capture"] = 1, -- Default: 1
		-- minimum units needed to outnumber the enemy by to capture the territory on 'If Enemy Present'
		-- set to 3 or 4
	["If no units present in the sector"] = 3, -- Default: 3
		-- Determines what to do when there's no units in the current sector
		-- 0 - Do nothing
		-- 1 - Make neutral if not in supply
		-- 2 - Make neutral
		-- 3 - Increase the points (available only with incremental capture)
	["If no units present in the sector: Increment"] = 0.05, -- Default: 0.05
		-- How many points will be added if there are no units in the sector on
		-- 'If no units present in the sector' set to option 3
		-- You can also use a negative value which would instead make point decrease
	["If no units present in the sector: Min points to decrement to"] = 50, -- Default: 50
		-- If 'If no units present in the sector: Increment' has a negative value it will not go lower
		-- than this ammount of points
	["If Enemy Present"] = 0, -- Default: 0
		-- Determines what to do when there's an enemy in the current sector
		-- 0 - Make neutral if there are more than min units to capture on enemy team in the sector
		-- 1 - Make neutral if there are enemy units in the sector
		-- 2 - Make neutral if there are enemy units in the sector or capture by team having more squads
		--     than other team by 'Min squads to capture' in the sector and having more squads than 'Min
		--     squads to capture'
		-- 3 - Do nothing or capture by team having more squads than other team by 'Min points to
		--     outnumber to capture' in the sector and having more than 'Min points to capture'
		-- 4 - Do nothing. Territory stays owned by its previous owner until all squads and entities of
		--     that team are removed from that sector
	["Capture Secured"] = false, -- Default: false
		-- If enabled, then secured strategic points will also be captured with ATC
	["Secure Structures"] = {
		{EBP.ALLIES.OBSERVATION_POST, {}},
		{EBP.AXIS.OBSERVATION_POST, {}},
		{SBP.CW.HQ, {UPG.CW.MOBILEHQ}},
		{SBP.CW.HQ_REINFORCEMENT, {UPG.CW.MOBILEHQ}},
		{SBP.CW.ARMOUR_HQ, {UPG.CW.MOBILEHQ}},
		{SBP.CW.INFANTRY_HQ, {UPG.CW.MOBILEHQ}},
	},	-- A table of tables of entities or squads and a table of upgrades needed to see if they can
		-- secure with which a sector is secured. If such entity or squad is present in the sector,
		-- has all the upgrades listed and is owned by a team than the sector is considered secured
		-- by that team
	["Exluded Strategic Points"] = {},
		-- a table of strategic points (entity blueprints) NOT included at ATC_FindTerritorySectors.
		-- This might be needed with campaign! Note: VPs are not included automatically
	["Exclude retreating"] = true, -- Default: true
		-- Determines whether to include the retreating squads when counting
	["Exclude in vehicles"] = false, -- Default: false
		-- Determines whether to include squads which are in hold of other squads (vehicles)
	["Exclude in buildings"] = false, -- Default: false
		-- Determines whether to include squads in buildings when counting.
	["Include all in buildings"] = false, -- Default: false
		-- Determines whether to include squads in buildings when counting even if they are not
		-- originally capturers or not
		-- Note: Doesn't work if 'Exclude in buildings' is on
	["Exclude entities"] = false, -- Default: false
		-- Determines whether to include buildings built in the territory sectors when counting.
	["Dynamic information"] = {
		["Show on"] = 4, -- Default: 4
			-- Determines whether to show a text about territory capturing progress when the mouse is on
			-- the Strategic Point.
			-- Note: First 3 settings can't work if the 'Hide strategic points' option is on
			-- 0 - Never
			-- 1 - On mouse over
			-- 2 - On select
			-- 3 - On both mouse over and select
			-- 4 - Show always. About whatever territory the mouse is on
		["Percent"] = true, -- Default: true
			-- If set to true it will show percentage of total capture points instead of points as they are
			-- You might want to play with min points to capture to get an easy percentage number for that
			-- Only for incremental capturing
		["Show max points"] = false, -- Default: false
			-- If set to true additional text ' / *maxpoints*' will be added to the information text
			-- Only for incremental capturing
		["Show enemy points"] = true, -- Default: true
			-- If set to true enemy count in the sector will also be shown
			-- Only for non-incremental capturing
		["Position"] = {0.05, 0.15}, -- Default: {0.05, 0.15}
			-- {x, y} on screen
		["Color"] = {255, 255, 255}, -- Default: {255, 255, 255}
			-- {Red, Green, Blue}
		["Hide delay"] = 0, -- Default: 0
			-- Will hide the info after this amount of seconds (Without updating it!)
	},
	
	--## READ ONLY variables.
	-- Don't be afraid to change them in the file though since they are applied
	-- at game start anyway!
	-- These variables will be updated if they are changed through appropriate functions, but will not
	-- change anything if you change them ingame directly through the ATC_Settings.
	["Check Interval"] = 0.5, -- Default: 0.5
		-- The main ATC check function call interval in seconds
		-- Note: Can't be modified in-game through settings. Use ATC_ChangeCheckInterval(newInterval)
	["Hide strategic points"] = true, -- Default: true
		-- Makes all the strategic points invisible if enabled
		-- Note: Use this instead of making them invisible with Corsix mod studio, or AI will not capture
		-- Note: AI will still be able to build observation points
		-- Note: Can't be modified ingame through settings. Use ATC_SP_Hide(hide)
	["Move SPs up by"] = 0, -- Default: 0
		-- Modifies all the strategic point y positions by this number.
		-- Note: Can't be modified ingame through settings. Use ATC_SP_YPos(pos)
	["SP Copies"] = 1000, -- Default: 1000
		-- If set to false, there will be no copies created.
		-- This can be used in combination with 'Hide strategic points' to disable people from capturing
		-- and seeing strategic points, but keep the strategic point icon on the tactical map.
		-- Note: Not working when 'Hide strategic points' is false
		-- Note: Not tested with ATC_FindTerritorySectors call after the game start. Might put these
		-- copies into ATC and create more CPU usage
		-- Note: Can't be modified in-game through settings. Use ATC_SPCopy_YPos(pos)
	["Capture Time Modifier"] = 1000, -- Default: 1000
		-- Modifies the default capture time for each and every strategic point
		-- Set to high amount to make it work better with incremental capture
		-- Setting to low amount will allow player to capture the sector, but if there are enemies in
		-- the sector and the counter still haven't reached the proper amount the territory will be
		-- captured back by the enemy
		-- Note: Can't be modified ingame through settings. Use ATC_ModifyCaptureTime(modifier)
	["Race Settings"] = {
		-- These are different settings for each army in game used with the code.
		-- Note: Do not update these settings through this table ingame. These settings are
		-- automatically copied for each player at the game start. That table is indexed by player indexes,
		-- so you can find needed player there with World_GetPlayerIndex or World_GetPlayerCount
		-- 
		-- ## Some explanations:
		--    Index (TRACE_ALLIES, TRACE_AXIS..)
		-- This is the race name to find the race by. You can find these at luaconsts.scar
		--    'Extra Included Squads'
		-- a table of squads included when counting capture points no matter that they can't
		-- originally capture (you can also include all the tanks here)
		--    'Excluded Squads'
		-- a table of squad blueprints that will not be included when counting capture points.
		-- Note: Squads that originally can't capture will also be skipped, unless they are in
		-- the included squads table
		--    'Excluded Entities'
		-- a table of entity blueprints that will not be included when counting capture points.
		--    'Capturing Rate Multiplier'
		-- Multiplier applied to squad capture rate if it is capturing the strategic point.
		-- Note: If you have the invisible SPs on, then AI will still be able to capture.
		-- You might want to set it to 1 to play it fair, but you might just aswell want the
		-- multiplier left as it is to help out AI capture faster
		--    'Squad Capture Rate'
		-- How fast will this race squads capture.
		--    'In Building Squad Capture Rate'
		-- How much faster will this race squads in buildings (modifier)
		--    'Entity Capture Rate'
		-- How fast will this race entities capture.
		--    'Special Squads'
		-- A table indexed by squad blueprints containing a modifier of capture rate for the squad
		-- Example: [SBP.ALLIES.JEEP] = 0.5,
		--    'Special Entities'
		-- A table indexed by entity blueprints containing a modifier of capture rate for the entity
		-- Example: [EBP.ALLIES.MG_NEST] = 2,
		-- 
		[TRACE_ALLIES] = {
			["Excluded Squads"] = {
				SBP.ALLIES.SNIPER,
			},
			["Excluded Entities"] = {
				EBP.ALLIES.MINES,
				EBP.ALLIES.MINES_RIFLEMEN,
				EBP.ALLIES.TANK_TRAP_RIFLEMEN,
				EBP.ALLIES.TANK_TRAP,
				EBP.ALLIES.SANDBAG_RIFLEMEN,
				EBP.ALLIES.SANDBAG,
				EBP.ALLIES.BARBED_WIRE_RIFLEMEN,
				EBP.ALLIES.BARBED_WIRE,
			},
			["Extra Included Squads"] = {
				SBP.ALLIES.JEEP,
			},
			["Capturing Rate Multiplier"] = 2,
			["Squad Capture Rate"] = 1,
			["In Hold Squad Capture Rate"] = 1.5,
			["Entity Capture Rate"] = 5,
			["Special Squads"] = {
			},
			["Special Entities"] = {
			},
		},
		[TRACE_AXIS] = {
			["Extra Included Squads"] = {
				SBP.AXIS.MOTORCYCLE,
			},
			["Exluded Squads"] = {
				SBP.AXIS.SNIPER,
				SBP.AXIS.OFFICER,
			},
			["Excluded Entities"] = {
				EBP.AXIS.TANK_TRAP,
				EBP.AXIS.SANDBAG,
				EBP.AXIS.MINES,
				EBP.AXIS.BARBED_WIRE,
			},
			["Capturing Rate Multiplier"] = 2,
			["Squad Capture Rate"] = 1,
			["In Hold Squad Capture Rate"] = 1.5,
			["Entity Capture Rate"] = 5,
			["Special Squads"] = {
			},
			["Special Entities"] = {
			},
		},
		[TRACE_ALLIES_COMMONWEALTH] = {
			["Extra Included Squads"] = {
				SBP.CW.COMMAND_CROMWELL,
			},
			["Exluded Squads"] = {
			},
			["Excluded Entities"] = {
				EBP.CW.DEMOLITION_CHARGE,
				EBP.CW.MINES,
				EBP.CW.SANDBAG,
				EBP.CW.BARBED_WIRE,
				EBP.CW.RADIO_BEACON,
				EBP.CW.SLITTRENCH_NEST,
			},
			["Capturing Rate Multiplier"] = 2,
			["Squad Capture Rate"] = 0.8,
			["In Hold Squad Capture Rate"] = 1.5,
			["Entity Capture Rate"] = 4,
			["Special Squads"] = {
				[SBP.CW.COMMAND_CROMWELL] = 1.5,
			},
			["Special Entities"] = {
			},
		},
		[TRACE_AXIS_PANZER_ELITE] = {
			["Extra Included Squads"] = {
			},
			["Exluded Squads"] = {
			},
			["Excluded Entities"] = {
				EBP.ELITE.BARBED_WIRE,
				EBP.ELITE.MINE_TELLER,
				EBP.ELITE.MINE_AIR_DROPPED,
				EBP.ELITE.SANDBAG,
				EBP.ELITE.TANK_TRAP,
			},
			["Capturing Rate Multiplier"] = 2,
			["Squad Capture Rate"] = 1.25,
			["In Hold Squad Capture Rate"] = 1.5,
			["Entity Capture Rate"] = 5,
			["Special Squads"] = {
			},
			["Special Entities"] = {
			},
		}
	},
	["Upgrades"] = {
		-- These are different settings for each army in game used with the code.
		-- This table will allow checking for player upgrades and change anything from the
		-- 'Race Settings' table for each player separately.
		-- Note: Only player upgrades are checked, NOT entity or squad or any other upgrades
		-- Note: Do not update these settings through this table in-game. These settings are
		-- automatically copied for each player at the game start. That table is indexed by player indexes,
		-- so you can find needed player there with World_GetPlayerIndex or World_GetPlayerCount
		-- 
		--### Some explanations:
		--    Index (TRACE_ALLIES, TRACE_AXIS..)
		-- This is the racename to find the race by. You can find these at luaconsts.scar
		-- 
		-- The table itself consists of more tables with separate upgrades.
		-- Each upgrade can have these settings (* - required for the upgrade to work):
		-- 
		-- For more information see upgradesystem.scar
		-- 
		[TRACE_ALLIES] = {
			{ -- Upgrades the Jeep capture rate with the Resource 2 or Armored doctrine upgrades
				["requirements_operation"] = UpgradeSystem_OPERATION_OR,
				["requirements"] = {
					{UpgradeSystem_PlayerUpgrade, BP_GetUpgradeBlueprint("upgrade/allies/allies_resource_upgrade_advanced.lua")},
					{UpgradeSystem_PlayerUpgrade, UPG.COMMANDER_TREE.ALLIES.ARMOR},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_TABLEACTION, {
						["index"]="Special Squads",
						["actions"] = {
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.ALLIES.JEEP, ["value"] = 1.5}},
						},
					}},
				},
			},
			{ -- Enables sniper capturing with Infantry Doctrine or Airborne + Resource 2 upgrades
				["requirements_operation"] = UpgradeSystem_OPERATION_OR,
				["requirements"] = {
					{UpgradeSystem_PlayerUpgrade, UPG.COMMANDER_TREE.ALLIES.INFANTRY},
					{UpgradeSystem_PlayerUpgrade,
						{BP_GetUpgradeBlueprint("upgrade/allies/allies_resource_upgrade_advanced.lua"), UPG.COMMANDER_TREE.ALLIES.AIRBORNE}},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_TABLEACTION, {

						["index"] = "Excluded Squads",
						["actions"] = {
							{UpgradeSystem_ACTION_REMOVEVALUE,
								{["find"]=true,["find_value"]=SBP.ALLIES.SNIPER}},
						}
					}},
				},
			},
		},
		[TRACE_AXIS] = {
			{ -- If there's an officer in the field, all units capture faster
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, SBP.AXIS.OFFICER},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"] = UpgradeSystem_ACTION_UPDATEVALUE_ADD,
						["value"] = 0.5,
					}},
				},
			},
		},
		[TRACE_ALLIES_COMMONWEALTH] = {
			{ -- Units capture faster if there are more lieutenants on the field. All 3 upgrades are the same, just unit count differs
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, SBP.CW.LIEUTENANT},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"] = UpgradeSystem_ACTION_UPDATEVALUE_ADD,
						["value"] = 0.1,
					}},
				},
			},
			{
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, {SBP.CW.LIEUTENANT, 2}},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"] = UpgradeSystem_ACTION_UPDATEVALUE_ADD,
						["value"] = 0.1,
					}},
				},
			},
			{
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, {SBP.CW.LIEUTENANT, 3}},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"] = UpgradeSystem_ACTION_UPDATEVALUE_ADD,
						["value"] = 0.1,
					}},
				},
			},
			{ -- Units capture faster if there's a captain on the field
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, SBP.CW.CAPTAIN},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"] = UpgradeSystem_ACTION_UPDATEVALUE_ADD,
						["value"] = 0.3,
					}},
				},
			},
			{ -- Tanks slowly capture if there's a cromwell command tank on the field
				["validate"] = true,
				["requirements"] = {
					{UpgradeSystem_Player_HasSquad, SBP.CW.COMMAND_CROMWELL},
				},
				["actions"] = {
					{UpgradeSystem_ACTION_TABLEACTION, {
						["index"]="Special Squads",
						["actions"] = {
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.BREN_CARRIER, ["value"] = 0.1}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.CHURCHILL_AVRE, ["value"] = 0.7}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.CHURCHILL_CROC, ["value"] = 0.7}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.CHURCHILL, ["value"] = 0.7}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.CHURCHILL_SP_CAEN, ["value"] = 0.7}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.CROMWELL, ["value"] = 0.5}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.STUART, ["value"] = 0.25}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.PRIEST, ["value"] = 0.1}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.FIREFLY, ["value"] = 0.6}},
							{UpgradeSystem_ACTION_UPDATEVALUE_SET,
								{["index"] = SBP.CW.TETRARCH, ["value"] = 0.2}},
						},
					}},
					{UpgradeSystem_ACTION_TABLEACTION, {
						["index"]="Extra Included Squads",
						["actions"] = {
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.BREN_CARRIER},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.CHURCHILL_AVRE},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.CHURCHILL_CROC},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.CHURCHILL},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.CHURCHILL_SP_CAEN},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.CROMWELL},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.STUART},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.PRIEST},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.FIREFLY},
							{UpgradeSystem_ACTION_ADDTONUMERICTABLE, SBP.CW.TETRARCH},
						},
					}},
				},
			},
		},
		[TRACE_AXIS_PANZER_ELITE] = {
			{ -- Makes Panzer Grenadiers capture faster with their capture rate upgrade
				["requirements"]={
					{UpgradeSystem_PlayerUpgrade, UPG.ELITE.CAPTURE_RATE},
				},
				["actions"]={
					{UpgradeSystem_ACTION_UPDATEVALUE, {
						["index"]="Squad Capture Rate",
						["operation"]=UpgradeSystem_ACTION_UPDATEVALUE_MULTIPLY,
						["value"]=1.5,
					}},
				},
			},
		}
	}
}

			elseif ATC_Settings["Sector - If Enemy Present"] == 2 then
				if (ATC_TerritorySquads[i][1] > 0 and ATC_TerritorySquads[i][2] > 0)
						and ((not ATC_TerritorySquads[i][1] >= ATC_Settings["Sector - Min squads to capture"]
						and not ATC_TerritorySquads[i][2] >= ATC_Settings["Sector - Min squads to capture"])
						or ATC_TerritorySquads[i][1] == ATC_TerritorySquads[i][2]) then
					Entity_SetStrategicPointNeutral(sp)
				elseif ATC_TerritorySquads[i][1] >= ATC_Settings["Sector - Min squads to capture"] and ATC_TerritorySquads[i][1] > ATC_TerritorySquads[i][2] then
					Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(0)))
				elseif ATC_TerritorySquads[i][2] >= ATC_Settings["Sector - Min squads to capture"] then
					Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(1)))
				end
			elseif ATC_Settings["Sector - If Enemy Present"] == 2 then
				if ATC_TerritorySquads[i][1] >= ATC_Settings["Sector - Min squads to capture"] and ATC_TerritorySquads[i][1] > ATC_TerritorySquads[i][2] then
					Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(0)))
				elseif ATC_TerritorySquads[i][2] >= ATC_Settings["Sector - Min squads to capture"] then
					Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(1)))
				end
			end

["Potentially Included Squads"] = {
	{ SBP.ALLIES.SNIPER,
		{ "or", { "playerupgrade", "upg.something" }, 
			{ "and", { "squadupgrade", "upg.somethingelse"}, {"squadupgrade", "upg.somethingother" } } 
	},
}

["Sector - If no units present in the sector"]

if ATC_TerritorySquads[i][1] > 0 and ATC_TerritorySquads[i][2] > 0 then

function ATC_Check()
	ATC_UpdateData()
	
	local i
	for i=1,table.getn(ATC_TerritorySquads) do
		local sp = ATC_StrategicPoints[i]
		local sp_neutral = World_OwnsEntity(sp)
		if ATC_TerritorySquads[i][1] >= ATC_Settings["Sector - Min squads to capture"] and ATC_TerritorySquads[i][2] == 0 then
			Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(0)))
		elseif ATC_TerritorySquads[i][2] >= ATC_Settings["Sector - Min squads to capture"] and ATC_TerritorySquads[i][1] == 0 then 
			Entity_InstantCaptureStrategicPoint(sp, Table_GetRandomItem(Team_GetPlayers(1)))
		end		
	end
end

 				and not World_IsInSupply( Table_GetRandomItem(Team_GetPlayers( Player_GetTeam(Entity_GetPlayerOwner(sp)) )), Entity_GetPosition(sp))) ) then

UpgradeSystem_OPERATION_AND = "and"
UpgradeSystem_OPERATION_OR = "or"
UpgradeSystem_REQUIREMENT_BINARY = "binary"
UpgradeSystem_REQUIREMENT_SCARFUNC = "scarfunc"
UpgradeSystem_REQUIREMENT_UPGRADE_ENTITY = "entity_upgrade"
UpgradeSystem_REQUIREMENT_UPGRADE_SQUAD = "squad_upgrade"
UpgradeSystem_REQUIREMENT_UPGRADE_PLAYER = "player_upgrade"
UpgradeSystem_ACTION_UPDATEVALUE = "updatevalue"
UpgradeSystem_ACTION_SCARFUNC = "scarfunc"
UpgradeSystem_ACTION_REQUIREMENTACTION = "requirement_action"
UpgradeSystem_ACTION_UPDATEVALUE_SET = "set"
UpgradeSystem_ACTION_UPDATEVALUE_MULTIPLY = "multiply"
UpgradeSystem_ACTION_UPDATEVALUE_ADD = "add"

UpgradeSystem_List = {
	["test"] = {
		value = 0,
		entity = nil,
		squad = nil,
		player = nil,
		requirements = {
			operation = UpgradeSystem_OPERATION_AND,
			UpgradeSystem_REQUIREMENT_BINARY = {
				operation = UpgradeSystem_OPERATION_OR, 
				requirement_table_1 = {
					
				},
				requirement_table_2 = {
					
				},
			},
			UpgradeSystem_REQUIREMENT_SCARFUNC = {
				func = TestCheckFunc,
				args = {
					"testarg1",
					"testarg2",
				},
			},
			UpgradeSystem_REQUIREMENT_UPGRADE_ENTITY = {
				
			},
			UpgradeSystem_REQUIREMENT_UPGRADE_SQUAD = {
			
			},
			UpgradeSystem_REQUIREMENT_UPGRADE_PLAYER = {
			
			},
		},
		actions = {
			UpgradeSystem_ACTION_REQUIREMENTACTION = {
				actions = {},
				requirements = {},
			},
			UpgradeSystem_ACTION_SCARFUNC = {
				func = TestActionFunc,
				args = {
					"testactionarg1",
					"testactionarg2",
				},
			},
			UpgradeSystem_ACTION_UPDATEVALUE = {
				action = UpgradeSystem_ACTION_UPDATEVALUE_SET,
				value = 1,
			},
		},
	},
}

--
--[[ ATC -- Automatic Territory Capture v1.3 beta ]]--
--
-- Coded by AGameAnx at 08-05-2008
-- Modified by JarHead
--
-- To use this code:
-- 1. Put this file to your data/scar folder
-- 2. Open data/scar/scarutil.scar file
-- 3. Put import("atc.scar") into the new line in there (change the *filename* to the name of this file)
-- 4. Modify settings (use line 123 to change the check interval)
-- 

-- Note: To dynamically change the interval for ATC_Check use Rule_ChangeInterval(ATC_Check, *your interval in seconds*)

CaptureSector_Settings = {
	["If Enemy Present"] = 2, -- Default: 0
		-- Determines what to do when there's an enemy in the current sector
		-- 0 - Make neutral if there are more than min units to capture of both teams in the sector
		-- 1 - Make neutral if there are enemy units in the sector
		-- 2 - Do nothing. Territory stays owned by its previous owner until all squads of that team are
		--     removed from that sector
	["If no units present in the sector"] = 0, -- Default: 0
		-- Determines what to do when there's no units in the current sector
		-- 0 - Do nothing
		-- 1 - Make neutral if not in supply
		-- 2 - Make neutral}
	["Min squads to capture"] = 1, -- Default: 1
		-- Determines what number of points a team needs to have for the territory sector to capture it
		-- Points are counted for different squads, captured buildings and emplacements differently
	["Sector allocation"] = 0, -- Default: 0
		-- Determines what to do when a sector is captured
		-- 0 - Allocated to winning player
		-- 1 - Random allocation to winning team
}

function CaptureSector_Init()

	Rule_AddInterval(CaptureSector_Update, 2)
	
	CaptureSector_SquadsPerSector = {}

	for i=1,World_GetPlayerCount() do
		CaptureSector_SquadsPerSector[i] = {0,0}
	end

	CaptureSector_TerritorySectors = {}

	Rule_AddOneShot(World_FindTerritorySectors, 1)

end

Scar_AddInit(CaptureSector_Init)

function CaptureSector_Update()

	CaptureSector_RefreshData()

	for i=1,table.getn(CaptureSector_SquadsPerSector) do
		local sector = CaptureSector_TerritorySectors[i][1]
		local neutralsector = World_OwnsEntity(sector)
		local team1count = 0
		local team2count = 0
		for j=1,World_GetPlayerCount() do
			local player = World_GetPlayerAt(j)
			if Player_GetTeam(player) == 0 then
				team1count = team1count + CaptureSector_SquadsPerSector[i][j][1] + CaptureSector_SquadsPerSector[i][j][2]
			elseif Player_GetTeam(player) == 1 then
				team2count = team2count + CaptureSector_SquadsPerSector[i][j][1] + CaptureSector_SquadsPerSector[i][j][2]
			end
		end
		if team1count > 0 and team2count > 0 then
			if not neutralsector and ((CaptureSector_Settings["If Enemy Present"] == 0 and not neutralsector and team1count >= CaptureSector_Settings["Min squads to capture"] and team2count >= CaptureSector_Settings["Min squads to capture"]) or CaptureSector_Settings["If Enemy Present"] == 1) then
				Entity_SetStrategicPointNeutral(sector)
			end
		elseif team1count >= CaptureSector_Settings["Min squads to capture"] then
			if CaptureSector_Settings["Sector allocation"] == 0 then
				local count = 0
				local player
				for j=1,World_GetPlayerCount() do
					local playercount = 0
					if Player_GetTeam(World_GetPlayerAt(j)) == 0 then
						playercount = CaptureSector_SquadsPerSector[i][j][1] + CaptureSector_SquadsPerSector[i][j][2]
						if playercount >= count then
							count = playercount
							player = World_GetPlayerAt(j)
						end
					end
				end
				Entity_InstantCaptureStrategicPoint(sector, player)
			elseif CaptureSector_Settings["Sector allocation"] == 1 then
				Entity_InstantCaptureStrategicPoint(sector, Table_GetRandomItem(Team_GetPlayers(0)))
			end
		elseif team2count >= CaptureSector_Settings["Min squads to capture"] then
			if CaptureSector_Settings["Sector allocation"] == 0 then
				local count = 0
				local player
				for j=1,World_GetPlayerCount() do
					local playercount = 0
					if Player_GetTeam(World_GetPlayerAt(j)) == 1 then
						playercount = CaptureSector_SquadsPerSector[i][j][1] + CaptureSector_SquadsPerSector[i][j][2]
						if playercount >= count then
							count = playercount
							player = World_GetPlayerAt(j)
						end
					end
				end
				Entity_InstantCaptureStrategicPoint(sector, player)
			elseif CaptureSector_Settings["Sector allocation"] == 1 then
				Entity_InstantCaptureStrategicPoint(sector, Table_GetRandomItem(Team_GetPlayers(1)))
			end
		end
		if not World_OwnsEntity(sector) and CaptureSector_SquadsPerSector[i][Player_GetTeam(Entity_GetPlayerOwner(sector))+1][1] < 1 and (CaptureSector_Settings["If no units present in the sector"] == 2 or (CaptureSector_Settings["If no units present in the sector"] == 1 and not World_IsInSupply( Table_GetRandomItem(Team_GetPlayers( Player_GetTeam(Entity_GetPlayerOwner(sector)) )), Entity_GetPosition(sector))) ) then
			Entity_SetStrategicPointNeutral(sector)
		end
	end

end

function CaptureSector_RefreshData()

	for i=1,table.getn(CaptureSector_TerritorySectors) do
		CaptureSector_SquadsPerSector[i] = {}
		for j=1,World_GetPlayerCount() do
			CaptureSector_SquadsPerSector[i][j] = {0,0}
		end
	end
	for i=1,World_GetPlayerCount() do
		local player = World_GetPlayerAt(i)
		local team = Player_GetTeam(player)+1
		for j=1,table.getn(CaptureSector_TerritorySectors) do
			sector = CaptureSector_TerritorySectors[j][1]
			if (not World_OwnsEntity(sector) and Player_GetTeam(Entity_GetPlayerOwner(sector)) == team-1)then
				local sg = SGroup_CreateIfNotFound("CaptureSector_SquadsPerSector["..j.."]["..i.."]")
				SGroup_Clear(sg)
				World_GetSquadsWithinTerritorySector( player, sg, World_GetTerritorySectorID( Entity_GetPosition(sector) ), OT_Player)
				local eg = EGroup_CreateIfNotFound("CaptureSector_PlayerMembersPerSector["..j.."]["..i.."]")
				EGroup_Clear(eg)
				World_GetEntitiesWithinTerritorySector( player, eg, World_GetTerritorySectorID( Entity_GetPosition(sector) ), OT_Player)
				World_GetEntitiesWithinTerritorySector( player, eg, World_GetTerritorySectorID( Entity_GetPosition(sector) ), OT_Neutral)
				local squadscount = 0
				local entitiescount = 0
				entitiescount,squadscount = EGroup_MembersCount(eg, sector)
				squadscount = squadscount + SGroup_MembersCount(sg, sector)
				CaptureSector_SquadsPerSector[j][i][1] = squadscount
				CaptureSector_SquadsPerSector[j][i][2] = entitiescount
			end
		end
	end
	
end

function SGroup_MembersCount(sgroup, sector)

	local sg = SGroup_CreateIfNotFound("temp")
	SGroup_Clear(sg)
	for i=1,SGroup_Count(sgroup) do
		local squad = SGroup_GetSpawnedSquadAt(sgroup, i)
		if Squad_IsCapturer(squad, sector) then
			SGroup_Add(sg,squad)
		end
	end
	return SGroup_TotalMembersCount(sg)
	
end

function EGroup_MembersCount(egroup, sector)

	local count = 0
	local count_squads = 0
	for i=1,EGroup_Count(egroup) do
		local entity = EGroup_GetSpawnedEntityAt(egroup, i)
		local held = SGroup_CreateIfNotFound("temp")
		SGroup_Clear(held)
		if not World_OwnsEntity(entity) then
			count = count + 1
			if Entity_GetSquadsHeld(entity, held) then
				count_squads = count_squads + SGroup_MembersCount(held, sector)
			end
		end
	end
	return count,count_squads
	
end

function Squad_IsCapturer(squad, sector)

	if Squad_IsRetreating(squad) then
		return false
	end
	return Squad_CanCaptureStrategicPoint(squad, sector)
	
end

function World_FindTerritorySectors()

	for i=0,World_GetNumEntities()-1 do
		e = World_GetEntity(i)
		if Entity_IsStrategicPoint(e) and not Entity_IsVictoryPoint(e) then
			CaptureSector_TerritorySectors[table.getn(CaptureSector_TerritorySectors)+1] = {e,0}
			Entity_SimHide(e, true)
		end
	end
	
end

if ATC_Settings["Capture Secured"] or not secured[j] then

		local sp_neutral = World_OwnsEntity(sp)
		if not sp_neutral then
			local owner = Player_GetTeam(Entity_GetPlayerOwner(sp))
			local enemy = Team_GetEnemyTeam(owner)
			if ATC_TerritorySquads[i][owner+1][1] < 1 
					and (ATC_Settings["If no units present in the sector"] == 2
					or (ATC_Settings["If no units present in the sector"] == 1
					and not World_IsInSupply( Table_GetRandomItem(Team_GetPlayers(owner)), Entity_GetPosition(sp))) ) then
				Entity_SetStrategicPointNeutral(sp)
			end
		end