--luacheck: ignore
-- fish defender -- by mewmew --

require 'maps.fish_defender_v1.map_intro'
require 'maps.fish_defender_v1.market'
require 'maps.fish_defender_v1.shotgun_buff'
require 'maps.fish_defender_v1.on_entity_damaged'

require 'modules.rocket_launch_always_yields_science'
require 'modules.launch_fish_to_win'
require 'modules.biters_yield_coins'
require 'modules.dynamic_landfill'
require 'modules.dangerous_goods'
require 'modules.custom_death_messages'
require 'modules.biter_evasion_hp_increaser'

local event = require 'utils.event'
local Server = require 'utils.server'
local boss_biter = require 'maps.fish_defender.boss_biters'
local Score = require 'utils.gui.score'
require 'utils.functions.boss_unit'
local map_functions = require 'utils.tools.map_functions'
local Difficulty = require 'modules.difficulty_vote'
local math_random = math.random
local insert = table.insert
local enable_start_grace_period = true

local biter_count_limit = 1024 --maximum biters on the east side of the map, next wave will be delayed if the maximum has been reached
local boss_waves = {
    [50] = { { name = 'big-biter', count = 3 } },
    [100] = { { name = 'behemoth-biter', count = 1 } },
    [150] = { { name = 'behemoth-spitter', count = 4 }, { name = 'big-spitter', count = 16 } },
    [200] = {
        { name = 'behemoth-biter',   count = 4 },
        { name = 'behemoth-spitter', count = 2 },
        { name = 'big-biter',        count = 32 }
    },
    [250] = {
        { name = 'behemoth-biter',   count = 8 },
        { name = 'behemoth-spitter', count = 4 },
        { name = 'big-spitter',      count = 32 }
    },
    [300] = { { name = 'behemoth-biter', count = 16 }, { name = 'behemoth-spitter', count = 8 } }
}

local difficulties_votes = {
    [1] = { wave_interval = 5100, amount_modifier = 0.55, strength_modifier = 0.40 },
    [2] = { wave_interval = 4500, amount_modifier = 0.75, strength_modifier = 0.65 },
    [3] = { wave_interval = 4000, amount_modifier = 0.90, strength_modifier = 0.85 },
    [4] = { wave_interval = 3600, amount_modifier = 1.00, strength_modifier = 1.00 },
    [5] = { wave_interval = 3200, amount_modifier = 1.10, strength_modifier = 1.25 },
    [6] = { wave_interval = 2700, amount_modifier = 1.25, strength_modifier = 1.75 },
    [7] = { wave_interval = 2100, amount_modifier = 1.50, strength_modifier = 2.50 }
}

local function shuffle(tbl)
    local size = #tbl
    for i = size, 1, -1 do
        local rand = math.random(size)
        tbl[i], tbl[rand] = tbl[rand], tbl[i]
    end
    return tbl
end

local function create_wave_gui(player)
    if player.gui.top['fish_defense_waves'] then
        player.gui.top['fish_defense_waves'].destroy()
    end
    local frame = player.gui.top.add({ type = 'frame', name = 'fish_defense_waves', tooltip = 'Click to show map info' })
    frame.style.maximal_height = 38

    local wave_count = 0
    if storage.wave_count then
        wave_count = storage.wave_count
    end

    if not storage.wave_grace_period then
        local label = frame.add({ type = 'label', caption = 'Wave: ' .. wave_count })
        label.style.font_color = { r = 0.88, g = 0.88, b = 0.88 }
        label.style.font = 'default-listbox'
        label.style.left_padding = 4
        label.style.right_padding = 4
        label.style.minimal_width = 68
        label.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }

        local next_level_progress = game.tick % storage.wave_interval / storage.wave_interval

        local progressbar = frame.add({ type = 'progressbar', value = next_level_progress })
        progressbar.style.minimal_width = 120
        progressbar.style.maximal_width = 120
        progressbar.style.top_padding = 10
        progressbar.style.height = 20
    else
        local time_remaining = math.floor(((storage.wave_grace_period - (game.tick % storage.wave_grace_period)) / 60) / 60)
        if time_remaining <= 0 then
            storage.wave_grace_period = nil
            return
        end

        local label = frame.add({ type = 'label', caption = 'Waves will start in ' .. time_remaining .. ' minutes.' })
        label.style.font_color = { r = 0.88, g = 0.88, b = 0.88 }
        label.style.font = 'default-listbox'
        label.style.left_padding = 4
        label.style.right_padding = 4
        label.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }

        if not enable_start_grace_period then
            storage.wave_grace_period = nil
            return
        end
    end
end

local function show_fd_stats(player)
    local gui_id = 'fd-stats'
    local table_id = gui_id .. 'table'

    if player.gui.left[gui_id] then
        player.gui.left[gui_id].destroy()
    end

    local frame =
        player.gui.left.add {
            type = 'frame',
            name = gui_id
        }
    local table =
        frame.add {
            type = 'table',
            name = table_id,
            column_count = 2
        }

    local table_header = { 'Building', 'Placed' .. '/' .. 'Limit' }
    for k, v in pairs(table_header) do
        local h = table.add { type = 'label', caption = v }
        h.style.font = 'heading-2'
    end

    for k, v in pairs(storage.entity_limits) do
        local name = v.str
        local placed = v.placed
        local limit = v.limit
        local entry = { name, placed .. '/' .. limit }
        for k, v in pairs(entry) do
            table.add {
                type = 'label',
                caption = v
            }
        end
    end
end

local function update_fd_stats()
    for _, player in pairs(game.connected_players) do
        if player.gui.left['fd-stats'] then
            show_fd_stats(player)
        end
    end
end

local function add_fd_stats_button(player)
    local button_id = 'fd-stats-button'
    if player.gui.top[button_id] then
        player.gui.top[button_id].destroy()
    end
    local button =
        player.gui.top.add {
            type = 'sprite-button',
            name = button_id,
            sprite = 'item/submachine-gun'
        }
end

local function on_gui_click(event)
    if not event.element.valid then
        return
    end
    if event.element.name ~= 'fd-stats-button' then
        return
    end
    local player = game.players[event.player_index]
    local frame = player.gui.left['fd-stats']
    if frame == nil then
        show_fd_stats(player)
    else
        frame.destroy()
    end
end

local function on_market_item_purchased(event)
    update_fd_stats()
end

local threat_values = {
    ['small_biter'] = 1,
    ['medium_biter'] = 3,
    ['big_biter'] = 5,
    ['behemoth_biter'] = 10,
    ['small_spitter'] = 1,
    ['medium_spitter'] = 3,
    ['big_spitter'] = 5,
    ['behemoth_spitter'] = 10
}

local function get_biter_initial_pool()
    local biter_pool = {}
    if storage.wave_count > 1750 then
        biter_pool = {
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
    if storage.wave_count > 1500 then
        biter_pool = {
            { name = 'big-biter',        threat = threat_values.big_biter,        weight = 1 },
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
    if storage.wave_count > 1250 then
        biter_pool = {
            { name = 'big-biter',        threat = threat_values.big_biter,        weight = 2 },
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
    if storage.wave_count > 1000 then
        biter_pool = {
            { name = 'big-biter',        threat = threat_values.big_biter,        weight = 3 },
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.1 then
        biter_pool = {
            { name = 'small-biter',   threat = threat_values.small_biter,   weight = 3 },
            { name = 'small-spitter', threat = threat_values.small_spitter, weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.2 then
        biter_pool = {
            { name = 'small-biter',    threat = threat_values.small_biter,    weight = 10 },
            { name = 'medium-biter',   threat = threat_values.medium_biter,   weight = 2 },
            { name = 'small-spitter',  threat = threat_values.small_spitter,  weight = 5 },
            { name = 'medium-spitter', threat = threat_values.medium_spitter, weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.3 then
        biter_pool = {
            { name = 'small-biter',    threat = threat_values.small_biter,    weight = 18 },
            { name = 'medium-biter',   threat = threat_values.medium_biter,   weight = 6 },
            { name = 'small-spitter',  threat = threat_values.small_spitter,  weight = 8 },
            { name = 'medium-spitter', threat = threat_values.medium_spitter, weight = 3 },
            { name = 'big-biter',      threat = threat_values.big_biter,      weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.4 then
        biter_pool = {
            { name = 'small-biter',    threat = threat_values.small_biter,    weight = 2 },
            { name = 'medium-biter',   threat = threat_values.medium_biter,   weight = 8 },
            { name = 'big-biter',      threat = threat_values.big_biter,      weight = 2 },
            { name = 'small-spitter',  threat = threat_values.small_spitter,  weight = 1 },
            { name = 'medium-spitter', threat = threat_values.medium_spitter, weight = 4 },
            { name = 'big-spitter',    threat = threat_values.big_spitter,    weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.5 then
        biter_pool = {
            { name = 'small-biter',    threat = threat_values.small_biter,    weight = 2 },
            { name = 'medium-biter',   threat = threat_values.medium_biter,   weight = 4 },
            { name = 'big-biter',      threat = threat_values.big_biter,      weight = 8 },
            { name = 'small-spitter',  threat = threat_values.small_spitter,  weight = 1 },
            { name = 'medium-spitter', threat = threat_values.medium_spitter, weight = 2 },
            { name = 'big-spitter',    threat = threat_values.big_spitter,    weight = 4 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.6 then
        biter_pool = {
            { name = 'medium-biter',   threat = threat_values.medium_biter,   weight = 4 },
            { name = 'big-biter',      threat = threat_values.big_biter,      weight = 8 },
            { name = 'medium-spitter', threat = threat_values.medium_spitter, weight = 2 },
            { name = 'big-spitter',    threat = threat_values.big_spitter,    weight = 4 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.7 then
        biter_pool = {
            { name = 'behemoth-biter',   threat = threat_values.small_biter,    weight = 2 },
            { name = 'medium-biter',     threat = threat_values.medium_biter,   weight = 12 },
            { name = 'big-biter',        threat = threat_values.big_biter,      weight = 20 },
            { name = 'behemoth-spitter', threat = threat_values.small_spitter,  weight = 1 },
            { name = 'medium-spitter',   threat = threat_values.medium_spitter, weight = 6 },
            { name = 'big-spitter',      threat = threat_values.big_spitter,    weight = 10 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor < 0.8 then
        biter_pool = {
            { name = 'behemoth-biter',   threat = threat_values.small_biter,    weight = 2 },
            { name = 'medium-biter',     threat = threat_values.medium_biter,   weight = 4 },
            { name = 'big-biter',        threat = threat_values.big_biter,      weight = 10 },
            { name = 'behemoth-spitter', threat = threat_values.small_spitter,  weight = 1 },
            { name = 'medium-spitter',   threat = threat_values.medium_spitter, weight = 2 },
            { name = 'big-spitter',      threat = threat_values.big_spitter,    weight = 5 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor <= 0.9 then
        biter_pool = {
            { name = 'big-biter',        threat = threat_values.big_biter,        weight = 12 },
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'big-spitter',      threat = threat_values.big_spitter,      weight = 6 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
    if game.forces.enemy.evolution_factor <= 1 then
        biter_pool = {
            { name = 'big-biter',        threat = threat_values.big_biter,        weight = 4 },
            { name = 'behemoth-biter',   threat = threat_values.behemoth_biter,   weight = 2 },
            { name = 'big-spitter',      threat = threat_values.big_spitter,      weight = 2 },
            { name = 'behemoth-spitter', threat = threat_values.behemoth_spitter, weight = 1 }
        }
        return biter_pool
    end
end

local function get_biter_pool()
    local surface = game.surfaces['fish_defender']
    local biter_pool = get_biter_initial_pool()
    local biter_raffle = {}
    for _, biter_type in pairs(biter_pool) do
        for x = 1, biter_type.weight, 1 do
            insert(biter_raffle, { name = biter_type.name, threat = biter_type.threat })
        end
    end
    return biter_raffle
end

local function spawn_biter(pos, biter_pool)
    if storage.attack_wave_threat < 1 then
        return false
    end
    local surface = game.surfaces['fish_defender']
    biter_pool = shuffle(biter_pool)
    storage.attack_wave_threat = storage.attack_wave_threat - biter_pool[1].threat
    local valid_pos = surface.find_non_colliding_position(biter_pool[1].name, pos, 100, 2)
    local biter = surface.create_entity({ name = biter_pool[1].name, position = valid_pos })
    return biter
end

local attack_group_count_thresholds = {
    { 0,    1 },
    { 50,   2 },
    { 100,  3 },
    { 150,  4 },
    { 200,  5 },
    { 1000, 6 },
    { 2000, 7 },
    { 3000, 8 }
}

local function get_number_of_attack_groups()
    local n = 1
    for _, entry in pairs(attack_group_count_thresholds) do
        if storage.wave_count >= entry[1] then
            n = entry[2]
        end
    end
    return n
end

local function clear_corpses(surface)
    if not storage.wave_count then
        return
    end
    local chance = 4
    if storage.wave_count > 250 then
        chance = 3
    end
    if storage.wave_count > 500 then
        chance = 2
    end
    for _, entity in pairs(surface.find_entities_filtered { type = 'corpse' }) do
        if math_random(1, chance) == 1 then
            entity.destroy()
        end
    end
end

local boss_wave_names = {
    [50] = 'The Big Biter Gang',
    [100] = 'Biterzilla',
    [150] = 'The Spitter Squad',
    [200] = 'The Wall Nibblers',
    [250] = 'Conveyor Munchers',
    [300] = 'Furnace Freezers',
    [350] = 'Cable Chewers',
    [400] = 'Power Pole Thieves',
    [450] = 'Assembler Annihilators',
    [500] = 'Inserter Crunchers',
    [550] = 'Engineer Eaters',
    [600] = 'Belt Unbalancers',
    [650] = 'Turret Devourers',
    [700] = 'Pipe Perforators',
    [750] = 'Desync Bros',
    [800] = 'Ratio Randomizers',
    [850] = 'Wire Chompers',
    [900] = 'The Bus Mixers',
    [950] = 'Roundabout Deadlockers',
    [1000] = 'Happy Tree Friends',
    [1050] = 'Uranium Digesters',
    [1100] = 'Bot Banishers',
    [1150] = 'Chest Crushers',
    [1200] = 'Cargo Wagon Scratchers',
    [1250] = 'Transport Belt Surfers',
    [1300] = 'Pumpjack Pulverizers',
    [1350] = 'Radar Ravagers',
    [1400] = 'Mall Deconstrutors',
    [1450] = 'Lamp Dimmers',
    [1500] = 'Roboport Disablers',
    [1550] = 'Signal Spammers',
    [1600] = 'Brick Tramplers',
    [1650] = 'Drill Destroyers',
    [1700] = 'Gearwheel Grinders',
    [1750] = 'Silo Seekers',
    [1800] = 'Circuit Breakers',
    [1850] = 'Bullet Absorbers',
    [1900] = 'Oil Guzzlers',
    [1950] = 'Belt Rotators',
    [2000] = 'Bluescreen Factor'
}

local function spawn_boss_units(surface)
    local Diff = Difficulty.get()
    if boss_wave_names[storage.wave_count] then
        game.print('Boss Wave ' .. storage.wave_count .. ' - - ' .. boss_wave_names[storage.wave_count], { r = 0.8, g = 0.1, b = 0.1 })
    else
        game.print('Boss Wave ' .. storage.wave_count, { r = 0.8, g = 0.1, b = 0.1 })
    end

    if not boss_waves[storage.wave_count] then
        boss_waves[storage.wave_count] = {
            { name = 'behemoth-biter',   count = math.floor(storage.wave_count / 16) },
            { name = 'behemoth-spitter', count = math.floor(storage.wave_count / 32) }
        }
    end

    local position = { x = 216, y = 0 }
    local biter_group = surface.create_unit_group({ position = position })
    for _, entry in pairs(boss_waves[storage.wave_count]) do
        for x = 1, entry.count, 1 do
            local pos = surface.find_non_colliding_position(entry.name, position, 64, 3)
            if pos then
                local biter = surface.create_entity({ name = entry.name, position = pos })
                storage.boss_biters[biter.unit_number] = biter
                add_boss_unit(biter, storage.biter_evasion_health_increase_factor * 8 * difficulties_votes[Diff.difficulty_vote_index].strength_modifier, 0.70)
                biter_group.add_member(biter)
            end
        end
    end
    biter_group.set_command(
        {
            type = defines.command.compound,
            structure_type = defines.compound_command.logical_and,
            commands = {
                {
                    type = defines.command.attack_area,
                    destination = { x = 160, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack_area,
                    destination = { x = 128, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack_area,
                    destination = { x = 96, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack_area,
                    destination = { x = 64, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack_area,
                    destination = { x = 32, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack_area,
                    destination = { x = -32, y = 0 },
                    radius = 16,
                    distraction = defines.distraction.by_enemy
                },
                {
                    type = defines.command.attack,
                    target = storage.market,
                    distraction = defines.distraction.by_enemy
                }
            }
        }
    )
    biter_group.start_moving()
end

local function wake_up_the_biters(surface)
    if not storage.market then
        return
    end

    --if not storage.wake_up_counter then storage.wake_up_counter = 0 end
    --storage.wake_up_counter = storage.wake_up_counter + 1
    --if storage.wake_up_counter % 2 == 1 then return end

    --[[
	unit_group = game.player.surface.create_unit_group({position = game.player.selected.position})
	for _, biter in pairs(game.player.surface.find_enemy_units(game.player.selected.position, 96, "player")) do
		unit_group.add_member(biter)
	end
	unit_group.set_command({
					type = defines.command.compound,
					structure_type = defines.compound_command.logical_and,
					commands = {
						{
							type=defines.command.attack_area,
							destination=storage.market.position,
							radius=512,
							distraction=defines.distraction.by_anything
						}
					}
				})
	unit_group.start_moving()

	game.player.surface.set_multi_command({
		command={
			type=defines.command.attack,
			target=storage.market,
			distraction=defines.distraction.none
			},
		unit_count = 128,
		force = "enemy",
		unit_search_distance=128
		})

	]]
    local nearest_player_unit = surface.find_nearest_enemy({ position = { x = 256, y = 0 }, max_distance = 512, force = 'enemy' })
    if not nearest_player_unit then
        return
    end
    local target_positions = {}
    for y = -80, 80, 4 do
        insert(target_positions, { x = nearest_player_unit.position.x, y = y })
    end
    target_positions = shuffle(target_positions)

    local units = surface.find_entities_filtered({ type = 'unit' })
    units = shuffle(units)
    local unit_groups = {}
    for i = 1, 2, 1 do
        if not units[i] then
            break
        end
        if not units[i].valid then
            break
        end
        unit_groups[i] = surface.create_unit_group({ position = { x = units[i].position.x, y = units[i].position.y } })
        local biters = surface.find_enemy_units(units[i].position, 24, 'player')
        for _, biter in pairs(biters) do
            unit_groups[i].add_member(biter)
        end
    end

    for i = 1, #unit_groups, 1 do
        if unit_groups[i].valid then
            if #unit_groups[i].members > 0 then
                unit_groups[i].set_command(
                    {
                        type = defines.command.compound,
                        structure_type = defines.compound_command.logical_and,
                        commands = {
                            {
                                type = defines.command.attack_area,
                                destination = { target_positions[i].x, target_positions[i].y },
                                radius = 32,
                                distraction = defines.distraction.by_anything
                            },
                            {
                                type = defines.command.attack_area,
                                destination = storage.market.position,
                                radius = 32,
                                distraction = defines.distraction.by_anything
                            },
                            {
                                type = defines.command.attack,
                                target = storage.market,
                                distraction = defines.distraction.by_enemy
                            }
                        }
                    }
                )
                unit_groups[i].start_moving()
            else
                unit_groups[i].destroy()
            end
        end
    end

    --[[
	surface.set_multi_command({
		command={
			type=defines.command.attack,
			target=storage.market,
			distraction=defines.distraction.by_enemy
			},
		unit_count = 16,
		force = "enemy",
		unit_search_distance=64
		})]]
    surface.set_multi_command(
        {
            command = {
                type = defines.command.attack,
                target = storage.market,
                distraction = defines.distraction.none
            },
            unit_count = 16,
            force = 'enemy',
            unit_search_distance = 24
        }
    )
end

local function damage_entity_outside_of_fence(e)
    if not e.health then
        return
    end
    if e.force.name == 'neutral' then
        return
    end
    if e.type == 'unit' or e.type == 'unit-spawner' then
        return
    end

    e.surface.create_entity({ name = 'water-splash', position = e.position })

    if e.type == 'entity-ghost' then
        e.destroy()
        return
    end

    e.health = e.health - math_random(math.floor(e.max_health * 0.05), math.floor(e.max_health * 0.1))
    if e.health <= 0 then
        e.die('enemy')
    end
end

local function biter_attack_wave()
    if not storage.market then
        return
    end
    if storage.wave_grace_period then
        return
    end
    local surface = game.surfaces['fish_defender']
    local Diff = Difficulty.get()

    clear_corpses(surface)
    wake_up_the_biters(surface)

    if surface.count_entities_filtered({ type = 'unit' }) > biter_count_limit then
        --game.print("Biter limit reached, wave delayed.", {r = 0.7, g = 0.1, b = 0.1})
        return
    end

    if not storage.wave_count then
        storage.wave_count = 1
    else
        storage.wave_count = storage.wave_count + 1
    end

    local m = 0.0015
    if Diff.difficulty_vote_index then
        m = m * difficulties_votes[Diff.difficulty_vote_index].strength_modifier
    end
    game.forces.enemy.set_ammo_damage_modifier('melee', storage.wave_count * m)
    game.forces.enemy.set_ammo_damage_modifier('biological', storage.wave_count * m)
    storage.biter_evasion_health_increase_factor = 1 + (storage.wave_count * (m * 2))

    local m = 4
    if Diff.difficulty_vote_index then
        m = m * difficulties_votes[Diff.difficulty_vote_index].amount_modifier
    end

    if storage.wave_count % 50 == 0 then
        storage.attack_wave_threat = math.floor(storage.wave_count * m)
        spawn_boss_units(surface)
        if storage.attack_wave_threat > 10000 then
            storage.attack_wave_threat = 10000
        end
    else
        storage.attack_wave_threat = math.floor(storage.wave_count * m)
        if storage.attack_wave_threat > 10000 then
            storage.attack_wave_threat = 10000
        end
    end

    local evolution = storage.wave_count * 0.00125
    if evolution > 1 then
        evolution = 1
    end
    game.forces.enemy.evolution_factor = evolution

    if game.forces.enemy.evolution_factor == 1 then
        if not storage.endgame_modifier then
            storage.endgame_modifier = 1
            game.print('Endgame enemy evolution reached.', { r = 0.7, g = 0.1, b = 0.1 })
        else
            storage.endgame_modifier = storage.endgame_modifier + 1
        end
    end

    for _, e in pairs(surface.find_entities_filtered({ area = { { 160, -256 }, { 360, 256 } } })) do
        damage_entity_outside_of_fence(e)
    end

    local spawn_x = 242
    local target_x = -32
    local group_coords = {}
    for a = -80, 80, 16 do
        insert(group_coords, { spawn = { x = spawn_x, y = a * 2 }, target = { x = target_x, y = a } })
    end
    group_coords = shuffle(group_coords)

    local unit_groups = {}
    if storage.wave_count > 100 and math_random(1, 8) == 1 then
        for i = 1, #group_coords, 1 do
            unit_groups[i] = surface.create_unit_group({ position = group_coords[i].spawn })
        end
    else
        for i = 1, get_number_of_attack_groups(), 1 do
            unit_groups[i] = surface.create_unit_group({ position = group_coords[i].spawn })
        end
    end

    local biter_pool = get_biter_pool()
    while storage.attack_wave_threat > 0 do
        for i = 1, #unit_groups, 1 do
            local biter = spawn_biter(unit_groups[i].position, biter_pool)
            if biter then
                unit_groups[i].add_member(biter)
            else
                break
            end
        end
    end

    for i = 1, #unit_groups, 1 do
        unit_groups[i].set_command(
            {
                type = defines.command.compound,
                structure_type = defines.compound_command.logical_and,
                commands = {
                    {
                        type = defines.command.attack_area,
                        destination = { group_coords[i].target.x + 192, group_coords[i].target.y },
                        radius = 32,
                        distraction = defines.distraction.by_anything
                    },
                    {
                        type = defines.command.attack_area,
                        destination = { group_coords[i].target.x + 128, group_coords[i].target.y },
                        radius = 32,
                        distraction = defines.distraction.by_anything
                    },
                    {
                        type = defines.command.attack_area,
                        destination = { group_coords[i].target.x + 64, group_coords[i].target.y },
                        radius = 32,
                        distraction = defines.distraction.by_anything
                    },
                    {
                        type = defines.command.attack_area,
                        destination = { group_coords[i].target.x, group_coords[i].target.y },
                        radius = 32,
                        distraction = defines.distraction.by_enemy
                    },
                    {
                        type = defines.command.attack,
                        target = storage.market,
                        distraction = defines.distraction.by_enemy
                    }
                }
            }
        )
        unit_groups[i].start_moving()
    end
end

local function get_sorted_list(column_name, score_list)
    for x = 1, #score_list, 1 do
        for y = 1, #score_list, 1 do
            if not score_list[y + 1] then
                break
            end
            if score_list[y][column_name] < score_list[y + 1][column_name] then
                local key = score_list[y]
                score_list[y] = score_list[y + 1]
                score_list[y + 1] = key
            end
        end
    end
    return score_list
end

local function get_mvps()
    local get_score = Score.get_table().score_table
    if not get_score['player'] then
        return false
    end
    local score = get_score['player']
    local score_list = {}
    for _, p in pairs(game.players) do
        local killscore = 0
        if score.players[p.name].killscore then
            killscore = score.players[p.name].killscore
        end
        local deaths = 0
        if score.players[p.name].deaths then
            deaths = score.players[p.name].deaths
        end
        local built_entities = 0
        if score.players[p.name].built_entities then
            built_entities = score.players[p.name].built_entities
        end
        local mined_entities = 0
        if score.players[p.name].mined_entities then
            mined_entities = score.players[p.name].mined_entities
        end
        table.insert(
            score_list,
            {
                name = p.name,
                killscore = killscore,
                deaths = deaths,
                built_entities = built_entities,
                mined_entities = mined_entities
            }
        )
    end
    local mvp = {}
    score_list = get_sorted_list('killscore', score_list)
    mvp.killscore = { name = score_list[1].name, score = score_list[1].killscore }
    score_list = get_sorted_list('deaths', score_list)
    mvp.deaths = { name = score_list[1].name, score = score_list[1].deaths }
    score_list = get_sorted_list('built_entities', score_list)
    mvp.built_entities = { name = score_list[1].name, score = score_list[1].built_entities }
    return mvp
end

local function is_game_lost()
    if storage.market then
        return
    end

    for _, player in pairs(game.connected_players) do
        if player.gui.left['fish_defense_game_lost'] then
            return
        end
        local f =
            player.gui.left.add(
                {
                    type = 'frame',
                    name = 'fish_defense_game_lost',
                    caption = 'The fish market was overrun! The biters are having a feast :3',
                    direction = 'vertical'
                }
            )
        f.style.font_color = { r = 0.65, g = 0.1, b = 0.99 }

        local t = f.add({ type = 'table', column_count = 2 })
        local l = t.add({ type = 'label', caption = 'Survival Time >> ' })
        l.style.font = 'default-listbox'
        l.style.font_color = { r = 0.22, g = 0.77, b = 0.44 }

        if storage.market_age >= 216000 then
            local l =
                t.add(
                    {
                        type = 'label',
                        caption = math.floor(((storage.market_age / 60) / 60) / 60) .. ' hours ' .. math.ceil((storage.market_age % 216000 / 60) / 60) .. ' minutes'
                    }
                )
            l.style.font = 'default-bold'
            l.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }
        else
            local l = t.add({ type = 'label', caption = math.ceil((storage.market_age % 216000 / 60) / 60) .. ' minutes' })
            l.style.font = 'default-bold'
            l.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }
        end

        local mvp = get_mvps()
        if mvp then
            local l = t.add({ type = 'label', caption = 'MVP Defender >> ' })
            l.style.font = 'default-listbox'
            l.style.font_color = { r = 0.22, g = 0.77, b = 0.44 }
            local l = t.add({ type = 'label', caption = mvp.killscore.name .. ' with a score of ' .. mvp.killscore.score })
            l.style.font = 'default-bold'
            l.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }

            local l = t.add({ type = 'label', caption = 'MVP Builder >> ' })
            l.style.font = 'default-listbox'
            l.style.font_color = { r = 0.22, g = 0.77, b = 0.44 }
            local l =
                t.add(
                    {
                        type = 'label',
                        caption = mvp.built_entities.name .. ' built ' .. mvp.built_entities.score .. ' things'
                    }
                )
            l.style.font = 'default-bold'
            l.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }

            local l = t.add({ type = 'label', caption = 'MVP Deaths >> ' })
            l.style.font = 'default-listbox'
            l.style.font_color = { r = 0.22, g = 0.77, b = 0.44 }
            local l = t.add({ type = 'label', caption = mvp.deaths.name .. ' died ' .. mvp.deaths.score .. ' times' })
            l.style.font = 'default-bold'
            l.style.font_color = { r = 0.33, g = 0.66, b = 0.9 }

            if not storage.results_sent then
                local result = {}
                insert(result, 'MVP Defender: \\n')
                insert(result, mvp.killscore.name .. ' with a score of ' .. mvp.killscore.score .. '\\n')
                insert(result, '\\n')
                insert(result, 'MVP Builder: \\n')
                insert(result, mvp.built_entities.name .. ' built ' .. mvp.built_entities.score .. ' things\\n')
                insert(result, '\\n')
                insert(result, 'MVP Deaths: \\n')
                insert(result, mvp.deaths.name .. ' died ' .. mvp.deaths.score .. ' times')
                local message = table.concat(result)
                Server.to_discord_embed(message)
                storage.results_sent = true
            end
        end

        for _, player in pairs(game.connected_players) do
            player.play_sound { path = 'utility/game_lost', volume_modifier = 0.75 }
        end
    end

    game.map_settings.enemy_expansion.enabled = true
    game.map_settings.enemy_expansion.max_expansion_distance = 15
    game.map_settings.enemy_expansion.settler_group_min_size = 15
    game.map_settings.enemy_expansion.settler_group_max_size = 30
    game.map_settings.enemy_expansion.min_expansion_cooldown = 600
    game.map_settings.enemy_expansion.max_expansion_cooldown = 600
end

local function damage_entities_in_radius(surface, position, radius, damage)
    local entities_to_damage = surface.find_entities_filtered({ area = { { position.x - radius, position.y - radius }, { position.x + radius, position.y + radius } } })
    for _, entity in pairs(entities_to_damage) do
        if entity.valid then
            if entity.health and entity.name ~= 'land-mine' then
                if entity.force.name ~= 'enemy' then
                    if entity.name == 'character' then
                        entity.damage(damage, 'enemy')
                    else
                        entity.health = entity.health - damage
                        if entity.health <= 0 then
                            entity.die('enemy')
                        end
                    end
                end
            end
        end
    end
end

local function market_kill_visuals()
    local m = 32
    local m2 = m * 0.005
    for i = 1, 1024, 1 do
        storage.market.surface.create_entity(
            {
                name = 'branch-particle',
                position = storage.market.position,
                frame_speed = 0.1,
                vertical_speed = 0.1,
                height = 0.1,
                movement = { m2 - (math.random(0, m) * 0.01), m2 - (math.random(0, m) * 0.01) }
            }
        )
    end
    for x = -5, 5, 0.5 do
        for y = -5, 5, 0.5 do
            if math_random(1, 2) == 1 then
                storage.market.surface.create_trivial_smoke(
                    {
                        name = 'smoke-fast',
                        position = { storage.market.position.x + (x * 0.35), storage.market.position.y + (y * 0.35) }
                    }
                )
            end
            if math_random(1, 3) == 1 then
                storage.market.surface.create_trivial_smoke(
                    {
                        name = 'train-smoke',
                        position = { storage.market.position.x + (x * 0.35), storage.market.position.y + (y * 0.35) }
                    }
                )
            end
        end
    end
    storage.market.surface.spill_item_stack(storage.market.position, { name = 'raw-fish', count = 1024 }, true)
end

local biter_splash_damage = {
    ['medium-biter'] = {
        visuals = { 'blood-explosion-big', 'big-explosion' },
        radius = 1.5,
        damage_min = 50,
        damage_max = 100,
        chance = 8
    },
    ['big-biter'] = {
        visuals = { 'blood-explosion-huge', 'ground-explosion' },
        radius = 2,
        damage_min = 75,
        damage_max = 150,
        chance = 16
    },
    ['behemoth-biter'] = {
        visuals = { 'blood-explosion-huge', 'big-artillery-explosion' },
        radius = 2.5,
        damage_min = 100,
        damage_max = 200,
        chance = 32
    }
}

local function on_entity_died(event)
    if event.entity.force.name == 'enemy' then
        local surface = event.entity.surface

        if storage.boss_biters[event.entity.unit_number] then
            boss_biter.died(event)
        end

        local splash = biter_splash_damage[event.entity.name]
        if splash then
            if math_random(1, splash.chance) == 1 then
                for _, visual in pairs(splash.visuals) do
                    surface.create_entity({ name = visual, position = event.entity.position })
                end
                damage_entities_in_radius(surface, event.entity.position, splash.radius, math_random(splash.damage_min, splash.damage_max))
                return
            end
        end

        if event.entity.name == 'behemoth-biter' then
            if math_random(1, 16) == 1 then
                local p = surface.find_non_colliding_position('big-biter', event.entity.position, 3, 0.5)
                if p then
                    surface.create_entity { name = 'big-biter', position = p }
                end
            end
            for i = 1, math_random(1, 2), 1 do
                local p = surface.find_non_colliding_position('medium-biter', event.entity.position, 3, 0.5)
                if p then
                    surface.create_entity { name = 'medium-biter', position = p }
                end
            end
        end
        return
    end

    if event.entity == storage.market then
        market_kill_visuals()
        storage.market = nil
        storage.market_age = game.tick
        is_game_lost()
    end

    if storage.entity_limits[event.entity.name] then
        storage.entity_limits[event.entity.name].placed = storage.entity_limits[event.entity.name].placed - 1
        update_fd_stats()
    end
end

local function on_player_joined_game(event)
    local player = game.players[event.player_index]

    if not storage.fish_defense_init_done then
        local map_gen_settings = {}
        map_gen_settings.water = '0.5'
        map_gen_settings.cliff_settings = { cliff_elevation_interval = 16, cliff_elevation_0 = 32 }
        map_gen_settings.autoplace_controls = {
            ['coal'] = { frequency = '3', size = '2', richness = '1' },
            ['stone'] = { frequency = '3', size = '2', richness = '1' },
            ['copper-ore'] = { frequency = '3', size = '2', richness = '1' },
            ['iron-ore'] = { frequency = '3', size = '2', richness = '1' },
            ['uranium-ore'] = { frequency = '2', size = '1', richness = '1' },
            ['crude-oil'] = { frequency = '4', size = '1', richness = '1' },
            ['trees'] = { frequency = '1.5', size = '1.5', richness = '1' },
            ['enemy-base'] = { frequency = 'none', size = 'none', richness = 'none' }
        }
        game.create_surface('fish_defender', map_gen_settings)
        local surface = game.surfaces['fish_defender']

        local radius = 256
        game.forces.player.chart(surface, { { x = -1 * radius, y = -1 * radius }, { x = radius, y = radius } })

        game.map_settings.enemy_expansion.enabled = false
        game.map_settings.enemy_evolution.destroy_factor = 0
        game.map_settings.enemy_evolution.time_factor = 0
        game.map_settings.enemy_evolution.pollution_factor = 0
        game.map_settings.pollution.enabled = false

        game.forces['player'].technologies['atomic-bomb'].enabled = false

        storage.entity_limits = {
            ['gun-turret'] = { placed = 1, limit = 1, str = 'gun turret', slot_price = 75 },
            ['laser-turret'] = { placed = 0, limit = 1, str = 'laser turret', slot_price = 300 },
            ['artillery-turret'] = { placed = 0, limit = 1, str = 'artillery turret', slot_price = 500 },
            ['flamethrower-turret'] = { placed = 0, limit = 0, str = 'flamethrower turret', slot_price = 50000 },
            ['land-mine'] = { placed = 0, limit = 1, str = 'mine', slot_price = 1 }
        }

        game.create_force('decoratives')
        game.forces['decoratives'].set_cease_fire('enemy', true)
        game.forces['enemy'].set_cease_fire('decoratives', true)
        game.forces['player'].set_cease_fire('decoratives', true)

        storage.comfylatron_habitat = {
            left_top = { x = -1500, y = -1500 },
            right_bottom = { x = -80, y = 1500 }
        }

        storage.fish_defense_init_done = true
    end

    if player.online_time < 1 then
        player.insert({ name = 'pistol', count = 1 })
        player.insert({ name = 'raw-fish', count = 3 })
        player.insert({ name = 'firearm-magazine', count = 16 })
        player.insert({ name = 'iron-plate', count = 32 })
    end

    local surface = game.surfaces['fish_defender']
    if player.online_time < 2 and surface.is_chunk_generated({ 0, 0 }) then
        player.teleport(surface.find_non_colliding_position('character', { -75, 4 }, 50, 1), 'fish_defender')
    else
        if player.online_time < 2 then
            player.teleport({ -50, 0 }, 'fish_defender')
        end
    end

    create_wave_gui(player)
    add_fd_stats_button(player)

    if game.tick > 900 then
        is_game_lost()
    end
end

local function get_replacement_tile(surface)
    local tilename = 'grass-1'
    for x = -160, 160, 1 do
        for y = -96, 90, 1 do
            local tile = surface.get_tile(x, y)
            if tile.name ~= 'water' and tile.name ~= 'deepwater' then
                tilename = tile.name
            end
        end
    end
    return tilename
end

local worm_raffle_table = {
    [1] = {
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret'
    },
    [2] = {
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'medium-worm-turret'
    },
    [3] = {
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret'
    },
    [4] = {
        'small-worm-turret',
        'small-worm-turret',
        'small-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret'
    },
    [5] = {
        'small-worm-turret',
        'small-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret'
    },
    [6] = {
        'small-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret'
    },
    [7] = {
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret',
        'big-worm-turret'
    },
    [8] = {
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret',
        'big-worm-turret'
    },
    [9] = {
        'medium-worm-turret',
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret',
        'big-worm-turret',
        'big-worm-turret'
    },
    [10] = {
        'medium-worm-turret',
        'medium-worm-turret',
        'big-worm-turret',
        'big-worm-turret',
        'big-worm-turret',
        'big-worm-turret'
    }
}
local rock_raffle = {
    'big-sand-rock',
    'big-sand-rock',
    'big-rock',
    'big-rock',
    'big-rock',
    'big-rock',
    'big-rock',
    'big-rock',
    'huge-rock'
}

local function spawn_obstacles(left_top, surface)
    if not storage.obstacle_start_x then
        storage.obstacle_start_x = math.abs(left_top.x) - 32
    end
    local current_depth = math.abs(left_top.x) - storage.obstacle_start_x
    local worm_amount = math.ceil(current_depth / 64)
    local i = math.ceil(current_depth / 256)
    if i > 10 then
        i = 10
    end
    if i < 1 then
        i = 1
    end
    local worm_raffle = worm_raffle_table[i]

    local rocks_amount = math.ceil(current_depth / 16)

    local tile_positions = {}
    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos = { x = left_top.x + x, y = left_top.y + y }
            if not surface.get_tile(pos).collides_with('player') then
                tile_positions[#tile_positions + 1] = pos
            end
        end
    end
    if #tile_positions == 0 then
        return
    end

    tile_positions = shuffle(tile_positions)
    for _, pos in pairs(tile_positions) do
        surface.create_entity({ name = worm_raffle[math_random(1, #worm_raffle)], position = pos, force = 'enemy' })
        worm_amount = worm_amount - 1
        if worm_amount < 1 then
            break
        end
    end

    tile_positions = shuffle(tile_positions)
    for _, pos in pairs(tile_positions) do
        surface.create_entity({ name = rock_raffle[math_random(1, #rock_raffle)], position = pos })
        rocks_amount = rocks_amount - 1
        if rocks_amount < 1 then
            break
        end
    end
end

local map_height = 96

local function on_chunk_generated(event)
    local surface = game.surfaces['fish_defender']

    if not surface then
        return
    end
    if surface.name ~= event.surface.name then
        return
    end

    local area = event.area
    local left_top = area.left_top

    if left_top.x <= -196 then
        local search_area = { { left_top.x - 32, left_top.y - 32 }, { left_top.x + 32, left_top.y + 32 } }
        if surface.count_tiles_filtered({ name = 'water', area = search_area }) == 0 and math_random(1, 64) == 1 then
            map_functions.draw_noise_tile_circle({ x = left_top.x + math_random(1, 30), y = left_top.y + math_random(1, 30) }, 'water', surface, math_random(6, 12))
        end

        if not storage.spawn_ores_generated then
            local spawn_position_x = -76

            surface.create_entity({ name = 'electric-beam', position = { 160, -96 }, source = { 160, -96 }, target = { 160, 96 } })

            local tiles = {}
            local replacement_tile = get_replacement_tile(surface)
            local water_tiles = surface.find_tiles_filtered({ name = { 'water', 'deepwater' } })

            for _, tile in pairs(water_tiles) do
                insert(tiles, { name = replacement_tile, position = { tile.position.x, tile.position.y } })
            end
            surface.set_tiles(tiles, true)

            local entities = surface.find_entities_filtered({ type = 'resource', area = { { -160, -96 }, { 160, 96 } } })
            for _, entity in pairs(entities) do
                entity.destroy()
            end

            local decorative_names = {}
            for k, v in pairs(prototypes.decorative) do
                if v.autoplace_specification then
                    decorative_names[#decorative_names + 1] = k
                end
            end
            for x = -4, 4, 1 do
                for y = -3, 3, 1 do
                    surface.regenerate_decorative(decorative_names, { { x, y } })
                end
            end

            local ore_positions = {
                { x = -128, y = -64 },
                { x = -128, y = -32 },
                { x = -128, y = 32 },
                { x = -128, y = 64 },
                { x = -128, y = 0 }
            }
            ore_positions = shuffle(ore_positions)
            map_functions.draw_smoothed_out_ore_circle(ore_positions[1], 'copper-ore', surface, 15, 2500)
            map_functions.draw_smoothed_out_ore_circle(ore_positions[2], 'iron-ore', surface, 15, 2500)
            map_functions.draw_smoothed_out_ore_circle(ore_positions[3], 'coal', surface, 15, 1500)
            map_functions.draw_smoothed_out_ore_circle(ore_positions[4], 'stone', surface, 15, 1500)
            map_functions.draw_noise_tile_circle({ x = -96, y = 0 }, 'water', surface, 16)
            map_functions.draw_oil_circle(ore_positions[5], 'crude-oil', surface, 8, 200000)

            local pos = surface.find_non_colliding_position('market', { spawn_position_x, 0 }, 50, 1)
            storage.market = place_fish_market(surface, pos)

            local pos = surface.find_non_colliding_position('gun-turret', { spawn_position_x + 5, 1 }, 50, 1)
            local turret = surface.create_entity({ name = 'gun-turret', position = pos, force = 'player' })
            turret.insert({ name = 'firearm-magazine', count = 32 })

            for x = -20, 20, 1 do
                for y = -20, 20, 1 do
                    local pos = { x = storage.market.position.x + x, y = storage.market.position.y + y }
                    local distance_to_center = math.sqrt(x ^ 2 + y ^ 2)
                    if distance_to_center > 8 and distance_to_center < 15 then
                        if math_random(1, 3) == 1 and surface.can_place_entity({ name = 'wooden-chest', position = pos, force = 'player' }) then
                            local chest = surface.create_entity({ name = 'wooden-chest', position = pos, force = 'player' })
                        end
                    end
                end
            end

            local area = { { x = -160, y = -96 }, { x = 160, y = 96 } }
            for _, tile in pairs(surface.find_tiles_filtered({ name = 'water', area = area })) do
                if math_random(1, 32) == 1 then
                    surface.create_entity({ name = 'fish', position = tile.position })
                end
            end

            local pos = surface.find_non_colliding_position('character', { spawn_position_x + 1, 4 }, 50, 1)
            game.forces['player'].set_spawn_position(pos, surface)
            for _, player in pairs(game.connected_players) do
                local pos = surface.find_non_colliding_position('character', { spawn_position_x + 1, 4 }, 50, 1)
                player.teleport(pos, surface)
            end

            storage.spawn_ores_generated = true
        end
    end

    local tiles = {}
    local hourglass_center_piece_length = 64

    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos = { x = left_top.x + x, y = left_top.y + y }
            if pos.y >= map_height then
                if pos.y > pos.x - hourglass_center_piece_length and pos.x > 0 then
                    insert(tiles, { name = 'out-of-map', position = pos })
                end
                if pos.y > (pos.x + hourglass_center_piece_length) * -1 and pos.x <= 0 then
                    insert(tiles, { name = 'out-of-map', position = pos })
                end
            end
            if pos.y < map_height * -1 then
                if pos.y < (pos.x - hourglass_center_piece_length) * -1 and pos.x > 0 then
                    insert(tiles, { name = 'out-of-map', position = pos })
                end
                if pos.y < pos.x + hourglass_center_piece_length and pos.x <= 0 then
                    insert(tiles, { name = 'out-of-map', position = pos })
                end
            end
        end
    end

    surface.set_tiles(tiles, false)

    for _, tile in pairs(surface.find_tiles_filtered({ name = 'water', area = event.area })) do
        if math_random(1, 32) == 1 then
            surface.create_entity({ name = 'fish', position = tile.position })
        end
    end

    if left_top.x < -2048 then
        spawn_obstacles(left_top, surface)
    end

    if left_top.x < 0 then
        return
    end

    for _, entity in pairs(surface.find_entities_filtered({ area = area, type = 'cliff' })) do
        entity.destroy()
    end

    if left_top.x < 160 then
        return
    end

    for _, entity in pairs(surface.find_entities_filtered({ area = area, type = 'tree' })) do
        entity.destroy()
    end

    for _, entity in pairs(surface.find_entities_filtered({ area = area, type = 'resource' })) do
        surface.create_entity({ name = 'uranium-ore', position = entity.position, amount = math_random(200, 8000) })
        entity.destroy()
    end

    local tiles = {}

    for x = 0, 31, 1 do
        for y = 0, 31, 1 do
            local pos = { x = left_top.x + x, y = left_top.y + y }

            local tile = surface.get_tile(pos)
            if tile.name ~= 'out-of-map' then
                if pos.x > 0 then
                    if pos.x > 320 then
                        insert(tiles, { name = 'out-of-map', position = pos })
                    else
                        local a = 0 + (pos.x - 160) * 0.01
                        local b = (pos.x - 160) * 0.035
                        local r = (pos.x - 160) * 0.015
                        if a > 0.75 then
                            a = 0.75
                        end
                        if b > 1 then
                            b = 1
                        end
                        if r > 0.6 then
                            r = 0.6
                        end
                        rendering.draw_sprite(
                            {
                                sprite = 'tile/lab-dark-2',
                                target = { pos.x + 0.5, pos.y + 0.5 },
                                surface = surface,
                                tint = { r = r, g = 0, b = b, a = a },
                                render_layer = 'ground'
                            }
                        )
                    end

                    if pos.x > 296 and pos.x < 312 and math_random(1, 128) == 1 then
                        if surface.can_place_entity({ name = 'biter-spawner', force = 'decoratives', position = pos }) then
                            local entity
                            if math_random(1, 4) == 1 then
                                entity = surface.create_entity({ name = 'spitter-spawner', force = 'decoratives', position = pos })
                            else
                                entity = surface.create_entity({ name = 'biter-spawner', force = 'decoratives', position = pos })
                            end
                            entity.active = false
                            entity.destructible = false
                        end
                    end
                end
            end
        end
    end
    surface.set_tiles(tiles, true)

    local decorative_names = {}
    for k, v in pairs(prototypes.decorative) do
        if v.autoplace_specification then
            decorative_names[#decorative_names + 1] = k
        end
    end
    surface.regenerate_decorative(decorative_names, { { x = math.floor(event.area.left_top.x / 32), y = math.floor(event.area.left_top.y / 32) } })
end

local function on_built_entity(event)
    local get_score = Score.get_table().score_table
    local entity = event.entity
    if not entity.valid then
        return
    end
    if storage.entity_limits[entity.name] then
        local surface = entity.surface

        if storage.entity_limits[entity.name].placed < storage.entity_limits[entity.name].limit then
            storage.entity_limits[entity.name].placed = storage.entity_limits[entity.name].placed + 1
            surface.create_entity(
                {
                    name = 'flying-text',
                    position = entity.position,
                    text = storage.entity_limits[entity.name].placed .. ' / ' .. storage.entity_limits[entity.name].limit .. ' ' .. storage.entity_limits[entity.name].str .. 's',
                    color = { r = 0.98, g = 0.66, b = 0.22 }
                }
            )
            update_fd_stats()
        else
            surface.create_entity(
                {
                    name = 'flying-text',
                    position = entity.position,
                    text = storage.entity_limits[entity.name].str .. ' limit reached.',
                    color = { r = 0.82, g = 0.11, b = 0.11 }
                }
            )
            local player = game.players[event.player_index]
            player.insert({ name = entity.name, count = 1 })
            if get_score then
                if get_score[player.force.name] then
                    if get_score[player.force.name].players[player.name] then
                        get_score[player.force.name].players[player.name].built_entities = get_score[player.force.name].players[player.name].built_entities - 1
                    end
                end
            end
            entity.destroy()
        end
    end
end

local function on_robot_built_entity(event)
    local entity = event.entity
    if storage.entity_limits[entity.name] then
        local surface = entity.surface
        if storage.entity_limits[entity.name].placed < storage.entity_limits[entity.name].limit then
            storage.entity_limits[entity.name].placed = storage.entity_limits[entity.name].placed + 1
            surface.create_entity(
                {
                    name = 'flying-text',
                    position = entity.position,
                    text = storage.entity_limits[entity.name].placed .. ' / ' .. storage.entity_limits[entity.name].limit .. ' ' .. storage.entity_limits[entity.name].str .. 's',
                    color = { r = 0.98, g = 0.66, b = 0.22 }
                }
            )
            update_fd_stats()
        else
            surface.create_entity(
                {
                    name = 'flying-text',
                    position = entity.position,
                    text = storage.entity_limits[entity.name].str .. ' limit reached.',
                    color = { r = 0.82, g = 0.11, b = 0.11 }
                }
            )
            local inventory = event.robot.get_inventory(defines.inventory.robot_cargo)
            inventory.insert({ name = entity.name, count = 1 })
            entity.destroy()
        end
    end
end

local function on_tick()
    local Diff = Difficulty.get()
    if game.tick % 30 == 0 then
        if storage.market then
            for _, player in pairs(game.connected_players) do
                if game.surfaces['fish_defender'].peaceful_mode == false then
                    create_wave_gui(player)
                end
            end
        end
        if game.tick % 180 == 0 then
            if game.surfaces['fish_defender'] then
                game.forces.player.chart(game.surfaces['fish_defender'], { { x = -64, y = -256 }, { x = 288, y = 256 } })
                if Diff.difficulty_vote_index then
                    storage.wave_interval = difficulties_votes[Diff.difficulty_vote_index].wave_interval
                end
            end
        end

        if storage.market_age then
            if not storage.game_restart_timer then
                storage.game_restart_timer = 10800
            else
                if storage.game_restart_timer < 0 then
                    return
                end
                storage.game_restart_timer = storage.game_restart_timer - 30
            end
            if storage.game_restart_timer % 1800 == 0 then
                if storage.game_restart_timer > 0 then
                    game.print('Map will restart in ' .. storage.game_restart_timer / 60 .. ' seconds!', { r = 0.22, g = 0.88, b = 0.22 })
                end
                if storage.game_restart_timer == 0 then
                    game.print('Map is restarting!', { r = 0.22, g = 0.88, b = 0.22 })
                    --game.write_file("commandPipe", ":loadscenario --force", false, 0)

                    local message = 'Map is restarting! '
                    Server.to_discord_bold(table.concat { '*** ', message, ' ***' })
                    Server.start_scenario('Fish_Defender')
                end
            end
        end
    end

    if game.tick % storage.wave_interval == storage.wave_interval - 1 then
        if game.surfaces['fish_defender'].peaceful_mode == true then
            return
        end
        biter_attack_wave()
    end
end

local function on_player_changed_position(event)
    local player = game.players[event.player_index]
    if player.position.x >= 160 then
        player.teleport({ player.position.x - 1, player.position.y }, game.surfaces['fish_defender'])
        if player.position.y > map_height or player.position.y < map_height * -1 then
            player.teleport({ player.position.x, 0 }, game.surfaces['fish_defender'])
        end
        if player.character then
            player.character.health = player.character.health - 25
            player.character.surface.create_entity({ name = 'water-splash', position = player.position })
            if player.character.health <= 0 then
                player.character.die('enemy')
            end
        end
    end
end

local function on_player_mined_entity(event)
    if storage.entity_limits[event.entity.name] then
        storage.entity_limits[event.entity.name].placed = storage.entity_limits[event.entity.name].placed - 1
        update_fd_stats()
    end
end

local function on_robot_mined_entity(event)
    if storage.entity_limits[event.entity.name] then
        storage.entity_limits[event.entity.name].placed = storage.entity_limits[event.entity.name].placed - 1
        update_fd_stats()
    end
end

local function on_research_finished(event)
    local research = event.research.name
    if research ~= 'tank' then
        return
    end
    game.forces['player'].technologies['artillery'].researched = true
    game.forces.player.recipes['artillery-wagon'].enabled = false
end

local function on_player_respawned(event)
    if not storage.market_age then
        return
    end
    local player = game.players[event.player_index]
    player.character.destructible = false
end

local function on_init(event)
    local Diff = Difficulty.get()
    storage.wave_interval = 3600 --interval between waves in ticks
    storage.wave_grace_period = 54000
    Diff.difficulty_poll_closing_timeout = 54000
    storage.boss_biters = {}
    storage.acid_lines_delay = {}
end

event.add(defines.events.on_gui_click, on_gui_click)
event.add(defines.events.on_market_item_purchased, on_market_item_purchased)
event.add(defines.events.on_player_respawned, on_player_respawned)
event.add(defines.events.on_built_entity, on_built_entity)
event.add(defines.events.on_chunk_generated, on_chunk_generated)
event.add(defines.events.on_entity_died, on_entity_died)
event.add(defines.events.on_player_changed_position, on_player_changed_position)
event.add(defines.events.on_player_joined_game, on_player_joined_game)
event.add(defines.events.on_player_mined_entity, on_player_mined_entity)
event.add(defines.events.on_research_finished, on_research_finished)
event.add(defines.events.on_robot_built_entity, on_robot_built_entity)
event.add(defines.events.on_robot_mined_entity, on_robot_mined_entity)
event.add(defines.events.on_tick, on_tick)
event.on_init(on_init)
