mirror of
https://github.com/veden/Rampant.git
synced 2025-02-11 13:39:05 +02:00
602 lines
19 KiB
Lua
Executable File
602 lines
19 KiB
Lua
Executable File
local chunkUtils = {}
|
|
|
|
-- imports
|
|
|
|
local constants = require("Constants")
|
|
local mapUtils = require("MapUtils")
|
|
|
|
-- constants
|
|
|
|
local WATER_TILE_NAMES = constants.WATER_TILE_NAMES
|
|
|
|
local DEFINES_DIRECTION_EAST = defines.direction.east
|
|
local DEFINES_WIRE_TYPE_RED = defines.wire_type.red
|
|
local DEFINES_WIRE_TYPE_GREEN = defines.wire_type.green
|
|
|
|
local SENTINEL_IMPASSABLE_CHUNK = constants.SENTINEL_IMPASSABLE_CHUNK
|
|
|
|
local BASE_PHEROMONE = constants.BASE_PHEROMONE
|
|
local PLAYER_PHEROMONE = constants.PLAYER_PHEROMONE
|
|
local MOVEMENT_PHEROMONE = constants.MOVEMENT_PHEROMONE
|
|
local RESOURCE_PHEROMONE = constants.RESOURCE_PHEROMONE
|
|
local BUILDING_PHEROMONES = constants.BUILDING_PHEROMONES
|
|
|
|
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 CHUNK_TICK = constants.CHUNK_TICK
|
|
|
|
local PATH_RATING = constants.PATH_RATING
|
|
|
|
local PASSABLE = constants.PASSABLE
|
|
|
|
local RESOURCE_GENERATOR_INCREMENT = constants.RESOURCE_GENERATOR_INCREMENT
|
|
|
|
-- imported functions
|
|
|
|
local getChunkByUnalignedXY = mapUtils.getChunkByUnalignedXY
|
|
|
|
local mFloor = math.floor
|
|
|
|
-- module code
|
|
|
|
local function fullScan(chunk, can_place_entity, canPlaceQuery)
|
|
local x = chunk.x
|
|
local y = chunk.y
|
|
|
|
local passableNorthSouth = false
|
|
local passableEastWest = false
|
|
|
|
canPlaceQuery.name = "chunk-scanner-ns-rampant"
|
|
|
|
local position = canPlaceQuery.position
|
|
position[2] = y
|
|
|
|
for xi=x, x + 32 do
|
|
position[1] = xi
|
|
if can_place_entity(canPlaceQuery) then
|
|
passableNorthSouth = true
|
|
break
|
|
end
|
|
end
|
|
|
|
position[1] = x
|
|
canPlaceQuery.name = "chunk-scanner-ew-rampant"
|
|
|
|
for yi=y, y + 32 do
|
|
position[2] = yi
|
|
if can_place_entity(canPlaceQuery) then
|
|
passableEastWest = true
|
|
break
|
|
end
|
|
end
|
|
return passableNorthSouth, passableEastWest
|
|
end
|
|
|
|
local function addEnemyStructureToChunk(regionMap, chunk, entity, base)
|
|
local lookup
|
|
if (entity.type == "unit-spawner") then
|
|
lookup = regionMap.chunkToNests
|
|
elseif (entity.type == "turret") then
|
|
lookup = regionMap.chunkToWorms
|
|
else
|
|
return
|
|
end
|
|
|
|
local entityCollection = lookup[chunk]
|
|
if not entityCollection then
|
|
lookup[chunk] = 0
|
|
end
|
|
lookup[chunk] = lookup[chunk] + 1
|
|
|
|
-- if base then
|
|
-- local baseCollection = regionMap.chunkToBases[chunk]
|
|
-- if not baseCollection then
|
|
-- baseCollection = {}
|
|
-- regionMap.chunkToBases[chunk] = baseCollection
|
|
-- end
|
|
-- baseCollection[base.id] = chunk
|
|
-- end
|
|
|
|
end
|
|
|
|
local function removeEnemyStructureFromChunk(regionMap, chunk, entity)
|
|
local lookup
|
|
if (entity.type == "unit-spawner") then
|
|
lookup = regionMap.chunkToNests
|
|
elseif (entity.type == "turret") then
|
|
lookup = regionMap.chunkToWorms
|
|
else
|
|
return
|
|
end
|
|
|
|
-- local base = indexChunk[entity.unit_number]
|
|
-- local indexBase
|
|
-- if base then
|
|
-- if (entity.type == "unit-spawner") then
|
|
-- if base.hives[entity.unit_number] then
|
|
-- indexBase = base.hives
|
|
-- else
|
|
-- indexBase = base.nests
|
|
-- end
|
|
-- elseif (entity.type == "turret") then
|
|
-- indexBase = base.worms
|
|
-- end
|
|
-- indexBase[entity.unit_number] = nil
|
|
-- end
|
|
|
|
if lookup[chunk] then
|
|
if ((lookup[chunk] - 1) <= 0) then
|
|
lookup[chunk] = nil
|
|
else
|
|
lookup[chunk] = lookup[chunk] - 1
|
|
end
|
|
end
|
|
end
|
|
|
|
local function getEntityOverlapChunks(regionMap, entity)
|
|
local boundingBox = entity.prototype.collision_box or entity.prototype.selection_box;
|
|
|
|
local leftTopChunk = SENTINEL_IMPASSABLE_CHUNK
|
|
local rightTopChunk = SENTINEL_IMPASSABLE_CHUNK
|
|
local leftBottomChunk = SENTINEL_IMPASSABLE_CHUNK
|
|
local rightBottomChunk = SENTINEL_IMPASSABLE_CHUNK
|
|
|
|
if boundingBox then
|
|
local center = entity.position
|
|
local topXOffset
|
|
local topYOffset
|
|
|
|
local bottomXOffset
|
|
local bottomYOffset
|
|
|
|
if (entity.direction == DEFINES_DIRECTION_EAST) then
|
|
topXOffset = boundingBox.left_top.y
|
|
topYOffset = boundingBox.left_top.x
|
|
bottomXOffset = boundingBox.right_bottom.y
|
|
bottomYOffset = boundingBox.right_bottom.x
|
|
else
|
|
topXOffset = boundingBox.left_top.x
|
|
topYOffset = boundingBox.left_top.y
|
|
bottomXOffset = boundingBox.right_bottom.x
|
|
bottomYOffset = boundingBox.right_bottom.y
|
|
end
|
|
|
|
local leftTopChunkX = mFloor(center.x + topXOffset)
|
|
local leftTopChunkY = mFloor(center.y + topYOffset)
|
|
|
|
-- used to force things on chunk boundary to not spill over 0.0001
|
|
local rightTopChunkX = mFloor(center.x + bottomXOffset - 0.0001)
|
|
local rightTopChunkY = leftTopChunkY
|
|
|
|
-- used to force things on chunk boundary to not spill over 0.0001
|
|
local leftBottomChunkX = leftTopChunkX
|
|
local leftBottomChunkY = mFloor(center.y + bottomYOffset - 0.0001)
|
|
|
|
local rightBottomChunkX = rightTopChunkX
|
|
local rightBottomChunkY = leftBottomChunkY
|
|
|
|
leftTopChunk = getChunkByUnalignedXY(regionMap, leftTopChunkX, leftTopChunkY)
|
|
if (leftTopChunkX ~= rightTopChunkX) then
|
|
rightTopChunk = getChunkByUnalignedXY(regionMap, rightTopChunkX, rightTopChunkY)
|
|
end
|
|
if (leftTopChunkY ~= leftBottomChunkY) then
|
|
leftBottomChunk = getChunkByUnalignedXY(regionMap, leftBottomChunkX, leftBottomChunkY)
|
|
end
|
|
if (leftTopChunkX ~= rightBottomChunkX) and (leftTopChunkY ~= rightBottomChunkY) then
|
|
rightBottomChunk = getChunkByUnalignedXY(regionMap, rightBottomChunkX, rightBottomChunkY)
|
|
end
|
|
end
|
|
return leftTopChunk, rightTopChunk, leftBottomChunk, rightBottomChunk
|
|
end
|
|
|
|
-- external functions
|
|
|
|
function chunkUtils.calculatePassScore(surface, regionMap)
|
|
local count_tiles_filtered = surface.count_tiles_filtered
|
|
local filteredTilesQuery = regionMap.filteredTilesQuery
|
|
|
|
local passScore = 0
|
|
for i=1,#WATER_TILE_NAMES do
|
|
filteredTilesQuery.name = WATER_TILE_NAMES[i]
|
|
passScore = passScore + count_tiles_filtered(filteredTilesQuery)
|
|
end
|
|
|
|
return 1 - (passScore * 0.0009765625)
|
|
end
|
|
|
|
function chunkUtils.scanChunkPaths(chunk, surface, regionMap)
|
|
local pass = CHUNK_IMPASSABLE
|
|
local passableNorthSouth, passableEastWest = fullScan(chunk,
|
|
surface.can_place_entity,
|
|
regionMap.canPlaceQuery)
|
|
|
|
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
|
|
|
|
function chunkUtils.scorePlayerBuildings(surface, regionMap, natives)
|
|
local entities = surface.find_entities_filtered(regionMap.filteredEntitiesPlayerQuery)
|
|
|
|
local playerObjects = 0
|
|
local safeBuildings = natives.safeBuildings
|
|
local safeEntities = natives.safeEntities
|
|
local safeEntityName = natives.safeEntityName
|
|
if safeBuildings then
|
|
for i=1, #entities do
|
|
local entity = entities[i]
|
|
local entityType = entity.type
|
|
|
|
if safeEntities[entityType] or safeEntityName[entity.name] then
|
|
entity.destructible = false
|
|
end
|
|
|
|
playerObjects = playerObjects + (BUILDING_PHEROMONES[entityType] or 0)
|
|
end
|
|
else
|
|
for i=1, #entities do
|
|
playerObjects = playerObjects + (BUILDING_PHEROMONES[entities[i].type] or 0)
|
|
end
|
|
end
|
|
|
|
return playerObjects
|
|
end
|
|
|
|
function chunkUtils.scoreEnemyBuildings(surface, regionMap)
|
|
local query = regionMap.filteredEntitiesEnemyTypeQuery
|
|
|
|
query.type = "unit-spawner"
|
|
local nests = surface.count_entities_filtered(regionMap.filteredEntitiesEnemyTypeQuery)
|
|
|
|
query.type = "turret"
|
|
local worms = surface.count_entities_filtered(regionMap.filteredEntitiesEnemyTypeQuery)
|
|
|
|
return nests, worms
|
|
end
|
|
|
|
function chunkUtils.initialScan(chunk, natives, surface, regionMap)
|
|
local passScore = chunkUtils.calculatePassScore(surface, regionMap)
|
|
|
|
if (passScore >= 0.40) then
|
|
local pass = chunkUtils.scanChunkPaths(chunk, surface, regionMap)
|
|
|
|
local playerObjects = chunkUtils.scorePlayerBuildings(surface, regionMap, natives)
|
|
|
|
local nests, worms = chunkUtils.scoreEnemyBuildings(surface, regionMap)
|
|
|
|
local resources = surface.count_entities_filtered(regionMap.countResourcesQuery) * 0.001
|
|
|
|
if ((playerObjects > 0) or (nests > 0)) and (pass == CHUNK_IMPASSABLE) then
|
|
pass = CHUNK_ALL_DIRECTIONS
|
|
end
|
|
|
|
chunkUtils.setNestCount(regionMap, chunk, nests)
|
|
chunkUtils.setPlayerBaseGenerator(regionMap, chunk, playerObjects)
|
|
chunkUtils.setResourceGenerator(regionMap, chunk, resources)
|
|
chunkUtils.setWormCount(regionMap, chunk, worms)
|
|
|
|
chunk[PASSABLE] = pass
|
|
chunk[PATH_RATING] = passScore
|
|
|
|
return chunk
|
|
end
|
|
|
|
return SENTINEL_IMPASSABLE_CHUNK
|
|
end
|
|
|
|
function chunkUtils.chunkPassScan(chunk, surface, regionMap)
|
|
local passScore = chunkUtils.calculatePassScore(surface, regionMap)
|
|
|
|
if (passScore >= 0.40) then
|
|
local pass = chunkUtils.scanChunkPaths(chunk, surface, regionMap)
|
|
|
|
local playerObjects = chunkUtils.getPlayerBaseGenerator(regionMap, chunk)
|
|
|
|
local nests = chunkUtils.getNestCount(regionMap, chunk)
|
|
|
|
if ((playerObjects > 0) or (nests > 0)) and (pass == CHUNK_IMPASSABLE) then
|
|
pass = CHUNK_ALL_DIRECTIONS
|
|
end
|
|
|
|
chunk[PASSABLE] = pass
|
|
chunk[PATH_RATING] = passScore
|
|
|
|
return chunk
|
|
end
|
|
|
|
return SENTINEL_IMPASSABLE_CHUNK
|
|
end
|
|
|
|
function chunkUtils.analyzeChunk(chunk, natives, surface, regionMap)
|
|
local playerObjects = chunkUtils.scorePlayerBuildings(surface, regionMap, natives)
|
|
chunkUtils.setPlayerBaseGenerator(regionMap, chunk, playerObjects)
|
|
end
|
|
|
|
-- function chunkUtils.remakeChunk(regionMap, chunk, surface, natives, tick, tempQuery)
|
|
-- tempQuery.force = "enemy"
|
|
-- local enemies = surface.find_entities_filtered(tempQuery)
|
|
|
|
-- local points = 0
|
|
-- for f=1, #enemies do
|
|
-- local enemy = enemies[f]
|
|
-- local entityType = enemies[f].type
|
|
-- if not ((enemy.name == "small-tendril-biter-rampant") or (enemy.name == "biter-spawner-hive-rampant")) then
|
|
-- if (entityType == "unit-spawner") then
|
|
-- points = points + 3
|
|
-- elseif (entityType == "turret") then
|
|
-- points = points + 2
|
|
-- elseif (entityType == "unit") then
|
|
-- points = points + 1
|
|
-- end
|
|
-- enemy.destroy()
|
|
-- end
|
|
-- end
|
|
-- -- local foundBase = findNearbyBase(natives, chunk) or createBase(regionMap, natives, chunk, surface, tick)
|
|
-- -- if foundBase then
|
|
-- -- foundBase.upgradePoints = foundBase.upgradePoints + points
|
|
-- -- end
|
|
-- end
|
|
|
|
function chunkUtils.getNestCount(regionMap, chunk)
|
|
return regionMap.chunkToNests[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.getWormCount(regionMap, chunk)
|
|
return regionMap.chunkToWorms[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.setWormCount(regionMap, chunk, count)
|
|
if (count == 0) then
|
|
regionMap.chunkToWorms[chunk] = nil
|
|
else
|
|
regionMap.chunkToWorms[chunk] = count
|
|
end
|
|
end
|
|
|
|
function chunkUtils.setNestCount(regionMap, chunk, count)
|
|
if (count == 0) then
|
|
regionMap.chunkToNests[chunk] = nil
|
|
else
|
|
regionMap.chunkToNests[chunk] = count
|
|
end
|
|
end
|
|
|
|
function chunkUtils.getNestCount(regionMap, chunk)
|
|
return regionMap.chunkToNests[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.getWormCount(regionMap, chunk)
|
|
return regionMap.chunkToWorms[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.getEnemyStructureCount(regionMap, chunk)
|
|
return (regionMap.chunkToNests[chunk] or 0) + (regionMap.chunkToWorms[chunk] or 0)
|
|
end
|
|
|
|
function chunkUtils.getRetreatTick(regionMap, chunk)
|
|
return regionMap.chunkToRetreats[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.getRallyTick(regionMap, chunk)
|
|
return regionMap.chunkToRallys[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.setRallyTick(regionMap, chunk, tick)
|
|
regionMap.chunkToRallys[chunk] = tick
|
|
end
|
|
|
|
function chunkUtils.setRetreatTick(regionMap, chunk, tick)
|
|
regionMap.chunkToRetreats[chunk] = tick
|
|
end
|
|
|
|
function chunkUtils.setResourceGenerator(regionMap, chunk, resourceGenerator)
|
|
if (resourceGenerator == 0) then
|
|
regionMap.chunkToResource[chunk] = nil
|
|
else
|
|
regionMap.chunkToResource[chunk] = resourceGenerator
|
|
end
|
|
end
|
|
|
|
function chunkUtils.getResourceGenerator(regionMap, chunk)
|
|
return regionMap.chunkToResource[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.addResourceGenerator(regionMap, chunk, delta)
|
|
regionMap.chunkToResource[chunk] = (regionMap.chunkToResource[chunk] or 0) + delta
|
|
end
|
|
|
|
function chunkUtils.getPlayerBaseGenerator(regionMap, chunk)
|
|
return regionMap.chunkToPlayerBase[chunk] or 0
|
|
end
|
|
|
|
function chunkUtils.setPlayerBaseGenerator(regionMap, chunk, playerGenerator)
|
|
if (playerGenerator == 0) then
|
|
regionMap.chunkToPlayerBase[chunk] = nil
|
|
else
|
|
regionMap.chunkToPlayerBase[chunk] = playerGenerator
|
|
end
|
|
end
|
|
|
|
function chunkUtils.addPlayerBaseGenerator(regionMap, chunk, playerGenerator)
|
|
regionMap.chunkToPlayerBase[chunk] = (regionMap.chunkToPlayerBase[chunk] or 0) + playerGenerator
|
|
end
|
|
|
|
function chunkUtils.createChunk(topX, topY)
|
|
local chunk = {
|
|
x = topX,
|
|
y = topY
|
|
}
|
|
chunk[MOVEMENT_PHEROMONE] = 0
|
|
chunk[BASE_PHEROMONE] = 0
|
|
chunk[PLAYER_PHEROMONE] = 0
|
|
chunk[RESOURCE_PHEROMONE] = 0
|
|
chunk[PASSABLE] = 0
|
|
chunk[CHUNK_TICK] = 0
|
|
chunk[PATH_RATING] = 0
|
|
|
|
return chunk
|
|
end
|
|
|
|
function chunkUtils.colorChunk(x, y, tileType, surface)
|
|
local tiles = {}
|
|
for xi=x+5, x + 27 do
|
|
for yi=y+5, y + 27 do
|
|
tiles[#tiles+1] = {name=tileType, position={xi, yi}}
|
|
end
|
|
end
|
|
surface.set_tiles(tiles, false)
|
|
end
|
|
|
|
function chunkUtils.entityForPassScan(regionMap, entity)
|
|
local leftTop, rightTop, leftBottom, rightBottom = getEntityOverlapChunks(regionMap, entity)
|
|
|
|
if (leftTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
regionMap.chunkToPassScan[leftTop] = true
|
|
end
|
|
if (rightTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
regionMap.chunkToPassScan[rightTop] = true
|
|
end
|
|
if (leftBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
regionMap.chunkToPassScan[leftBottom] = true
|
|
end
|
|
if (rightBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
regionMap.chunkToPassScan[rightBottom] = true
|
|
end
|
|
end
|
|
|
|
function chunkUtils.registerEnemyBaseStructure(regionMap, entity, base)
|
|
local entityType = entity.type
|
|
if ((entityType == "unit-spawner") or (entityType == "turret")) and (entity.force.name == "enemy") then
|
|
local leftTop, rightTop, leftBottom, rightBottom = getEntityOverlapChunks(regionMap, entity)
|
|
|
|
if (leftTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
addEnemyStructureToChunk(regionMap, leftTop, entity, base)
|
|
end
|
|
if (rightTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
addEnemyStructureToChunk(regionMap, rightTop, entity, base)
|
|
end
|
|
if (leftBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
addEnemyStructureToChunk(regionMap, leftBottom, entity, base)
|
|
end
|
|
if (rightBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
addEnemyStructureToChunk(regionMap, rightBottom, entity, base)
|
|
end
|
|
end
|
|
end
|
|
|
|
function chunkUtils.unregisterEnemyBaseStructure(regionMap, entity)
|
|
local entityType = entity.type
|
|
if ((entityType == "unit-spawner") or (entityType == "turret")) and (entity.force.name == "enemy") then
|
|
local leftTop, rightTop, leftBottom, rightBottom = getEntityOverlapChunks(regionMap, entity)
|
|
|
|
if (leftTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
removeEnemyStructureFromChunk(regionMap, leftTop, entity)
|
|
end
|
|
if (rightTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
removeEnemyStructureFromChunk(regionMap, rightTop, entity)
|
|
end
|
|
if (leftBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
removeEnemyStructureFromChunk(regionMap, leftBottom, entity)
|
|
end
|
|
if (rightBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
removeEnemyStructureFromChunk(regionMap, rightBottom, entity)
|
|
end
|
|
end
|
|
end
|
|
|
|
function chunkUtils.addRemovePlayerEntity(regionMap, entity, natives, addObject, creditNatives)
|
|
local leftTop, rightTop, leftBottom, rightBottom
|
|
local entityValue
|
|
if (BUILDING_PHEROMONES[entity.type] ~= nil) and (entity.force.name == "player") then
|
|
entityValue = BUILDING_PHEROMONES[entity.type]
|
|
|
|
leftTop, rightTop, leftBottom, rightBottom = getEntityOverlapChunks(regionMap, entity)
|
|
if not addObject then
|
|
if creditNatives then
|
|
natives.points = natives.points + entityValue
|
|
end
|
|
entityValue = -entityValue
|
|
end
|
|
if (leftTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addPlayerBaseGenerator(regionMap, leftTop, entityValue)
|
|
end
|
|
if (rightTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addPlayerBaseGenerator(regionMap, rightTop, entityValue)
|
|
end
|
|
if (leftBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addPlayerBaseGenerator(regionMap, leftBottom, entityValue)
|
|
end
|
|
if (rightBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addPlayerBaseGenerator(regionMap, rightBottom, entityValue)
|
|
end
|
|
end
|
|
return entity
|
|
end
|
|
|
|
function chunkUtils.unregisterResource(entity, regionMap)
|
|
if entity.prototype.infinite_resource then
|
|
return
|
|
end
|
|
local leftTop, rightTop, leftBottom, rightBottom = getEntityOverlapChunks(regionMap, entity)
|
|
|
|
if (leftTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addResourceGenerator(regionMap, leftTop, -RESOURCE_GENERATOR_INCREMENT)
|
|
end
|
|
if (rightTop ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addResourceGenerator(regionMap, rightTop, -RESOURCE_GENERATOR_INCREMENT)
|
|
end
|
|
if (leftBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addResourceGenerator(regionMap, leftBottom, -RESOURCE_GENERATOR_INCREMENT)
|
|
end
|
|
if (rightBottom ~= SENTINEL_IMPASSABLE_CHUNK) then
|
|
chunkUtils.addResourceGenerator(regionMap, rightBottom, -RESOURCE_GENERATOR_INCREMENT)
|
|
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 connectType,neighbourGroup in pairs(wires) do
|
|
if connectType == "copper" then
|
|
for _,v in pairs(neighbourGroup) do
|
|
newEntity.connect_neighbour(v);
|
|
end
|
|
elseif connectType == "red" then
|
|
for _,v in pairs(neighbourGroup) do
|
|
newEntity.connect_neighbour({wire = DEFINES_WIRE_TYPE_RED, target_entity = v});
|
|
end
|
|
elseif connectType == "green" then
|
|
for _,v in pairs(neighbourGroup) do
|
|
newEntity.connect_neighbour({wire = DEFINES_WIRE_TYPE_GREEN, target_entity = v});
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
newEntity.destructible = false
|
|
end
|
|
|
|
return chunkUtils
|