-- data:extend(
-- {
-- 	{
-- 		type='map-settings',
-- 		name='map-settings',
-- 		pollution=
-- 		{
-- 			enabled=true,
-- 			-- these are values for 60 ticks (1 simulated second)
-- 			--
-- 			-- amount that is diffused to neighboring chunk
-- 			-- (possibly repeated for other directions as well)
-- 			diffusion_ratio=0.02,
-- 			-- this much PUs must be on the chunk to start diffusing
-- 			min_to_diffuse=15,
-- 			-- constant modifier a percentage of 1 - the pollution eaten by a chunks tiles
-- 			ageing=1,
-- 			-- anything bigger than this is visualised as this value
-- 			expected_max_per_chunk=150,
-- 			-- anything lower than this (but > 0) is visualised as this value
-- 			min_to_show_per_chunk=50,
-- 			min_pollution_to_damage_trees = 60,
-- 			pollution_with_max_forest_damage = 150,
-- 			pollution_per_tree_damage = 50,
-- 			pollution_restored_per_tree_damage = 10,
-- 			max_pollution_to_restore_trees = 20,
-- 			enemy_attack_pollution_consumption_modifier = 1
-- 		},

-- 		enemy_evolution=
-- 		{
-- 			enabled=true,
-- 			-- percentual increase in the evolve factor for every second (60 ticks)
-- 			time_factor = 0.000004,
-- 			-- percentual increase in the evolve factor for every destroyed spawner
-- 			destroy_factor = 0.002,
-- 			-- percentual increase in the evolve factor for 1 pollution unit
-- 			pollution_factor = 0.0000009
-- 		},

-- 		enemy_expansion=
-- 		{
-- 			enabled = true,
-- 			-- Distance in chunks from the furthest base around.
-- 			-- This prevents expansions from reaching too far into the
-- 			-- player's territory
-- 			max_expansion_distance = 7,

-- 			friendly_base_influence_radius = 2,
-- 			enemy_building_influence_radius = 2,

-- 			-- A candidate chunk's score is given as follows:
-- 			--	 player = 0
-- 			--	 for neighbour in all chunks within enemy_building_influence_radius from chunk:
-- 			--		 player += number of player buildings on neighbour
-- 			--						 * building_coefficient
-- 			--						 * neighbouring_chunk_coefficient^distance(chunk, neighbour)
-- 			--
-- 			--	 base = 0
-- 			--	 for neighbour in all chunk within friendly_base_influence_radius from chunk:
-- 			--		 base += num of enemy bases on neighbour
-- 			--					 * other_base_coefficient
-- 			--					 * neighbouring_base_chunk_coefficient^distance(chunk, neighbour)
-- 			--
-- 			--	 score(chunk) = 1 / (1 + player + base)
-- 			--
-- 			-- The iteration is over a square region centered around the chunk for which the calculation is done,
-- 			-- and includes the central chunk as well. distance is the Manhattan distance, and ^ signifies exponentiation.
-- 			building_coefficient = 0.1,
-- 			other_base_coefficient = 2.0,
-- 			neighbouring_chunk_coefficient = 0.5,
-- 			neighbouring_base_chunk_coefficient = 0.4,

-- 			-- A chunk has to have at most this much percent unbuildable tiles for it to be considered a candidate.
-- 			-- This is to avoid chunks full of water to be marked as candidates.
-- 			max_colliding_tiles_coefficient = 0.9,

-- 			-- Size of the group that goes to build new base (in game this is multiplied by the
-- 			-- evolution factor).
-- 			settler_group_min_size = 5,
-- 			settler_group_max_size = 20,

-- 			-- Ticks to expand to a single
-- 			-- position for a base is used.
-- 			--
-- 			-- cooldown is calculated as follows:
-- 			--	 cooldown = lerp(max_expansion_cooldown, min_expansion_cooldown, -e^2 + 2 * e),
-- 			-- where lerp is the linear interpolation function, and e is the current evolution factor.
-- 			min_expansion_cooldown = 4 * 3600,
-- 			max_expansion_cooldown = 60 * 3600
-- 		},

-- 		unit_group=
-- 		{
-- 			-- pollution triggered group waiting time is a random time between min and max gathering time
-- 			min_group_gathering_time = 3600,
-- 			max_group_gathering_time = 10 * 3600,
-- 			-- after the gathering is finished the group can still wait for late members,
-- 			-- but it doesn't accept new ones anymore
-- 			max_wait_time_for_late_members = 2 * 3600,
-- 			-- limits for group radius (calculated by number of numbers)
-- 			max_group_radius = 30.0,
-- 			min_group_radius = 5.0,
-- 			-- when a member falls behind the group he can speedup up till this much of his regular speed
-- 			max_member_speedup_when_behind = 1.4,
-- 			-- When a member gets ahead of its group, it will slow down to at most this factor of its speed
-- 			max_member_slowdown_when_ahead = 0.6,
-- 			-- When members of a group are behind, the entire group will slow down to at most this factor of its max speed
-- 			max_group_slowdown_factor = 0.3,
-- 			-- If a member falls behind more than this times the group radius, the group will slow down to max_group_slowdown_factor
-- 			max_group_member_fallback_factor = 3,
-- 			-- If a member falls behind more than this time the group radius, it will be removed from the group.
-- 			member_disown_distance = 10,
-- 			tick_tolerance_when_member_arrives = 60,

-- 			-- Maximum number of automatically created unit groups gathering for attack at any time.
-- 			max_gathering_unit_groups = 30,

-- 			-- Maximum size of an attack unit group. This only affects automatically-created unit groups;
-- 			-- manual groups created through the API are unaffected.
-- 			max_unit_group_size = 200
-- 		},

-- 		steering=
-- 		{
-- 			default=
-- 			{
-- 				-- not including the radius of the unit
-- 				radius = 1.2,
-- 				separation_force = 0.005,
-- 				separation_factor = 1.2,
-- 				force_unit_fuzzy_goto_behavior = false
-- 			},
-- 			moving=
-- 			{
-- 				radius = 3,
-- 				separation_force = 0.01,
-- 				separation_factor = 3,
-- 				-- used only for special 'to look good' purposes (like in trailer)
-- 				force_unit_fuzzy_goto_behavior = false
-- 			}
-- 		},

-- 		path_finder=
-- 		{
-- 			-- defines whether we prefer forward (>1) or backward (<-1) or symmetrical (1) search
-- 			fwd2bwd_ratio = 1,
-- 			-- when comparing nodes in open which one to check next
-- 			-- heuristic value is multiplied by this ratio
-- 			-- the higher the number the more is the search directed directly towards the goal
-- 			goal_pressure_ratio = 2,
-- 			-- How many nodes can be expanded at most per tick.
-- 			max_steps_worked_per_tick = 1000,
-- 			-- How much work each patfinding job is allowed to do per tick.
-- 			max_work_done_per_tick = 8000,
-- 			-- path cache setings
-- 			use_path_cache = true,
-- 			-- number of elements in the cache
-- 			short_cache_size = 5,
-- 			long_cache_size = 25,
-- 			-- minimal distance to goal for path to be searched in short path cache
-- 			short_cache_min_cacheable_distance = 10,
-- 			-- minimal number of algorithm steps for path to be inserted into the short path cache
-- 			short_cache_min_algo_steps_to_cache = 50,
-- 			-- minimal distance to goal for path to be searched in long path cache
-- 			long_cache_min_cacheable_distance = 30,
-- 			-- when searching for connection to path cache path, search at most for this number of steps times the initial estimate
-- 			cache_max_connect_to_cache_steps_multiplier = 100,
-- 			-- when looking for path from cache make sure it doesn't start too far from requested start in relative distance terms
-- 			cache_accept_path_start_distance_ratio = 0.2,
-- 			-- when looking for path from cache make sure it doesn't end too far from requested end
-- 			-- this is typically higher than accept value for the start because the end target can be moving
-- 			cache_accept_path_end_distance_ratio = 0.15,
-- 			-- Same as cache_accept_path_start_distance_ratio, but used for negative cache queries
-- 			negative_cache_accept_path_start_distance_ratio = 0.3,
-- 			-- Same as cache_accept_path_end_distance_ratio, but used for negative cache queries
-- 			negative_cache_accept_path_end_distance_ratio = 0.3,
-- 			-- when assigning rating to the best path this * start distances is considered
-- 			cache_path_start_distance_rating_multiplier = 10,
-- 			-- when assigning rating to the best path this * end distances is considered
-- 			-- this is typically higher than value for the start to achieve better path end quality
-- 			cache_path_end_distance_rating_multiplier = 20,

-- 			-- somewhere along the path is stuck enemy we need to avoid
-- 			-- this is mainly to handle situations when units have arrived and are attacking the target
-- 			-- then units further in the back will use this and run around the target
-- 			stale_enemy_with_same_destination_collision_penalty = 30,
-- 			-- if there is a moving unit further than this we don't really care
-- 			ignore_moving_enemy_collision_distance = 5,
-- 			-- enemy is not moving/or is too close and has different destination
-- 			enemy_with_different_destination_collision_penalty = 30,
-- 			-- simplification for now - collision with everything else is this
-- 			general_entity_collision_penalty = 10,
-- 			-- collision penalty for successors of positions that require destroy to reach
-- 			general_entity_subsequent_collision_penalty = 3,
-- 			-- Collision penalty for collisions in the extended bounding box but outside the entity's actual bounding box
-- 			extended_collision_penalty = 3,
-- 			-- uptil this amount any client will be served by the path finder (no estimate on the path length)
-- 			max_clients_to_accept_any_new_request = 10,
-- 			-- from max_clients_to_accept_any_new_request till this one only those that have a short estimate will be served
-- 			max_clients_to_accept_short_new_request = 100,
-- 			-- this is the 'threshold' to decide what is short and what is not
-- 			direct_distance_to_consider_short_request = 100,
-- 			-- if a short request takes more than this many steps, it will be rescheduled as a long request
-- 			short_request_max_steps = 1000,
-- 			-- How many steps will be allocated to short requests each tick, as a ratio of all available steps per tick
-- 			short_request_ratio = 0.5,
-- 			-- absolute minimum of steps that will be performed for every path find request no matter what
-- 			min_steps_to_check_path_find_termination = 2000,
-- 			-- if the amount of steps is higher than this times estimate of start to goal then path finding is terminated
-- 			start_to_goal_cost_multiplier_to_terminate_path_find = 2000.0,
-- 			-- When the number of waiting clients exceeds certain values, the per-tick work limit will be increased by the
-- 			-- given multiplier. overload_levels gives the threshold values, overload_multipliers gives the multipliers.
-- 			-- overload_levels and overload_multipliers must be the same length.
-- 			overload_levels = {0, 100, 500},
-- 			overload_multipliers = {2, 3, 4}
-- 		},

-- 		-- If a behavior fails this many times, the enemy (or enemy group)
-- 		-- is destroyed.
-- 		-- This solves biters stuck within their own base.
-- 		max_failed_behavior_count = 3,

-- 		-- These can't be changed through game.map_settings - you must use game.difficulty_settings
-- 		difficulty_settings =
-- 		{
-- 			 recipe_difficulty = defines.difficulty_settings.recipe_difficulty.normal,
-- 			 technology_difficulty = defines.difficulty_settings.technology_difficulty.normal,
-- 			 technology_price_multiplier = 1,
-- 			 research_queue_setting = 'after-victory'
-- 		}
-- 	}
-- })