135 lines
4.8 KiB
Lua
135 lines
4.8 KiB
Lua
local common = {}
|
|
|
|
local floor, ceil = math.floor, math.ceil
|
|
local min, max = math.min, math.max
|
|
|
|
---@param miner MinerStruct
|
|
function common.simple_miner_placement(miner)
|
|
local near, far, size, fullsize = miner.near, miner.far, miner.size, miner.full_size
|
|
local neighbor_cap = (near + 1) ^ 2
|
|
local leech = (far + 1) ^ 2
|
|
|
|
---@param center GridTile
|
|
return function(center)
|
|
return center.neighbor_count > neighbor_cap
|
|
-- return center.neighbor_count > neighbor_cap or center.far_neighbor_count > leech
|
|
end
|
|
end
|
|
|
|
---@param miner MinerStruct
|
|
function common.overfill_miner_placement(miner)
|
|
local near, far, size, fullsize = miner.near, miner.far, miner.size, miner.full_size
|
|
local neighbor_cap = (near + 1) ^ 2 - 1
|
|
local leech = far ^ 2 - 1
|
|
|
|
---@param center GridTile
|
|
return function(center)
|
|
return center.neighbor_count > 0 or center.far_neighbor_count > leech
|
|
end
|
|
end
|
|
|
|
---@param attempt PlacementAttempt
|
|
function common.simple_layout_heuristic(attempt)
|
|
--local lane_weigth = 0.05 * ((#attempt.lane_layout) ^ (1/3) - 1) + 1
|
|
return attempt.simple_density / attempt.miner_count + attempt.empty_space / attempt.miner_count
|
|
--return attempt.simple_density / attempt.miner_count * lane_weigth
|
|
--return (attempt.real_density - attempt.simple_density) -- * math.log(#attempt.lane_layout)
|
|
end
|
|
|
|
---@param attempt PlacementAttempt
|
|
function common.overfill_layout_heuristic(attempt)
|
|
--return (attempt.simple_density-attempt.real_density) / attempt.miner_count
|
|
--return attempt.simple_density - attempt.real_density -- * math.log(#attempt.lane_layout)
|
|
return -attempt.far_neighbor_sum
|
|
end
|
|
|
|
---Utility to fill in postponed miners on unconsumed resources
|
|
---@param state SimpleState
|
|
---@param heuristics PlacementAttempt
|
|
---@param miners MinerPlacement[]
|
|
---@param postponed MinerPlacement[]
|
|
function common.process_postponed(state, heuristics, miners, postponed)
|
|
local grid = state.grid
|
|
local size, near, far, fullsize = state.miner.size, state.miner.near, state.miner.far, state.miner.full_size
|
|
|
|
for _, miner in ipairs(miners) do
|
|
grid:consume(miner.center.x, miner.center.y)
|
|
end
|
|
|
|
for _, miner in ipairs(postponed) do
|
|
local center = miner.center
|
|
miner.unconsumed = grid:get_unconsumed(center.x, center.y)
|
|
end
|
|
|
|
table.sort(postponed, function(a, b)
|
|
if a.unconsumed == b.unconsumed then
|
|
local a_center, b_center = a.center, b.center
|
|
if a_center.neighbor_count == b_center.neighbor_count then
|
|
return a_center.far_neighbor_count > b_center.far_neighbor_count
|
|
end
|
|
return a_center.neighbor_count > b_center.neighbor_count
|
|
end
|
|
return a.unconsumed > b.unconsumed
|
|
end)
|
|
|
|
for _, miner in ipairs(postponed) do
|
|
local center = miner.center
|
|
local unconsumed_count = grid:get_unconsumed(center.x, center.y)
|
|
if unconsumed_count > 0 then
|
|
heuristics.neighbor_sum = heuristics.neighbor_sum + center.neighbor_count
|
|
heuristics.far_neighbor_sum = heuristics.far_neighbor_sum + center.far_neighbor_count
|
|
heuristics.empty_space = heuristics.empty_space + (size^2) - center.neighbor_count
|
|
heuristics.simple_density = heuristics.simple_density + center.neighbor_count / (size ^ 2)
|
|
heuristics.real_density = heuristics.real_density + center.far_neighbor_count / (fullsize ^ 2)
|
|
heuristics.leech_sum = heuristics.leech_sum + max(0, center.far_neighbor_count - center.neighbor_count)
|
|
heuristics.postponed_count = heuristics.postponed_count + 1
|
|
|
|
grid:consume(center.x, center.y)
|
|
miners[#miners+1] = miner
|
|
heuristics.miner_count = heuristics.miner_count + 1
|
|
miner.postponed = true
|
|
end
|
|
end
|
|
local unconsumed_sum = 0
|
|
for _, tile in ipairs(state.resource_tiles) do
|
|
if not tile.consumed then unconsumed_sum = unconsumed_sum + 1 end
|
|
end
|
|
heuristics.unconsumed_count = unconsumed_sum
|
|
|
|
grid:clear_consumed(state.resource_tiles)
|
|
end
|
|
|
|
local seed
|
|
local function get_map_seed()
|
|
if seed then return seed end
|
|
|
|
local game_exchange_string = game.get_map_exchange_string()
|
|
local map_data = game.parse_map_exchange_string(game_exchange_string)
|
|
|
|
local seed_number = map_data.map_gen_settings.seed
|
|
seed = string.format("%x", seed_number)
|
|
return seed
|
|
end
|
|
|
|
---Dump state to json for inspection
|
|
---@param state SimpleState
|
|
function common.save_state_to_file(state, type_)
|
|
|
|
local c = state.coords
|
|
local gx, gy = floor(c.gx), floor(c.gy)
|
|
local dir = state.direction_choice
|
|
|
|
local coverage = state.coverage_choice and "t" or "f"
|
|
local filename = string.format("layout_%s_%i;%i_%s_%i_%s_%s_%x.%s", get_map_seed(), gx, gy, state.miner_choice, #state.resources, dir, coverage, game.tick, type_)
|
|
|
|
if type_ == "json" then
|
|
game.print(string.format("Dumped data to %s ", filename))
|
|
game.write_file("mpp-inspect/"..filename, game.table_to_json(state), false, state.player.index)
|
|
elseif type_ == "lua" then
|
|
game.print(string.format("Dumped data to %s ", filename))
|
|
game.write_file("mpp-inspect/"..filename, serpent.dump(state, {}), false, state.player.index)
|
|
end
|
|
end
|
|
|
|
return common
|