if chunkUtilsG then
    return chunkUtilsG
end
local chunkUtils = {}

-- imports

local baseUtils = require("BaseUtils")
local constants = require("Constants")
local mapUtils = require("MapUtils")
local chunkPropertyUtils = require("ChunkPropertyUtils")

-- constants

local HIVE_BUILDINGS_TYPES = constants.HIVE_BUILDINGS_TYPES

local DEFINES_WIRE_TYPE_RED = defines.wire_type.red
local DEFINES_WIRE_TYPE_GREEN = defines.wire_type.green

local CHUNK_PASS_THRESHOLD = constants.CHUNK_PASS_THRESHOLD

local AI_STATE_ONSLAUGHT = constants.AI_STATE_ONSLAUGHT

local BASE_PHEROMONE = constants.BASE_PHEROMONE
local PLAYER_PHEROMONE = constants.PLAYER_PHEROMONE
local RESOURCE_PHEROMONE = constants.RESOURCE_PHEROMONE
local BASE_DETECTION_PHEROMONE = constants.BASE_DETECTION_PHEROMONE
local GENERATOR_PHEROMONE_LEVEL = constants.GENERATOR_PHEROMONE_LEVEL

local GET_ENTITY_PHEROMONES = constants.GET_ENTITY_PHEROMONES
local BUILDING_PHEROMONES = constants.BUILDING_PHEROMONES
local FACTORISSIMO_ENTITY = constants.FACTORISSIMO_ENTITY
local FACTORISSIMO_ENTITY_FEROMONE = constants.FACTORISSIMO_ENTITY_FEROMONE
	

local CHUNK_SIZE = constants.CHUNK_SIZE
local CHUNK_SIZE_DIVIDER = constants.CHUNK_SIZE_DIVIDER

local CHUNK_NORTH_SOUTH = constants.CHUNK_NORTH_SOUTH
local CHUNK_EAST_WEST = constants.CHUNK_EAST_WEST

local CHUNK_ALL_DIRECTIONS = constants.CHUNK_ALL_DIRECTIONS
local CHUNK_IMPASSABLE = constants.CHUNK_IMPASSABLE

local RESOURCE_NORMALIZER = constants.RESOURCE_NORMALIZER

local CHUNK_TICK = constants.CHUNK_TICK
local GLOBAL_LVLUP_COOLDOWN = constants.GLOBAL_LVLUP_COOLDOWN

local MAXIMUM_BASE_RADIUS = constants.MAXIMUM_BASE_RADIUS
local BASE_CHANGING_CHANCE = constants.BASE_CHANGING_CHANCE

local VANILLA_ENTITIES = constants.VANILLA_ENTITIES


-- imported functions

local setNestCount = chunkPropertyUtils.setNestCount
local setPlayerBaseGenerator = chunkPropertyUtils.setPlayerBaseGenerator
local addPlayerBaseGenerator = chunkPropertyUtils.addPlayerBaseGenerator


local setResourceGenerator = chunkPropertyUtils.setResourceGenerator
local addResourceGenerator = chunkPropertyUtils.addResourceGenerator
local setPlayerTurretCount = chunkPropertyUtils.setPlayerTurretCount
local setHiveCount = chunkPropertyUtils.setHiveCount
local setTrapCount = chunkPropertyUtils.setTrapCount
local setTurretCount = chunkPropertyUtils.setTurretCount
local setUtilityCount = chunkPropertyUtils.setUtilityCount
local getPlayerBaseGenerator = chunkPropertyUtils.getPlayerBaseGenerator
local getNestCount = chunkPropertyUtils.getNestCount
local getHiveCount = chunkPropertyUtils.getHiveCount
local getTrapCount = chunkPropertyUtils.getTrapCount
local getUtilityCount = chunkPropertyUtils.getUtilityCount
local getTurretCount = chunkPropertyUtils.getTurretCount
local setRaidNestActiveness = chunkPropertyUtils.setRaidNestActiveness
local setNestActiveness = chunkPropertyUtils.setNestActiveness

local processNestActiveness = chunkPropertyUtils.processNestActiveness

local getEnemyStructureCount = chunkPropertyUtils.getEnemyStructureCount

local findNearbyBase = baseUtils.findNearbyBase
local createBase = baseUtils.createBase
local upgradeEntity = baseUtils.upgradeEntity

local changeEntityAligment = baseUtils.changeEntityAligment
local changeEntityTier = baseUtils.changeEntityTier
local getDynamicRates = baseUtils.getDynamicRates
local changeEntityAndUpdateDynamicRates = baseUtils.changeEntityAndUpdateDynamicRates

local thisIsNewEnemyPosition = chunkPropertyUtils.thisIsNewEnemyPosition

local getChunkBase = chunkPropertyUtils.getChunkBase
local setChunkBase = chunkPropertyUtils.setChunkBase
local removeChunkBase = chunkPropertyUtils.removeChunkBase
local setPassable = chunkPropertyUtils.setPassable
local setPathRating = chunkPropertyUtils.setPathRating

local getChunkByXY = mapUtils.getChunkByXY

local mMin = math.min
local mMax = math.max
local mFloor = math.floor
local mRandom = math.random

-- module code

local function getEntityOverlapChunks(map, entity)
    local boundingBox = entity.prototype.collision_box or entity.prototype.selection_box;
    local overlapArray = map.universe.chunkOverlapArray

    overlapArray[1] = -1 --LeftTop
    overlapArray[2] = -1 --RightTop
    overlapArray[3] = -1 --LeftBottom
    overlapArray[4] = -1 --RightBottom

    if boundingBox then
        local center = entity.position
        local topXOffset
        local topYOffset

        local bottomXOffset
        local bottomYOffset

        topXOffset = boundingBox.left_top.x
        topYOffset = boundingBox.left_top.y
        bottomXOffset = boundingBox.right_bottom.x
        bottomYOffset = boundingBox.right_bottom.y

        local leftTopChunkX = mFloor((center.x + topXOffset) * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE
        local leftTopChunkY = mFloor((center.y + topYOffset) * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE

        local rightTopChunkX = mFloor((center.x + bottomXOffset) * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE
        local leftBottomChunkY = mFloor((center.y + bottomYOffset) * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE

        overlapArray[1] = getChunkByXY(map, leftTopChunkX, leftTopChunkY) -- LeftTop
        if (leftTopChunkX ~= rightTopChunkX) then
            overlapArray[2] = getChunkByXY(map, rightTopChunkX, leftTopChunkY) -- RightTop
        end
        if (leftTopChunkY ~= leftBottomChunkY) then
            overlapArray[3] = getChunkByXY(map, leftTopChunkX, leftBottomChunkY) -- LeftBottom
        end
        if (leftTopChunkX ~= rightTopChunkX) and (leftTopChunkY ~= leftBottomChunkY) then
            overlapArray[4] = getChunkByXY(map, rightTopChunkX, leftBottomChunkY) -- RightBottom
        end
    end
    return overlapArray
end

local function scanPaths(chunk, map)
    local surface = map.surface
    local pass = CHUNK_IMPASSABLE

    local x = chunk.x
    local y = chunk.y

    local universe = map.universe
    local filteredEntitiesCliffQuery = universe.filteredEntitiesCliffQuery
    local filteredTilesPathQuery = universe.filteredTilesPathQuery
    local count_entities_filtered = surface.count_entities_filtered
    local count_tiles_filtered = surface.count_tiles_filtered

    local passableNorthSouth = false
    local passableEastWest = false

    local topPosition = filteredEntitiesCliffQuery.area[1]
    local bottomPosition = filteredEntitiesCliffQuery.area[2]
    topPosition[2] = y
    bottomPosition[2] = y + 32

    for xi=x, x + 32 do
        topPosition[1] = xi
        bottomPosition[1] = xi + 1
        if (count_entities_filtered(filteredEntitiesCliffQuery) == 0) and
            (count_tiles_filtered(filteredTilesPathQuery) == 0)
        then
            passableNorthSouth = true
            break
        end
    end

    topPosition[1] = x
    bottomPosition[1] = x + 32

    for yi=y, y + 32 do
        topPosition[2] = yi
        bottomPosition[2] = yi + 1
        if (count_entities_filtered(filteredEntitiesCliffQuery) == 0) and
            (count_tiles_filtered(filteredTilesPathQuery) == 0)
        then
            passableEastWest = true
            break
        end
    end

    if passableEastWest and passableNorthSouth then
        pass = CHUNK_ALL_DIRECTIONS
    elseif passableEastWest then
        pass = CHUNK_EAST_WEST
    elseif passableNorthSouth then
        pass = CHUNK_NORTH_SOUTH
    end
    return pass
end

local function scorePlayerBuildings(map, chunk)
    local surface = map.surface
	local universe = map.universe
	local turretsCount = 0
	local pheromones = {}
	pheromones[BASE_PHEROMONE] = 0
	pheromones[BASE_DETECTION_PHEROMONE] = 0
    if surface.count_entities_filtered(universe.hasPlayerStructuresQuery) > 0 then
		for lvlName, values in pairs(GENERATOR_PHEROMONE_LEVEL) do
			local query = universe.filteredEntities_player_pheromones[lvlName]
			if query then
				local enityCnt = surface.count_entities_filtered(query)
				pheromones[BASE_PHEROMONE] = pheromones[BASE_PHEROMONE] + enityCnt*values[BASE_PHEROMONE]
				pheromones[BASE_DETECTION_PHEROMONE] = pheromones[BASE_DETECTION_PHEROMONE] + enityCnt*values[BASE_DETECTION_PHEROMONE]
				if lvlName == "turrets" then
					turretsCount = turretsCount + enityCnt
				end
			end	
		end
		
		local entities = surface.find_entities_filtered(universe.filteredEntitiesPlayerQueryFactorissimo)	-- 
		for i = 1, #entities do
			local entity = entities[i]
			if FACTORISSIMO_ENTITY(entity) then
				pheromones[BASE_PHEROMONE] = pheromones[BASE_PHEROMONE] + FACTORISSIMO_ENTITY_FEROMONE[BASE_PHEROMONE]			
				pheromones[BASE_DETECTION_PHEROMONE] = pheromones[BASE_DETECTION_PHEROMONE] + FACTORISSIMO_ENTITY_FEROMONE[BASE_DETECTION_PHEROMONE]			
			end
		end    
    end		
	setPlayerBaseGenerator(map, chunk, pheromones[BASE_PHEROMONE], BASE_PHEROMONE)
	setPlayerBaseGenerator(map, chunk, pheromones[BASE_DETECTION_PHEROMONE], BASE_DETECTION_PHEROMONE)
	setPlayerTurretCount(map, chunk, turretsCount)

	return pheromones[BASE_PHEROMONE]
end

function chunkUtils.initialScan(chunk, map, tick)
    local surface = map.surface
    local universe = map.universe
    local waterTiles = (1 - (surface.count_tiles_filtered(universe.filteredTilesQuery) * 0.0009765625)) * 0.80
    local enemyBuildings = surface.find_entities_filtered(universe.filteredEntitiesEnemyStructureQuery)

    if (waterTiles >= CHUNK_PASS_THRESHOLD) or (#enemyBuildings > 0) then
        local neutralObjects = mMax(0,
                                    mMin(1 - (surface.count_entities_filtered(universe.filteredEntitiesChunkNeutral) * 0.005),
                                         1) * 0.20)
        local pass = scanPaths(chunk, map)		
		
		local pheromones = scorePlayerBuildings(map, chunk)

        if ((pheromones > 0) or (#enemyBuildings > 0)) and (pass == CHUNK_IMPASSABLE) then
            pass = CHUNK_ALL_DIRECTIONS
        end

        if (pass ~= CHUNK_IMPASSABLE) then
            local resources = surface.count_entities_filtered(universe.countResourcesQuery) * RESOURCE_NORMALIZER

            local buildingHiveTypeLookup = universe.buildingHiveTypeLookup
            local counts = map.chunkScanCounts
            for i=1,#HIVE_BUILDINGS_TYPES do
                counts[HIVE_BUILDINGS_TYPES[i]] = 0
            end
			local unknownNests = 0
            if (#enemyBuildings > 0) then
				local thisIsRampantEnemy = false
				local base
                if universe.NEW_ENEMIES then
					base = findNearbyBase(map, chunk, MAXIMUM_BASE_RADIUS, BASE_CHANGING_CHANCE)
					if base then
						setChunkBase(map, chunk, base)
					else
						base = createBase(map, chunk, tick, thisIsNewEnemyPosition(universe, chunk.x, chunk.y))
					end
					thisIsRampantEnemy = base.thisIsRampantEnemy
				end
				
				if thisIsRampantEnemy then
					local alignment = base.alignment
						local unitList = surface.find_entities_filtered(universe.filteredEntitiesUnitQuery)
						for i=1,#unitList do
							local unit = unitList[i]
							if (unit.valid) then
								unit.destroy()
							end
						end

						for i = 1, #enemyBuildings do
							local enemyBuilding = enemyBuildings[i]							
							if not buildingHiveTypeLookup[enemyBuilding.name] then
								local newEntity
								if VANILLA_ENTITIES[enemyBuilding.name] or ((not universe.ALLOW_OTHER_ENEMIES) and (mRandom()<0.8)) then
									newEntity = upgradeEntity(enemyBuilding, alignment, map, nil, true)
								end	
								if newEntity then
									local hiveType = buildingHiveTypeLookup[newEntity.name]
									counts[hiveType] = counts[hiveType] + 1
								elseif (enemyBuilding and enemyBuilding.type == "unit-spawner") then
									unknownNests = unknownNests + 1
								end
							end
						end
						setNestCount(map, chunk, counts["spitter-spawner"] + counts["biter-spawner"]  + unknownNests)
						setUtilityCount(map, chunk, counts["utility"])
						setHiveCount(map, chunk, counts["hive"])
						setTrapCount(map, chunk, counts["trap"])
						setTurretCount(map, chunk, counts["turret"])
				
				else
                    for i=1,#enemyBuildings do
                        local building = enemyBuildings[i]
                        local hiveType = buildingHiveTypeLookup[building.name] or
                            ((building.type == "turret") and "turret")
							if hiveType then	
								counts[hiveType] = counts[hiveType] + 1
							elseif building.type == "unit-spawner" then
								unknownNests = unknownNests + 1
							end
                    end
                    setNestCount(map, chunk, counts["spitter-spawner"] + counts["biter-spawner"] + unknownNests)
					setTurretCount(map, chunk, counts["turret"])
				end				
				if map.suspended then
					map.suspended = false
					map.suspendCheckTick = tick
				end
			end	
								
            setResourceGenerator(map, chunk, resources)

            setPassable(map, chunk, pass)
            setPathRating(map, chunk, waterTiles + neutralObjects)

            return chunk
        end
    end

    return -1
end

function chunkUtils.chunkPassScan(chunk, map)
    local surface = map.surface
    local universe = map.universe
    local waterTiles = (1 - (surface.count_tiles_filtered(universe.filteredTilesQuery) * 0.0009765625)) * 0.80

    if (waterTiles >= CHUNK_PASS_THRESHOLD) then
        local neutralObjects = mMax(0,
                                    mMin(1 - (surface.count_entities_filtered(universe.filteredEntitiesChunkNeutral) * 0.005),
                                         1) * 0.20)
        local pass = scanPaths(chunk, map)

        local playerObjects = getPlayerBaseGenerator(map, chunk, BASE_PHEROMONE)

        local nests = getNestCount(map, chunk)

        if ((playerObjects > 0) or (nests > 0)) and (pass == CHUNK_IMPASSABLE) then
            pass = CHUNK_ALL_DIRECTIONS
        end

        setPassable(map, chunk, pass)
        setPathRating(map, chunk, waterTiles + neutralObjects)

        return chunk
    end

    return -1
end

function chunkUtils.mapScanPlayerChunk(chunk, map)
	scorePlayerBuildings(map, chunk)
end

function chunkUtils.mapScanResourceChunk(chunk, map)
    local surface = map.surface
    local universe = map.universe
    local resources = surface.count_entities_filtered(universe.countResourcesQuery) * RESOURCE_NORMALIZER
    setResourceGenerator(map, chunk, resources)
    local waterTiles = (1 - (surface.count_tiles_filtered(universe.filteredTilesQuery) * 0.0009765625)) * 0.80
    local neutralObjects = mMax(0,
                                mMin(1 - (surface.count_entities_filtered(universe.filteredEntitiesChunkNeutral) * 0.005),
                                     1) * 0.20)
    setPathRating(map, chunk, waterTiles + neutralObjects)
end

function chunkUtils.mapScanEnemyChunk(chunk, map)
    local universe = map.universe
    local buildingHiveTypeLookup = universe.buildingHiveTypeLookup
    local buildings = map.surface.find_entities_filtered(universe.filteredEntitiesEnemyStructureQuery)
    local counts = map.chunkScanCounts

    local FactionCounts = {}
	local enemyAlignmentLookup = universe.enemyAlignmentLookup
	local base = getChunkBase(map, chunk)
	local changingEntities = false
	local dynamicRates
	
	local baseTier = 1
	local newTier = 1
			
	local thisIsRampantEnemy = false
	if universe.NEW_ENEMIES and base and base.thisIsRampantEnemy then
		thisIsRampantEnemy = true
		changingEntities = base.changingEntities
		baseTier = mMax(base.tier-base.tierHandicap, 1)
		newTier = mMax(baseTier - mRandom(0, 2), 1)
	end	
	
	if changingEntities then
		dynamicRates = baseUtils.getDynamicRates(base)
	end	
	
    for i=1,#HIVE_BUILDINGS_TYPES do
        counts[HIVE_BUILDINGS_TYPES[i]] = 0
    end
		
	local mutatesCnt = 0	
	local maxMutations = 5
	local tick = game.tick
	
	local pendingMutations = universe.pendingMutations
	local pendingEntities = pendingMutations["entities"]
	local pendingChunks = pendingMutations["chunks"]
	local pendingEntitiesCnt = 0
	local chunkIndex = "x"..chunk.x.."y"..chunk.y.."m"..map.surface.index
	
	local buildingsCnt = #buildings
	
    for i=1,#buildings do
        local building = buildings[i]
        local newBuilding
		-- mutation and upgrade--
		if thisIsRampantEnemy and (not pendingChunks[chunkIndex]) and building.valid then
			if changingEntities then
				if ((chunk.nextMutationTick  or 0) < tick) and (buildingHiveTypeLookup[building.name] or (building.type == "turret")) then
					-- if mutatesCnt>maxMutations then
						pendingEntitiesCnt = pendingEntitiesCnt + 1
						local entityData = {
							["chunkIndex"] = chunkIndex,
							["surfaceIndex"] = map.surface.index,
							["base"] = base,
							["entity"] = building
						}
						pendingEntities[building.unit_number] = entityData 
					-- else
						-- newBuilding = changeEntityAndUpdateDynamicRates(building, dynamicRates, map, base)
						-- if newBuilding then
							-- mutatesCnt = mutatesCnt + 1
							-- building = newBuilding
						-- end
					-- end
				end
			else
				local oldTier = universe.buildingTierLookup[building.name]
				if oldTier and (oldTier<newTier) and (universe.lvlupTick<=tick) then
					local roll = mRandom()
					if roll < 0.01 then
						--local oldName = building.name
						newBuilding = changeEntityTier(building, newTier, map)
						if newBuilding then
							--game.print("chunkUtils.mapScanEnemyChunk. Changing tier:"..oldName.."->"..newBuilding.name)	-- debug
							universe.lvlupTick = tick + GLOBAL_LVLUP_COOLDOWN
							building = newBuilding
						end
					end
				end
			end
		end			
		
		-----
		if building.valid then	
			local hiveType = buildingHiveTypeLookup[building.name] or
				(((building.type == "turret") and "turret") 
					or ((building.type =="unit-spawner") and "biter-spawner")
				)	
			counts[hiveType] = counts[hiveType] + 1
			
			
			if universe.NEW_ENEMIES then
				if building.type =="unit-spawner" then
					local faction = enemyAlignmentLookup[building.name]
					if faction then
						FactionCounts[faction] = (FactionCounts[faction] or 0) + 1
					end
				end	
			end
		end	
    end

	if pendingEntitiesCnt > 0 then
		pendingChunks[chunkIndex] = pendingEntitiesCnt
	end
	
	if (mutatesCnt > 0) or (pendingEntitiesCnt > 0) then
		chunk.nextMutationTick = tick + mMin(pendingEntitiesCnt + mutatesCnt, 20)*1800
	end

		
	if universe.NEW_ENEMIES then		
		if (buildingsCnt > 0) and not base then
 			base = findNearbyBase(map, chunk, MAXIMUM_BASE_RADIUS, BASE_CHANGING_CHANCE)
			if base then
				setChunkBase(map, chunk, base)
			else
				local FactionCountsIterator = next(FactionCounts, nil)
				if FactionCountsIterator then
					base = createBase(map, chunk, game.tick, true)
				else	
					base = createBase(map, chunk, game.tick, thisIsNewEnemyPosition(universe, chunk.x, chunk.y))
				end	
				setChunkBase(map, chunk, base)
			end
			thisIsRampantEnemy = base.thisIsRampantEnemy
		----------------	
		end
		if (buildingsCnt == 0) and base then
			removeChunkBase(map, chunk, base)
		end
	end	


    setNestCount(map, chunk, counts["spitter-spawner"] + counts["biter-spawner"])
    setUtilityCount(map, chunk, counts["utility"])
    setHiveCount(map, chunk, counts["hive"])
    setTrapCount(map, chunk, counts["trap"])
    setTurretCount(map, chunk, counts["turret"])

	if universe.NEW_ENEMIES and thisIsRampantEnemy then
		local baseChunkFactions = {}

		if base then
			base.chunkFactions[chunk] = FactionCounts
		end	
	end	
	
	if map.suspended and (counts["spitter-spawner"] + counts["biter-spawner"] > 0) then
		map.suspended = false
		map.suspendCheckTick = game.tick
	end
end

function chunkUtils.entityForPassScan(map, entity)
    local overlapArray = getEntityOverlapChunks(map, entity)

    for i=1,#overlapArray do
        local chunk = overlapArray[i]
        if (chunk ~= -1) then
			local chunkData = {chunk.x, chunk.y, map.surface.index}
			local chunkIndex = "x"..chunkData[1].."y"..chunkData[2].."m"..chunkData[3]
            map.universe.chunkToPassScan[chunkIndex] = chunkData
        end
    end
end

function chunkUtils.createChunk(topX, topY)
    local chunk = {
        x = topX,
        y = topY
    }
    chunk[BASE_PHEROMONE] = 0
    chunk[BASE_DETECTION_PHEROMONE] = 0	-- + !КДА
    chunk[PLAYER_PHEROMONE] = 0
    chunk[RESOURCE_PHEROMONE] = 0
    chunk[CHUNK_TICK] = 0
    chunk["deathLevel"] = nil	

    return chunk
end

function chunkUtils.colorChunk(chunk, surface, color)
    local lx = math.floor(chunk.x * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE
    local ly = math.floor(chunk.y * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE

    rendering.draw_rectangle({
            color = color or {0.1, 0.3, 0.1, 0.6},
            width = 32 * 32,
            filled = true,
            left_top = {lx, ly},
            right_bottom = {lx+32, ly+32},
            surface = surface,
            time_to_live = 180,
            draw_on_ground = true,
            visible = true
    })
end

function chunkUtils.colorXY(x, y, surface, color)
    local lx = math.floor(x * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE
    local ly = math.floor(y * CHUNK_SIZE_DIVIDER) * CHUNK_SIZE

    rendering.draw_rectangle({
            color = color or {0.1, 0.3, 0.1, 0.6},
            width = 32 * 32,
            filled = true,
            left_top = {lx, ly},
            right_bottom = {lx+32, ly+32},
            surface = surface,
            time_to_live = 180,
            draw_on_ground = true,
            visible = true
    })
end


function chunkUtils.registerEnemyBaseStructure(map, entity, base)
    local entityType = entity.type
    if ((entityType == "unit-spawner") or (entityType == "turret")) and (entity.force.name == "enemy") then
        local overlapArray = getEntityOverlapChunks(map, entity)

        local getFunc
        local setFunc
        local universe = map.universe
        local hiveTypeLookup = universe.buildingHiveTypeLookup
        local hiveType = hiveTypeLookup[entity.name]
        if (hiveType == "spitter-spawner") or (hiveType == "biter-spawner") then
            map.builtEnemyBuilding = map.builtEnemyBuilding + 1
            getFunc = getNestCount
            setFunc = setNestCount
        elseif (hiveType == "turret") then
            map.builtEnemyBuilding = map.builtEnemyBuilding + 1
            getFunc = getTurretCount
            setFunc = setTurretCount
        elseif (hiveType == "trap") then
            getFunc = getTrapCount
            setFunc = setTrapCount
        elseif (hiveType == "utility") then
            map.builtEnemyBuilding = map.builtEnemyBuilding + 1
            getFunc = getUtilityCount
            setFunc = setUtilityCount
        elseif (hiveType == "hive") then
            map.builtEnemyBuilding = map.builtEnemyBuilding + 1
            getFunc = getHiveCount
            setFunc = setHiveCount
        else
            if (entityType == "turret") then
                map.builtEnemyBuilding = map.builtEnemyBuilding + 1
                getFunc = getTurretCount
                setFunc = setTurretCount
            elseif (entityType == "unit-spawner") then
                map.builtEnemyBuilding = map.builtEnemyBuilding + 1
                getFunc = getNestCount
                setFunc = setNestCount
            end
        end

        for i=1,#overlapArray do
            local chunk = overlapArray[i]
			if (chunk ~= -1) then
				setFunc(map, chunk, getFunc(map, chunk) + 1)
				if base then
					setChunkBase(map, chunk, base)
				end	
				processNestActiveness(map, chunk)
           end
        end
    end

    return entity
end

function chunkUtils.unregisterEnemyBaseStructure(map, entity, damageType)
    local entityType = entity.type
    if ((entityType == "unit-spawner") or (entityType == "turret")) and (entity.force.name == "enemy") then
        local overlapArray = getEntityOverlapChunks(map, entity)
        local getFunc
        local setFunc
        local hiveTypeLookup = map.universe.buildingHiveTypeLookup
        local hiveType = hiveTypeLookup[entity.name]
        if (hiveType == "spitter-spawner") or (hiveType == "biter-spawner") then
            map.lostEnemyBuilding = map.lostEnemyBuilding + 1
            getFunc = getNestCount
            setFunc = setNestCount
        elseif (hiveType == "turret") then
            map.lostEnemyBuilding = map.lostEnemyBuilding + 1
            getFunc = getTurretCount
            setFunc = setTurretCount
        elseif (hiveType == "trap") then
            getFunc = getTrapCount
            setFunc = setTrapCount
        elseif (hiveType == "utility") then
            map.lostEnemyBuilding = map.lostEnemyBuilding + 1
            getFunc = getUtilityCount
            setFunc = setUtilityCount
        elseif (hiveType == "hive") then
            map.lostEnemyBuilding = map.lostEnemyBuilding + 1
            getFunc = getHiveCount
            setFunc = setHiveCount
        else
            if (entityType == "turret") then
                map.lostEnemyBuilding = map.lostEnemyBuilding + 1
                getFunc = getTurretCount
                setFunc = setTurretCount
            elseif (entityType == "unit-spawner") then
                hiveType = "biter-spawner"
                map.lostEnemyBuilding = map.lostEnemyBuilding + 1
                getFunc = getNestCount
                setFunc = setNestCount
            end
        end

        for i=1,#overlapArray do
            local chunk = overlapArray[i]
			if (chunk ~= -1) then
				local count = getFunc(map, chunk)
				if count then
					if (count <= 1) then
						if (hiveType == "spitter-spawner") or (hiveType == "biter-spawner") then
							setRaidNestActiveness(map, chunk, 0)
							setNestActiveness(map, chunk, 0)
						end
						setFunc(map, chunk, 0)
						if (getEnemyStructureCount(map, chunk) == 0) then
							removeChunkBase(map, chunk)
						end
					else
						setFunc(map, chunk, count - 1)
					end
				end
			end
		end
    end
end

local function ignoredForce(force, universe)
	local forceIgnored = true
	for i = 1, #universe.activePlayerForces do
		if universe.activePlayerForces[i] == force.name then
			forceIgnored = false
			break
		end
	end
	return forceIgnored
end

function chunkUtils.accountPlayerEntity(entity, map, addObject, creditNatives)
	if ignoredForce(entity.force, map.universe) then
		return
	end	
	local GENERATOR_PHEROMONE_LEVEL = constants.GENERATOR_PHEROMONE_LEVEL
	local pointsToAccount = {BASE_PHEROMONE, BASE_DETECTION_PHEROMONE}
	for i = 1, #pointsToAccount do
		local pheromoneType = pointsToAccount[i]
		if (entity.force.name ~= "enemy") then
			local universe = map.universe
			local entityValue = GET_ENTITY_PHEROMONES(entity, pheromoneType)
			local overlapArray = getEntityOverlapChunks(map, entity)
			if not addObject then
				if (creditNatives) and (pheromoneType==BASE_PHEROMONE) then					
					if entity.type ~= "wall" then	-- + !КДА 2021.11
						map.destroyPlayerBuildings = map.destroyPlayerBuildings + 1
						if universe.aiDifficulty == "Hard" then
							if (map.state == AI_STATE_ONSLAUGHT) then
								map.points = map.points + entityValue
								if universe.aiPointsPrintGainsToChat then
									game.print(map.surface.name .. ": Points: +" .. math.floor(entityValue) .. ". [Structure Kill] Total: " .. string.format("%.2f", map.points))
								end
							else
								map.points = map.points + entityValue * 0.12
								if universe.aiPointsPrintGainsToChat then
									game.print(map.surface.name .. ": Points: +" .. math.floor(entityValue * 0.12) .. ". [Structure Kill] Total: " .. string.format("%.2f", map.points))
								end
							end
						end	
					end
				end					
				entityValue = -entityValue
			end

			for i=1,#overlapArray do
				local chunk = overlapArray[i]
				if chunk ~= -1 then
					addPlayerBaseGenerator(map, chunk, entityValue, pheromoneType)
				end
			end	
		end	
	end	
    return entity
end

function chunkUtils.unregisterResource(entity, map)
    if entity.prototype.infinite_resource then
        return
    end
    local overlapArray = getEntityOverlapChunks(map, entity)

    for i=1,#overlapArray do
        local chunk = overlapArray[i]
        if (chunk ~= -1) then
            addResourceGenerator(map, chunk, -RESOURCE_NORMALIZER)
        end
    end
end

function chunkUtils.registerResource(entity, map)
    local overlapArray = getEntityOverlapChunks(map, entity)

    for i=1,#overlapArray do
        local chunk = overlapArray[i]
        if (chunk ~= -1) then
            addResourceGenerator(map, chunk, RESOURCE_NORMALIZER)
        end
    end
end

function chunkUtils.makeImmortalEntity(surface, entity)
    local repairPosition = entity.position
    local repairName = entity.name
    local repairForce = entity.force
    local repairDirection = entity.direction

    local wires
    if (entity.type == "electric-pole") then
        wires = entity.neighbours
    end
    entity.destroy()
    local newEntity = surface.create_entity({position=repairPosition,
                                             name=repairName,
                                             direction=repairDirection,
                                             force=repairForce})
    if wires then
        for _,v in pairs(wires.copper) do
            if (v.valid) then
                newEntity.connect_neighbour(v);
            end
        end
        for _,v in pairs(wires.red) do
            if (v.valid) then
                newEntity.connect_neighbour({wire = DEFINES_WIRE_TYPE_RED, target_entity = v});
            end
        end
        for _,v in pairs(wires.green) do
            if (v.valid) then
                newEntity.connect_neighbour({wire = DEFINES_WIRE_TYPE_GREEN, target_entity = v});
            end
        end
    end

    newEntity.destructible = false
end

chunkUtilsG = chunkUtils
return chunkUtils