298 lines
9.7 KiB
Lua
298 lines
9.7 KiB
Lua
local me = require("me")
|
|
|
|
local util = {}
|
|
util.me = me
|
|
local regenerate_command = "bz-regenerate"
|
|
local list_command = "bz-list"
|
|
|
|
function decode(data)
|
|
if type(data) == "string" then return data end
|
|
local str = {}
|
|
for i = 2, #data do
|
|
str[i-1] = decode(data[i])
|
|
end
|
|
return table.concat(str, "")
|
|
end
|
|
|
|
function util.check_fluid_mining()
|
|
if me.fluid_mining then
|
|
for i, force in pairs(game.forces) do
|
|
if (
|
|
(force.technologies["uranium-processing"] and force.technologies["uranium-processing"].researched) or
|
|
(force.technologies["titanium-processing"] and force.technologies["titanium-processing"].researched) or
|
|
false
|
|
) then
|
|
force.technologies["fluid-mining"].researched = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function get_list()
|
|
local p = prototypes.item[me.name.."-list"]
|
|
if p then
|
|
data = p.localised_description
|
|
return decode(data)
|
|
end
|
|
end
|
|
|
|
function util.force_enable_recipe(event, recipe_name)
|
|
if game.players[event.player_index].force.recipes[recipe_name] then
|
|
game.players[event.player_index].force.recipes[recipe_name].enabled=true
|
|
end
|
|
end
|
|
|
|
function list(event)
|
|
if event.command and string.lower(event.command) == "bz-list" then
|
|
local player = game.players[event.player_index]
|
|
if player and player.connected then
|
|
local list = get_list()
|
|
if list and #list>0 then
|
|
local filename = util.me.name..".txt"
|
|
helpers.write_file(filename, list, false, event.player_index)
|
|
player.print("Wrote recipes to script-output/"..filename)
|
|
else
|
|
player.print("Please change your mod startup setting for this mod's modified recipes list.")
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function util.add_command_handler()
|
|
script.on_event(defines.events.on_console_command, route)
|
|
end
|
|
|
|
function route(event)
|
|
if event.command == regenerate_command then regenerate_ore(event) end
|
|
if event.command == list_command then list(event) end
|
|
end
|
|
|
|
function util.add_list_command_handler()
|
|
util.add_command_handler()
|
|
|
|
if not commands.commands[list_command] then
|
|
commands.add_command(list_command, "", function() end)
|
|
end
|
|
end
|
|
|
|
|
|
function util.warptorio2_expansion_helper()
|
|
if script.active_mods["warptorio2_expansion"] then
|
|
function check_container_for_items(container,items)
|
|
local has_all =true
|
|
for k=1,#items do
|
|
if container.get_item_count(items[k].name)<items[k].count then has_all=false break end
|
|
end
|
|
return has_all
|
|
end
|
|
|
|
function remove_items_from_container(container,items)
|
|
for k=1,#items do
|
|
container.remove_item(items[k])
|
|
end
|
|
end
|
|
|
|
script.on_nth_tick(60, function (event)
|
|
if global.done then return end
|
|
local fix_items={
|
|
{name='iron-plate',count=100},
|
|
{name='iron-gear-wheel',count=100},
|
|
{name='repair-pack',count=50},
|
|
}
|
|
local entities = {}
|
|
for i=1,100 do
|
|
if game.surfaces[i] then
|
|
local lentities= game.surfaces[i].find_entities_filtered{area = {{-100, -100}, {100, 100}}, name = "wpe_broken_lab"}
|
|
for j, entity in pairs(lentities) do
|
|
table.insert(entities, entity)
|
|
end
|
|
end
|
|
end
|
|
if #entities == 0 then
|
|
if global.checking then
|
|
-- The lab has already been fixed
|
|
global.done = true
|
|
else
|
|
-- Check that the lab doesn't reappear due to a warp
|
|
global.checking = true
|
|
end
|
|
return
|
|
end
|
|
if check_container_for_items(entities[1],fix_items) then
|
|
remove_items_from_container(entities[1],fix_items)
|
|
local lab = entities[1].surface.create_entity({name='wpe_repaired_lab', position=entities[1].position, force = game.forces.player})
|
|
lab.destructible=false
|
|
lab.minable=false
|
|
entities[1].destroy()
|
|
global.done = true
|
|
end
|
|
end)
|
|
end
|
|
end
|
|
|
|
local usage_regenerate = [[
|
|
Recommend saving the game before running this command.
|
|
Usage: /bz-regenerate all
|
|
or /bz-regenerate <planet> <resource> [<frequency> <size> <richness>]
|
|
planet must be an internal name like nauvis
|
|
resource must be an internal name like lead-ore or titanium-ore
|
|
frequency, size, and richness are optional, but all or none must be provided, and each should be a number between 0.166 and 6, where 1 is default setting.
|
|
Regenerates ore patches. If frequency/size/richness are provided, the planet will use those settings from now on, as well.
|
|
- Separate arguments with spaces, do not use < >, [ ], quotes or other symbols
|
|
- This action can take a while for larger maps!
|
|
- Ores can sometimes overlap on regeneration. This can sometimes hide ore patches. If none seem to be made for a resource, regenerate just that resource and tweak frequency/size.
|
|
]]
|
|
function util.add_regenerate_command_handler()
|
|
util.add_command_handler()
|
|
|
|
if not commands.commands[regenerate_command] then
|
|
commands.add_command( regenerate_command, usage_regenerate, function() end)
|
|
end
|
|
end
|
|
|
|
function regenerate_ore(event)
|
|
if event.command == regenerate_command then
|
|
local params = {}
|
|
for w in event.parameters:gmatch("%S+") do table.insert(params, w) end
|
|
if #params == 1 and params[1] == "all" then
|
|
for _, resource in pairs(me.resources) do
|
|
if prototypes.entity[resource[1]] then
|
|
game.print("Regenerating "..resource[1])
|
|
game.regenerate_entity(resource[1])
|
|
end
|
|
end
|
|
return
|
|
end
|
|
if not (#params == 2 or #params == 5) then
|
|
game.print(usage_regenerate)
|
|
return
|
|
end
|
|
local planet = params[1]
|
|
for _, resource in pairs(me.resources) do
|
|
if not game.surfaces[planet] then
|
|
game.print("Could not find surface for "..planet..". May not exist, or may not yet be explored.")
|
|
return
|
|
end
|
|
if resource[1] == params[2] and (resource[2] == planet or "tenebris" == planet) then
|
|
if #params == 5 then
|
|
local settings = {frequency=params[3], size=params[4], richness=params[5]}
|
|
local map_gen_settings = game.surfaces[planet].map_gen_settings
|
|
map_gen_settings.autoplace_controls[resource[1]] = settings
|
|
map_gen_settings.autoplace_settings.entity.settings[resource[1]] = settings
|
|
game.surfaces[planet].map_gen_settings = map_gen_settings
|
|
game.print("Set "..resource[1].." on "..planet.." to "..serpent.line(settings))
|
|
end
|
|
game.print("Regenerating "..resource[1])
|
|
game.surfaces[planet].regenerate_entity(resource[1])
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function util.ore_fix()
|
|
ore_fix("nauvis")
|
|
ore_fix("vulcanus")
|
|
if game.surfaces.tenebris then
|
|
ore_fix("tenebris")
|
|
end
|
|
end
|
|
|
|
function ore_fix(surface_name)
|
|
for _, resource in pairs(me.resources) do
|
|
if resource[2] == surface_name then
|
|
if game.surfaces[resource[2]] then
|
|
local map_gen_settings = game.surfaces[surface_name].map_gen_settings
|
|
if map_gen_settings.autoplace_controls[resource[1]] == nil then
|
|
map_gen_settings.autoplace_controls[resource[1]] = {}
|
|
end
|
|
if map_gen_settings.autoplace_settings.entity.settings[resource[1]] == nil then
|
|
map_gen_settings.autoplace_settings.entity.settings[resource[1]] = {}
|
|
end
|
|
game.surfaces[surface_name].map_gen_settings = map_gen_settings
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
-- A workaround for generating ores until this bug is fixed:
|
|
-- https://forums.factorio.com/viewtopic.php?f=7&t=124996&p=655013#p655013
|
|
function util.ore_workaround(event)
|
|
for i, ore in pairs(util.me.ores_for_workaround) do
|
|
if (
|
|
event.surface and
|
|
event.surface.map_gen_settings and
|
|
event.surface.map_gen_settings.autoplace_controls and
|
|
event.surface.map_gen_settings.autoplace_controls["titanium-ore"]
|
|
) then
|
|
return
|
|
end
|
|
if event.surface.name ~= "nauvis" then return end
|
|
if math.random() < settings.global[util.me.name.."-ore-workaround-probability"].value then
|
|
util.generate_ore(event, ore.name, ore.amount, ore.tiles)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- The majority of this function was written by Eradicator, see https://forums.factorio.com/viewtopic.php?t=72723
|
|
function util.generate_ore(event, name, amount, tiles)
|
|
local biases = {[0] = {[0] = 1}}
|
|
local t = 1
|
|
|
|
repeat
|
|
t = t + util.grow(biases,t,tiles)
|
|
until t >= tiles
|
|
|
|
local pos = {x=event.position.x*32, y=event.position.y*32}
|
|
local multiplier = math.max(math.abs(event.position.x), math.abs(event.position.y))
|
|
if multiplier < 10 then return end -- don't generate too close to start
|
|
local total_bias = 0
|
|
for x,_ in pairs(biases) do for y,bias in pairs(_) do
|
|
total_bias = total_bias + bias
|
|
end end
|
|
|
|
for x,_ in pairs(biases) do for y,bias in pairs(_) do
|
|
local entity = {
|
|
name = name,
|
|
amount = amount * (bias/total_bias) * multiplier,
|
|
force = 'neutral',
|
|
position = {pos.x+x,pos.y+y},
|
|
}
|
|
if event.surface.can_place_entity(entity) then
|
|
event.surface.create_entity(entity)
|
|
end
|
|
end end
|
|
|
|
end
|
|
|
|
-- The majority of this function was written by Eradicator, see https://forums.factorio.com/viewtopic.php?t=72723
|
|
function util.grow(grid,t,tiles)
|
|
local w_max = 256
|
|
local h_max = 256
|
|
local abs = math.abs
|
|
local old = {}
|
|
local new_count = 0
|
|
for x,_ in pairs(grid) do for y,__ in pairs(_) do
|
|
table.insert(old,{x,y})
|
|
end end
|
|
for _,pos in pairs(old) do
|
|
local x,y = pos[1],pos[2]
|
|
local bias = grid[x][y]
|
|
for dx=-1,1,1 do for dy=-1,1,1 do
|
|
local a,b = x+dx, y+dy
|
|
if (math.random() > 0.9) and (abs(a) < w_max) and (abs(b) < h_max) then
|
|
grid[a] = grid[a] or {}
|
|
if not grid[a][b] then
|
|
grid[a][b] = 1 - (t/tiles)
|
|
new_count = new_count + 1
|
|
if (new_count+t) == tiles then return new_count end
|
|
end
|
|
end
|
|
end end
|
|
end
|
|
return new_count
|
|
end
|
|
|
|
|
|
|
|
return util
|